?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented Rtl*ByteSwap() functions, based on a patch by Jon
[wine/multimedia.git] / dlls / oleaut32 / variant.c
blob035351c887cbd0797769a08aebc1f11b3808ea55
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 * VarBoolFromUI1 [OLEAUT32.118]
3638 */
3639 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL* pboolOut)
3640 {
3641 TRACE("( %d, %p ), stub\n", bIn, pboolOut );
3642
3643 if( bIn == 0 )
3644 {
3645 *pboolOut = VARIANT_FALSE;
3646 }
3647 else
3648 {
3649 *pboolOut = VARIANT_TRUE;
3650 }
3651
3652 return S_OK;
3653 }
3654
3655 /******************************************************************************
3656 * VarBoolFromI2 [OLEAUT32.119]
3657 */
3658 HRESULT WINAPI VarBoolFromI2(short sIn, VARIANT_BOOL* pboolOut)
3659 {
3660 TRACE("( %d, %p ), stub\n", sIn, pboolOut );
3661
3662 *pboolOut = (sIn) ? VARIANT_TRUE : VARIANT_FALSE;
3663
3664 return S_OK;
3665 }
3666
3667 /******************************************************************************
3668 * VarBoolFromI4 [OLEAUT32.120]
3669 */
3670 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL* pboolOut)
3671 {
3672 TRACE("( %ld, %p ), stub\n", lIn, pboolOut );
3673
3674 *pboolOut = (lIn) ? VARIANT_TRUE : VARIANT_FALSE;
3675
3676 return S_OK;
3677 }
3678
3679 /******************************************************************************
3680 * VarBoolFromR4 [OLEAUT32.121]
3681 */
3682 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL* pboolOut)
3683 {
3684 TRACE("( %f, %p ), stub\n", fltIn, pboolOut );
3685
3686 *pboolOut = (fltIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3687
3688 return S_OK;
3689 }
3690
3691 /******************************************************************************
3692 * VarBoolFromR8 [OLEAUT32.122]
3693 */
3694 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL* pboolOut)
3695 {
3696 TRACE("( %f, %p ), stub\n", dblIn, pboolOut );
3697
3698 *pboolOut = (dblIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3699
3700 return S_OK;
3701 }
3702
3703 /******************************************************************************
3704 * VarBoolFromDate [OLEAUT32.123]
3705 */
3706 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL* pboolOut)
3707 {
3708 TRACE("( %f, %p ), stub\n", dateIn, pboolOut );
3709
3710 *pboolOut = (dateIn == 0.0) ? VARIANT_FALSE : VARIANT_TRUE;
3711
3712 return S_OK;
3713 }
3714
3715 /******************************************************************************
3716 * VarBoolFromStr [OLEAUT32.125]
3717 */
3718 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL* pboolOut)
3719 {
3720 HRESULT ret = S_OK;
3721 char* pNewString = NULL;
3722
3723 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pboolOut );
3724
3725 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3726
3727 if( pNewString == NULL || strlen( pNewString ) == 0 )
3728 {
3729 ret = DISP_E_TYPEMISMATCH;
3730 }
3731
3732 if( ret == S_OK )
3733 {
3734 if( strncasecmp( pNewString, "True", strlen( pNewString ) ) == 0 )
3735 {
3736 *pboolOut = VARIANT_TRUE;
3737 }
3738 else if( strncasecmp( pNewString, "False", strlen( pNewString ) ) == 0 )
3739 {
3740 *pboolOut = VARIANT_FALSE;
3741 }
3742 else
3743 {
3744 /* Try converting the string to a floating point number.
3745 */
3746 double dValue = 0.0;
3747 HRESULT res = VarR8FromStr( strIn, lcid, dwFlags, &dValue );
3748 if( res != S_OK )
3749 {
3750 ret = DISP_E_TYPEMISMATCH;
3751 }
3752 else
3753 *pboolOut = (dValue == 0.0) ?
3754 VARIANT_FALSE : VARIANT_TRUE;
3755 }
3756 }
3757
3758 HeapFree( GetProcessHeap(), 0, pNewString );
3759
3760 return ret;
3761 }
3762
3763 /******************************************************************************
3764 * VarBoolFromI1 [OLEAUT32.233]
3765 */
3766 HRESULT WINAPI VarBoolFromI1(CHAR cIn, VARIANT_BOOL* pboolOut)
3767 {
3768 TRACE("( %c, %p ), stub\n", cIn, pboolOut );
3769
3770 *pboolOut = (cIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3771
3772 return S_OK;
3773 }
3774
3775 /******************************************************************************
3776 * VarBoolFromUI2 [OLEAUT32.234]
3777 */
3778 HRESULT WINAPI VarBoolFromUI2(USHORT uiIn, VARIANT_BOOL* pboolOut)
3779 {
3780 TRACE("( %d, %p ), stub\n", uiIn, pboolOut );
3781
3782 *pboolOut = (uiIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3783
3784 return S_OK;
3785 }
3786
3787 /******************************************************************************
3788 * VarBoolFromUI4 [OLEAUT32.235]
3789 */
3790 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL* pboolOut)
3791 {
3792 TRACE("( %ld, %p ), stub\n", ulIn, pboolOut );
3793
3794 *pboolOut = (ulIn == 0) ? VARIANT_FALSE : VARIANT_TRUE;
3795
3796 return S_OK;
3797 }
3798
3799 /**********************************************************************
3800 * VarBoolFromCy [OLEAUT32.124]
3801 * Convert currency to boolean
3802 */
3803 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL* pboolOut) {
3804 if (cyIn.s.Hi || cyIn.s.Lo) *pboolOut = -1;
3805 else *pboolOut = 0;
3806
3807 return S_OK;
3808 }
3809
3810 /******************************************************************************
3811 * VarI1FromUI1 [OLEAUT32.244]
3812 */
3813 HRESULT WINAPI VarI1FromUI1(BYTE bIn, CHAR* pcOut)
3814 {
3815 TRACE("( %d, %p ), stub\n", bIn, pcOut );
3816
3817 /* Check range of value.
3818 */
3819 if( bIn > CHAR_MAX )
3820 {
3821 return DISP_E_OVERFLOW;
3822 }
3823
3824 *pcOut = (CHAR) bIn;
3825
3826 return S_OK;
3827 }
3828
3829 /******************************************************************************
3830 * VarI1FromI2 [OLEAUT32.245]
3831 */
3832 HRESULT WINAPI VarI1FromI2(short uiIn, CHAR* pcOut)
3833 {
3834 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3835
3836 if( uiIn > CHAR_MAX )
3837 {
3838 return DISP_E_OVERFLOW;
3839 }
3840
3841 *pcOut = (CHAR) uiIn;
3842
3843 return S_OK;
3844 }
3845
3846 /******************************************************************************
3847 * VarI1FromI4 [OLEAUT32.246]
3848 */
3849 HRESULT WINAPI VarI1FromI4(LONG lIn, CHAR* pcOut)
3850 {
3851 TRACE("( %ld, %p ), stub\n", lIn, pcOut );
3852
3853 if( lIn < CHAR_MIN || lIn > CHAR_MAX )
3854 {
3855 return DISP_E_OVERFLOW;
3856 }
3857
3858 *pcOut = (CHAR) lIn;
3859
3860 return S_OK;
3861 }
3862
3863 /******************************************************************************
3864 * VarI1FromR4 [OLEAUT32.247]
3865 */
3866 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, CHAR* pcOut)
3867 {
3868 TRACE("( %f, %p ), stub\n", fltIn, pcOut );
3869
3870 fltIn = round( fltIn );
3871 if( fltIn < CHAR_MIN || fltIn > CHAR_MAX )
3872 {
3873 return DISP_E_OVERFLOW;
3874 }
3875
3876 *pcOut = (CHAR) fltIn;
3877
3878 return S_OK;
3879 }
3880
3881 /******************************************************************************
3882 * VarI1FromR8 [OLEAUT32.248]
3883 */
3884 HRESULT WINAPI VarI1FromR8(double dblIn, CHAR* pcOut)
3885 {
3886 TRACE("( %f, %p ), stub\n", dblIn, pcOut );
3887
3888 dblIn = round( dblIn );
3889 if( dblIn < CHAR_MIN || dblIn > CHAR_MAX )
3890 {
3891 return DISP_E_OVERFLOW;
3892 }
3893
3894 *pcOut = (CHAR) dblIn;
3895
3896 return S_OK;
3897 }
3898
3899 /******************************************************************************
3900 * VarI1FromDate [OLEAUT32.249]
3901 */
3902 HRESULT WINAPI VarI1FromDate(DATE dateIn, CHAR* pcOut)
3903 {
3904 TRACE("( %f, %p ), stub\n", dateIn, pcOut );
3905
3906 dateIn = round( dateIn );
3907 if( dateIn < CHAR_MIN || dateIn > CHAR_MAX )
3908 {
3909 return DISP_E_OVERFLOW;
3910 }
3911
3912 *pcOut = (CHAR) dateIn;
3913
3914 return S_OK;
3915 }
3916
3917 /******************************************************************************
3918 * VarI1FromStr [OLEAUT32.251]
3919 */
3920 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CHAR* pcOut)
3921 {
3922 double dValue = 0.0;
3923 LPSTR pNewString = NULL;
3924
3925 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pcOut );
3926
3927 /* Check if we have a valid argument
3928 */
3929 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
3930 RemoveCharacterFromString( pNewString, "," );
3931 if( IsValidRealString( pNewString ) == FALSE )
3932 {
3933 return DISP_E_TYPEMISMATCH;
3934 }
3935
3936 /* Convert the valid string to a floating point number.
3937 */
3938 dValue = atof( pNewString );
3939
3940 /* We don't need the string anymore so free it.
3941 */
3942 HeapFree( GetProcessHeap(), 0, pNewString );
3943
3944 /* Check range of value.
3945 */
3946 dValue = round( dValue );
3947 if( dValue < CHAR_MIN || dValue > CHAR_MAX )
3948 {
3949 return DISP_E_OVERFLOW;
3950 }
3951
3952 *pcOut = (CHAR) dValue;
3953
3954 return S_OK;
3955 }
3956
3957 /******************************************************************************
3958 * VarI1FromBool [OLEAUT32.253]
3959 */
3960 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, CHAR* pcOut)
3961 {
3962 TRACE("( %d, %p ), stub\n", boolIn, pcOut );
3963
3964 *pcOut = (CHAR) boolIn;
3965
3966 return S_OK;
3967 }
3968
3969 /******************************************************************************
3970 * VarI1FromUI2 [OLEAUT32.254]
3971 */
3972 HRESULT WINAPI VarI1FromUI2(USHORT uiIn, CHAR* pcOut)
3973 {
3974 TRACE("( %d, %p ), stub\n", uiIn, pcOut );
3975
3976 if( uiIn > CHAR_MAX )
3977 {
3978 return DISP_E_OVERFLOW;
3979 }
3980
3981 *pcOut = (CHAR) uiIn;
3982
3983 return S_OK;
3984 }
3985
3986 /******************************************************************************
3987 * VarI1FromUI4 [OLEAUT32.255]
3988 */
3989 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, CHAR* pcOut)
3990 {
3991 TRACE("( %ld, %p ), stub\n", ulIn, pcOut );
3992
3993 if( ulIn > CHAR_MAX )
3994 {
3995 return DISP_E_OVERFLOW;
3996 }
3997
3998 *pcOut = (CHAR) ulIn;
3999
4000 return S_OK;
4001 }
4002
4003 /**********************************************************************
4004 * VarI1FromCy [OLEAUT32.250]
4005 * Convert currency to signed char
4006 */
4007 HRESULT WINAPI VarI1FromCy(CY cyIn, CHAR* pcOut) {
4008 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4009
4010 if (t > CHAR_MAX || t < CHAR_MIN) return DISP_E_OVERFLOW;
4011
4012 *pcOut = (CHAR)t;
4013 return S_OK;
4014 }
4015
4016 /******************************************************************************
4017 * VarUI2FromUI1 [OLEAUT32.257]
4018 */
4019 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* puiOut)
4020 {
4021 TRACE("( %d, %p ), stub\n", bIn, puiOut );
4022
4023 *puiOut = (USHORT) bIn;
4024
4025 return S_OK;
4026 }
4027
4028 /******************************************************************************
4029 * VarUI2FromI2 [OLEAUT32.258]
4030 */
4031 HRESULT WINAPI VarUI2FromI2(short uiIn, USHORT* puiOut)
4032 {
4033 TRACE("( %d, %p ), stub\n", uiIn, puiOut );
4034
4035 if( uiIn < UI2_MIN )
4036 {
4037 return DISP_E_OVERFLOW;
4038 }
4039
4040 *puiOut = (USHORT) uiIn;
4041
4042 return S_OK;
4043 }
4044
4045 /******************************************************************************
4046 * VarUI2FromI4 [OLEAUT32.259]
4047 */
4048 HRESULT WINAPI VarUI2FromI4(LONG lIn, USHORT* puiOut)
4049 {
4050 TRACE("( %ld, %p ), stub\n", lIn, puiOut );
4051
4052 if( lIn < UI2_MIN || lIn > UI2_MAX )
4053 {
4054 return DISP_E_OVERFLOW;
4055 }
4056
4057 *puiOut = (USHORT) lIn;
4058
4059 return S_OK;
4060 }
4061
4062 /******************************************************************************
4063 * VarUI2FromR4 [OLEAUT32.260]
4064 */
4065 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* puiOut)
4066 {
4067 TRACE("( %f, %p ), stub\n", fltIn, puiOut );
4068
4069 fltIn = round( fltIn );
4070 if( fltIn < UI2_MIN || fltIn > UI2_MAX )
4071 {
4072 return DISP_E_OVERFLOW;
4073 }
4074
4075 *puiOut = (USHORT) fltIn;
4076
4077 return S_OK;
4078 }
4079
4080 /******************************************************************************
4081 * VarUI2FromR8 [OLEAUT32.261]
4082 */
4083 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* puiOut)
4084 {
4085 TRACE("( %f, %p ), stub\n", dblIn, puiOut );
4086
4087 dblIn = round( dblIn );
4088 if( dblIn < UI2_MIN || dblIn > UI2_MAX )
4089 {
4090 return DISP_E_OVERFLOW;
4091 }
4092
4093 *puiOut = (USHORT) dblIn;
4094
4095 return S_OK;
4096 }
4097
4098 /******************************************************************************
4099 * VarUI2FromDate [OLEAUT32.262]
4100 */
4101 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* puiOut)
4102 {
4103 TRACE("( %f, %p ), stub\n", dateIn, puiOut );
4104
4105 dateIn = round( dateIn );
4106 if( dateIn < UI2_MIN || dateIn > UI2_MAX )
4107 {
4108 return DISP_E_OVERFLOW;
4109 }
4110
4111 *puiOut = (USHORT) dateIn;
4112
4113 return S_OK;
4114 }
4115
4116 /******************************************************************************
4117 * VarUI2FromStr [OLEAUT32.264]
4118 */
4119 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* puiOut)
4120 {
4121 double dValue = 0.0;
4122 LPSTR pNewString = NULL;
4123
4124 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, puiOut );
4125
4126 /* Check if we have a valid argument
4127 */
4128 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4129 RemoveCharacterFromString( pNewString, "," );
4130 if( IsValidRealString( pNewString ) == FALSE )
4131 {
4132 return DISP_E_TYPEMISMATCH;
4133 }
4134
4135 /* Convert the valid string to a floating point number.
4136 */
4137 dValue = atof( pNewString );
4138
4139 /* We don't need the string anymore so free it.
4140 */
4141 HeapFree( GetProcessHeap(), 0, pNewString );
4142
4143 /* Check range of value.
4144 */
4145 dValue = round( dValue );
4146 if( dValue < UI2_MIN || dValue > UI2_MAX )
4147 {
4148 return DISP_E_OVERFLOW;
4149 }
4150
4151 *puiOut = (USHORT) dValue;
4152
4153 return S_OK;
4154 }
4155
4156 /******************************************************************************
4157 * VarUI2FromBool [OLEAUT32.266]
4158 */
4159 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* puiOut)
4160 {
4161 TRACE("( %d, %p ), stub\n", boolIn, puiOut );
4162
4163 *puiOut = (USHORT) boolIn;
4164
4165 return S_OK;
4166 }
4167
4168 /******************************************************************************
4169 * VarUI2FromI1 [OLEAUT32.267]
4170 */
4171 HRESULT WINAPI VarUI2FromI1(CHAR cIn, USHORT* puiOut)
4172 {
4173 TRACE("( %c, %p ), stub\n", cIn, puiOut );
4174
4175 *puiOut = (USHORT) cIn;
4176
4177 return S_OK;
4178 }
4179
4180 /******************************************************************************
4181 * VarUI2FromUI4 [OLEAUT32.268]
4182 */
4183 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* puiOut)
4184 {
4185 TRACE("( %ld, %p ), stub\n", ulIn, puiOut );
4186
4187 if( ulIn > UI2_MAX )
4188 {
4189 return DISP_E_OVERFLOW;
4190 }
4191
4192 *puiOut = (USHORT) ulIn;
4193
4194 return S_OK;
4195 }
4196
4197 /******************************************************************************
4198 * VarUI4FromStr [OLEAUT32.277]
4199 */
4200 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG* pulOut)
4201 {
4202 double dValue = 0.0;
4203 LPSTR pNewString = NULL;
4204
4205 TRACE("( %p, %ld, %ld, %p ), stub\n", strIn, lcid, dwFlags, pulOut );
4206
4207 /* Check if we have a valid argument
4208 */
4209 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4210 RemoveCharacterFromString( pNewString, "," );
4211 if( IsValidRealString( pNewString ) == FALSE )
4212 {
4213 return DISP_E_TYPEMISMATCH;
4214 }
4215
4216 /* Convert the valid string to a floating point number.
4217 */
4218 dValue = atof( pNewString );
4219
4220 /* We don't need the string anymore so free it.
4221 */
4222 HeapFree( GetProcessHeap(), 0, pNewString );
4223
4224 /* Check range of value.
4225 */
4226 dValue = round( dValue );
4227 if( dValue < UI4_MIN || dValue > UI4_MAX )
4228 {
4229 return DISP_E_OVERFLOW;
4230 }
4231
4232 *pulOut = (ULONG) dValue;
4233
4234 return S_OK;
4235 }
4236
4237 /**********************************************************************
4238 * VarUI2FromCy [OLEAUT32.263]
4239 * Convert currency to unsigned short
4240 */
4241 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut) {
4242 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4243
4244 if (t > UI2_MAX || t < UI2_MIN) return DISP_E_OVERFLOW;
4245
4246 *pusOut = (USHORT)t;
4247
4248 return S_OK;
4249 }
4250
4251 /******************************************************************************
4252 * VarUI4FromUI1 [OLEAUT32.270]
4253 */
4254 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG* pulOut)
4255 {
4256 TRACE("( %d, %p ), stub\n", bIn, pulOut );
4257
4258 *pulOut = (USHORT) bIn;
4259
4260 return S_OK;
4261 }
4262
4263 /******************************************************************************
4264 * VarUI4FromI2 [OLEAUT32.271]
4265 */
4266 HRESULT WINAPI VarUI4FromI2(short uiIn, ULONG* pulOut)
4267 {
4268 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4269
4270 if( uiIn < UI4_MIN )
4271 {
4272 return DISP_E_OVERFLOW;
4273 }
4274
4275 *pulOut = (ULONG) uiIn;
4276
4277 return S_OK;
4278 }
4279
4280 /******************************************************************************
4281 * VarUI4FromI4 [OLEAUT32.272]
4282 */
4283 HRESULT WINAPI VarUI4FromI4(LONG lIn, ULONG* pulOut)
4284 {
4285 TRACE("( %ld, %p ), stub\n", lIn, pulOut );
4286
4287 if( lIn < 0 )
4288 {
4289 return DISP_E_OVERFLOW;
4290 }
4291
4292 *pulOut = (ULONG) lIn;
4293
4294 return S_OK;
4295 }
4296
4297 /******************************************************************************
4298 * VarUI4FromR4 [OLEAUT32.273]
4299 */
4300 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG* pulOut)
4301 {
4302 fltIn = round( fltIn );
4303 if( fltIn < UI4_MIN || fltIn > UI4_MAX )
4304 {
4305 return DISP_E_OVERFLOW;
4306 }
4307
4308 *pulOut = (ULONG) fltIn;
4309
4310 return S_OK;
4311 }
4312
4313 /******************************************************************************
4314 * VarUI4FromR8 [OLEAUT32.274]
4315 */
4316 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG* pulOut)
4317 {
4318 TRACE("( %f, %p ), stub\n", dblIn, pulOut );
4319
4320 dblIn = round( dblIn );
4321 if( dblIn < UI4_MIN || dblIn > UI4_MAX )
4322 {
4323 return DISP_E_OVERFLOW;
4324 }
4325
4326 *pulOut = (ULONG) dblIn;
4327
4328 return S_OK;
4329 }
4330
4331 /******************************************************************************
4332 * VarUI4FromDate [OLEAUT32.275]
4333 */
4334 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG* pulOut)
4335 {
4336 TRACE("( %f, %p ), stub\n", dateIn, pulOut );
4337
4338 dateIn = round( dateIn );
4339 if( dateIn < UI4_MIN || dateIn > UI4_MAX )
4340 {
4341 return DISP_E_OVERFLOW;
4342 }
4343
4344 *pulOut = (ULONG) dateIn;
4345
4346 return S_OK;
4347 }
4348
4349 /******************************************************************************
4350 * VarUI4FromBool [OLEAUT32.279]
4351 */
4352 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG* pulOut)
4353 {
4354 TRACE("( %d, %p ), stub\n", boolIn, pulOut );
4355
4356 *pulOut = (ULONG) boolIn;
4357
4358 return S_OK;
4359 }
4360
4361 /******************************************************************************
4362 * VarUI4FromI1 [OLEAUT32.280]
4363 */
4364 HRESULT WINAPI VarUI4FromI1(CHAR cIn, ULONG* pulOut)
4365 {
4366 TRACE("( %c, %p ), stub\n", cIn, pulOut );
4367
4368 *pulOut = (ULONG) cIn;
4369
4370 return S_OK;
4371 }
4372
4373 /******************************************************************************
4374 * VarUI4FromUI2 [OLEAUT32.281]
4375 */
4376 HRESULT WINAPI VarUI4FromUI2(USHORT uiIn, ULONG* pulOut)
4377 {
4378 TRACE("( %d, %p ), stub\n", uiIn, pulOut );
4379
4380 *pulOut = (ULONG) uiIn;
4381
4382 return S_OK;
4383 }
4384
4385 /**********************************************************************
4386 * VarUI4FromCy [OLEAUT32.276]
4387 * Convert currency to unsigned long
4388 */
4389 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG* pulOut) {
4390 double t = round((((double)cyIn.s.Hi * 4294967296.0) + (double)cyIn.s.Lo) / 10000);
4391
4392 if (t > UI4_MAX || t < UI4_MIN) return DISP_E_OVERFLOW;
4393
4394 *pulOut = (ULONG)t;
4395
4396 return S_OK;
4397 }
4398
4399 /**********************************************************************
4400 * VarCyFromUI1 [OLEAUT32.98]
4401 * Convert unsigned char to currency
4402 */
4403 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pcyOut) {
4404 pcyOut->s.Hi = 0;
4405 pcyOut->s.Lo = ((ULONG)bIn) * 10000;
4406
4407 return S_OK;
4408 }
4409
4410 /**********************************************************************
4411 * VarCyFromI2 [OLEAUT32.99]
4412 * Convert signed short to currency
4413 */
4414 HRESULT WINAPI VarCyFromI2(short sIn, CY* pcyOut) {
4415 if (sIn < 0) pcyOut->s.Hi = -1;
4416 else pcyOut->s.Hi = 0;
4417 pcyOut->s.Lo = ((ULONG)sIn) * 10000;
4418
4419 return S_OK;
4420 }
4421
4422 /**********************************************************************
4423 * VarCyFromI4 [OLEAUT32.100]
4424 * Convert signed long to currency
4425 */
4426 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pcyOut) {
4427 double t = (double)lIn * (double)10000;
4428 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4429 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4430 if (lIn < 0) pcyOut->s.Hi--;
4431
4432 return S_OK;
4433 }
4434
4435 /**********************************************************************
4436 * VarCyFromR4 [OLEAUT32.101]
4437 * Convert float to currency
4438 */
4439 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pcyOut) {
4440 double t = round((double)fltIn * (double)10000);
4441 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4442 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4443 if (fltIn < 0) pcyOut->s.Hi--;
4444
4445 return S_OK;
4446 }
4447
4448 /**********************************************************************
4449 * VarCyFromR8 [OLEAUT32.102]
4450 * Convert double to currency
4451 */
4452 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pcyOut) {
4453 double t = round(dblIn * (double)10000);
4454 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4455 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4456 if (dblIn < 0) pcyOut->s.Hi--;
4457
4458 return S_OK;
4459 }
4460
4461 /**********************************************************************
4462 * VarCyFromDate [OLEAUT32.103]
4463 * Convert date to currency
4464 */
4465 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pcyOut) {
4466 double t = round((double)dateIn * (double)10000);
4467 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4468 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4469 if (dateIn < 0) pcyOut->s.Hi--;
4470
4471 return S_OK;
4472 }
4473
4474 /**********************************************************************
4475 * VarCyFromStr [OLEAUT32.104]
4476 * FIXME: Never tested with decimal seperator other than '.'
4477 */
4478 HRESULT WINAPI VarCyFromStr(OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pcyOut) {
4479
4480 LPSTR pNewString = NULL;
4481 char *decSep = NULL;
4482 char *strPtr,*curPtr = NULL;
4483 int size, rc;
4484 double currencyVal = 0.0;
4485
4486
4487 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, strIn );
4488 TRACE("( '%s', 0x%08lx, 0x%08lx, %p )\n", pNewString, lcid, dwFlags, pcyOut );
4489
4490 /* Get locale information - Decimal Seperator (size includes 0x00) */
4491 size = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, NULL, 0);
4492 decSep = (char *) malloc(size);
4493 rc = GetLocaleInfoA(lcid, LOCALE_SDECIMAL, decSep, size);
4494 TRACE("Decimal Seperator is '%s'\n", decSep);
4495
4496 /* Now copy to temporary buffer, skipping any character except 0-9 and
4497 the decimal seperator */
4498 curPtr = pBuffer; /* Current position in string being built */
4499 strPtr = pNewString; /* Current position in supplied currenct string */
4500
4501 while (*strPtr) {
4502 /* If decimal seperator, skip it and put '.' in string */
4503 if (strncmp(strPtr, decSep, (size-1)) == 0) {
4504 strPtr = strPtr + (size-1);
4505 *curPtr = '.';
4506 curPtr++;
4507 } else if ((*strPtr == '+' || *strPtr == '-') ||
4508 (*strPtr >= '0' && *strPtr <= '9')) {
4509 *curPtr = *strPtr;
4510 strPtr++;
4511 curPtr++;
4512 } else strPtr++;
4513 }
4514 *curPtr = 0x00;
4515
4516 /* Try to get currency into a double */
4517 currencyVal = atof(pBuffer);
4518 TRACE("Converted string '%s' to %f\n", pBuffer, currencyVal);
4519
4520 /* Free allocated storage */
4521 HeapFree( GetProcessHeap(), 0, pNewString );
4522 free(decSep);
4523
4524 /* Convert double -> currency using internal routine */
4525 return VarCyFromR8(currencyVal, pcyOut);
4526 }
4527
4528
4529 /**********************************************************************
4530 * VarCyFromBool [OLEAUT32.106]
4531 * Convert boolean to currency
4532 */
4533 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pcyOut) {
4534 if (boolIn < 0) pcyOut->s.Hi = -1;
4535 else pcyOut->s.Hi = 0;
4536 pcyOut->s.Lo = (ULONG)boolIn * (ULONG)10000;
4537
4538 return S_OK;
4539 }
4540
4541 /**********************************************************************
4542 * VarCyFromI1 [OLEAUT32.225]
4543 * Convert signed char to currency
4544 */
4545 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pcyOut) {
4546 if (cIn < 0) pcyOut->s.Hi = -1;
4547 else pcyOut->s.Hi = 0;
4548 pcyOut->s.Lo = (ULONG)cIn * (ULONG)10000;
4549
4550 return S_OK;
4551 }
4552
4553 /**********************************************************************
4554 * VarCyFromUI2 [OLEAUT32.226]
4555 * Convert unsigned short to currency
4556 */
4557 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pcyOut) {
4558 pcyOut->s.Hi = 0;
4559 pcyOut->s.Lo = (ULONG)usIn * (ULONG)10000;
4560
4561 return S_OK;
4562 }
4563
4564 /**********************************************************************
4565 * VarCyFromUI4 [OLEAUT32.227]
4566 * Convert unsigned long to currency
4567 */
4568 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pcyOut) {
4569 double t = (double)ulIn * (double)10000;
4570 pcyOut->s.Hi = (LONG)(t / (double)4294967296.0);
4571 pcyOut->s.Lo = (ULONG)fmod(t, (double)4294967296.0);
4572
4573 return S_OK;
4574 }
4575
4576
4577 /**********************************************************************
4578 * DosDateTimeToVariantTime [OLEAUT32.14]
4579 * Convert dos representation of time to the date and time representation
4580 * stored in a variant.
4581 */
4582 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
4583 DATE *pvtime)
4584 {
4585 struct tm t;
4586
4587 TRACE("( 0x%x, 0x%x, %p ), stub\n", wDosDate, wDosTime, pvtime );
4588
4589 t.tm_sec = (wDosTime & 0x001f) * 2;
4590 t.tm_min = (wDosTime & 0x07e0) >> 5;
4591 t.tm_hour = (wDosTime & 0xf800) >> 11;
4592
4593 t.tm_mday = (wDosDate & 0x001f);
4594 t.tm_mon = (wDosDate & 0x01e0) >> 5;
4595 t.tm_year = ((wDosDate & 0xfe00) >> 9) + 1980;
4596
4597 return TmToDATE( &t, pvtime );
4598 }
4599
4600
4601 /**********************************************************************
4602 * VarParseNumFromStr [OLEAUT32.46]
4603 */
4604 HRESULT WINAPI VarParseNumFromStr(OLECHAR * strIn, LCID lcid, ULONG dwFlags,
4605 NUMPARSE * pnumprs, BYTE * rgbDig)
4606 {
4607 int i,lastent=0;
4608 int cDig;
4609 BOOL foundNum=FALSE;
4610
4611 FIXME("(%s,flags=%lx,....), partial stub!\n",debugstr_w(strIn),dwFlags);
4612 FIXME("numparse: cDig=%d, InFlags=%lx\n",pnumprs->cDig,pnumprs->dwInFlags);
4613
4614 /* The other struct components are to be set by us */
4615 memset(rgbDig,0,pnumprs->cDig);
4616
4617 /* FIXME: Just patching some values in */
4618 pnumprs->nPwr10 = 0;
4619 pnumprs->nBaseShift = 0;
4620 pnumprs->cchUsed = lastent;
4621 pnumprs->dwOutFlags = NUMPRS_DECIMAL;
4622
4623 cDig = 0;
4624 for (i=0; strIn[i] ;i++) {
4625 if ((strIn[i]>='0') && (strIn[i]<='9')) {
4626 foundNum = TRUE;
4627 if (pnumprs->cDig > cDig) {
4628 *(rgbDig++)=strIn[i]-'0';
4629 cDig++;
4630 lastent = i;
4631 }
4632 } else if ((strIn[i]=='-') && (foundNum==FALSE)) {
4633 pnumprs->dwOutFlags |= NUMPRS_NEG;
4634 }
4635 }
4636 pnumprs->cDig = cDig;
4637 TRACE("numparse out: cDig=%d, OutFlags=%lx\n",pnumprs->cDig,pnumprs->dwOutFlags);
4638 return S_OK;
4639 }
4640
4641
4642 /**********************************************************************
4643 * VarNumFromParseNum [OLEAUT32.47]
4644 */
4645 HRESULT WINAPI VarNumFromParseNum(NUMPARSE * pnumprs, BYTE * rgbDig,
4646 ULONG dwVtBits, VARIANT * pvar)
4647 {
4648 DWORD xint;
4649 int i;
4650 FIXME("(..,dwVtBits=%lx,....), partial stub!\n",dwVtBits);
4651
4652 xint = 0;
4653 for (i=0;i<pnumprs->cDig;i++)
4654 xint = xint*10 + rgbDig[i];
4655
4656 if (pnumprs->dwOutFlags & NUMPRS_NEG) {
4657 xint = xint * -1;
4658 }
4659
4660 VariantInit(pvar);
4661 if (dwVtBits & VTBIT_I4) {
4662 V_VT(pvar) = VT_I4;
4663 V_UNION(pvar,intVal) = xint;
4664 return S_OK;
4665 }
4666 if (dwVtBits & VTBIT_R8) {
4667 V_VT(pvar) = VT_R8;
4668 V_UNION(pvar,dblVal) = xint;
4669 return S_OK;
4670 }
4671 if (dwVtBits & VTBIT_R4) {
4672 V_VT(pvar) = VT_R4;
4673 V_UNION(pvar,fltVal) = xint;
4674 return S_OK;
4675 }
4676 if (dwVtBits & VTBIT_I2) {
4677 V_VT(pvar) = VT_I2;
4678 V_UNION(pvar,iVal) = xint;
4679 return S_OK;
4680 }
4681 /* FIXME: Currency should be from a double */
4682 if (dwVtBits & VTBIT_CY) {
4683 V_VT(pvar) = VT_CY;
4684 TRACE("Calculated currency is xint=%ld\n", xint);
4685 VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4686 TRACE("Calculated cy is %ld,%lu\n", V_UNION(pvar,cyVal).s.Hi, V_UNION(pvar,cyVal).s.Lo);
4687 return VarCyFromInt( (int) xint, &V_UNION(pvar,cyVal) );
4688 }
4689
4690 FIXME("vtbitmask is unsupported %lx, int=%d\n",dwVtBits, (int) xint);
4691 return E_FAIL;
4692 }
4693
4694
4695 /**********************************************************************
4696 * VarFormatDateTime [OLEAUT32.97]
4697 */
4698 HRESULT WINAPI VarFormatDateTime(LPVARIANT var, INT format, ULONG dwFlags, BSTR *out)
4699 {
4700 FIXME("%p %d %lx %p\n", var, format, dwFlags, out);
4701 return E_NOTIMPL;
4702 }
4703
4704 /**********************************************************************
4705 * VarFormatCurrency [OLEAUT32.127]
4706 */
4707 HRESULT WINAPI VarFormatCurrency(LPVARIANT var, INT digits, INT lead, INT paren, INT group, ULONG dwFlags, BSTR *out)
4708 {
4709 FIXME("%p %d %d %d %d %lx %p\n", var, digits, lead, paren, group, dwFlags, out);
4710 return E_NOTIMPL;
4711 }
4712
4713 /**********************************************************************
4714 * VariantTimeToDosDateTime [OLEAUT32.13]
4715 * Convert variant representation of time to the date and time representation
4716 * stored in dos.
4717 */
4718 INT WINAPI VariantTimeToDosDateTime(DATE pvtime, USHORT *wDosDate, USHORT *wDosTime)
4719 {
4720 struct tm t;
4721 *wDosTime = 0;
4722 *wDosDate = 0;
4723
4724 TRACE("( 0x%x, 0x%x, %p ), stub\n", *wDosDate, *wDosTime, &pvtime );
4725
4726 if (DateToTm(pvtime, 0, &t) < 0) return 0;
4727
4728 *wDosTime = *wDosTime | (t.tm_sec / 2);
4729 *wDosTime = *wDosTime | (t.tm_min << 5);
4730 *wDosTime = *wDosTime | (t.tm_hour << 11);
4731
4732 *wDosDate = *wDosDate | t.tm_mday ;
4733 *wDosDate = *wDosDate | t.tm_mon << 5;
4734 *wDosDate = *wDosDate | ((t.tm_year - 1980) << 9) ;
4735
4736 return 1;
4737 }
4738
4739
4740 /***********************************************************************
4741 * SystemTimeToVariantTime [OLEAUT32.184]
4742 */
4743 HRESULT WINAPI SystemTimeToVariantTime( LPSYSTEMTIME lpSystemTime, double *pvtime )
4744 {
4745 struct tm t;
4746
4747 TRACE(" %d/%d/%d %d:%d:%d\n",
4748 lpSystemTime->wMonth, lpSystemTime->wDay,
4749 lpSystemTime->wYear, lpSystemTime->wHour,
4750 lpSystemTime->wMinute, lpSystemTime->wSecond);
4751
4752 if (lpSystemTime->wYear >= 1900)
4753 {
4754 t.tm_sec = lpSystemTime->wSecond;
4755 t.tm_min = lpSystemTime->wMinute;
4756 t.tm_hour = lpSystemTime->wHour;
4757
4758 t.tm_mday = lpSystemTime->wDay;
4759 t.tm_mon = lpSystemTime->wMonth - 1; /* tm_mon is 0..11, wMonth is 1..12 */
4760 t.tm_year = lpSystemTime->wYear;
4761
4762 return TmToDATE( &t, pvtime );
4763 }
4764 else
4765 {
4766 double tmpDate;
4767 long firstDayOfNextYear;
4768 long thisDay;
4769 long leftInYear;
4770 long result;
4771
4772 double decimalPart = 0.0;
4773
4774 t.tm_sec = lpSystemTime->wSecond;
4775 t.tm_min = lpSystemTime->wMinute;
4776 t.tm_hour = lpSystemTime->wHour;
4777
4778 /* Step year forward the same number of years before 1900 */
4779 t.tm_year = 1900 + 1899 - lpSystemTime->wYear;
4780 t.tm_mon = lpSystemTime->wMonth - 1;
4781 t.tm_mday = lpSystemTime->wDay;
4782
4783 /* Calculate date */
4784 TmToDATE( &t, pvtime );
4785
4786 thisDay = (double) floor( *pvtime );
4787 decimalPart = fmod( *pvtime, thisDay );
4788
4789 /* Now, calculate the same time for the first of Jan that year */
4790 t.tm_mon = 0;
4791 t.tm_mday = 1;
4792 t.tm_sec = 0;
4793 t.tm_min = 0;
4794 t.tm_hour = 0;
4795 t.tm_year = t.tm_year+1;
4796 TmToDATE( &t, &tmpDate );
4797 firstDayOfNextYear = (long) floor(tmpDate);
4798
4799 /* Finally since we know the size of the year, subtract the two to get
4800 remaining time in the year */
4801 leftInYear = firstDayOfNextYear - thisDay;
4802
4803 /* Now we want full years up to the year in question, and remainder of year
4804 of the year in question */
4805 if (isleap(lpSystemTime->wYear) ) {
4806 TRACE("Extra day due to leap year\n");
4807 result = 2.0 - ((firstDayOfNextYear - 366) + leftInYear - 2.0);
4808 } else {
4809 result = 2.0 - ((firstDayOfNextYear - 365) + leftInYear - 2.0);
4810 }
4811 *pvtime = (double) result + decimalPart;
4812 TRACE("<1899 support: returned %f, 1st day %ld, thisday %ld, left %ld\n", *pvtime, firstDayOfNextYear, thisDay, leftInYear);
4813
4814 return 1;
4815 }
4816
4817 return 0;
4818 }
4819
4820 /***********************************************************************
4821 * VariantTimeToSystemTime [OLEAUT32.185]
4822 */
4823 HRESULT WINAPI VariantTimeToSystemTime( double vtime, LPSYSTEMTIME lpSystemTime )
4824 {
4825 double t = 0, timeofday = 0;
4826
4827 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4828 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4829
4830 /* The Month_Code is used to find the Day of the Week (LY = LeapYear)*/
4831 static const BYTE Month_Code[] = {0, 1, 4, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4832 static const BYTE Month_Code_LY[] = {0, 0, 3, 4, 0, 2, 5, 0, 3, 6, 1, 4, 6};
4833
4834 /* The Century_Code is used to find the Day of the Week */
4835 static const BYTE Century_Code[] = {0, 6, 4, 2};
4836
4837 struct tm r;
4838
4839 TRACE(" Variant = %f SYSTEMTIME ptr %p\n", vtime, lpSystemTime);
4840
4841 if (vtime >= 0)
4842 {
4843
4844 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4845
4846 lpSystemTime->wSecond = r.tm_sec;
4847 lpSystemTime->wMinute = r.tm_min;
4848 lpSystemTime->wHour = r.tm_hour;
4849 lpSystemTime->wDay = r.tm_mday;
4850 lpSystemTime->wMonth = r.tm_mon;
4851
4852 if (lpSystemTime->wMonth == 12)
4853 lpSystemTime->wMonth = 1;
4854 else
4855 lpSystemTime->wMonth++;
4856
4857 lpSystemTime->wYear = r.tm_year;
4858 }
4859 else
4860 {
4861 vtime = -1*vtime;
4862
4863 if (DateToTm(vtime, 0, &r ) <= 0) return 0;
4864
4865 lpSystemTime->wSecond = r.tm_sec;
4866 lpSystemTime->wMinute = r.tm_min;
4867 lpSystemTime->wHour = r.tm_hour;
4868
4869 lpSystemTime->wMonth = 13 - r.tm_mon;
4870
4871 if (lpSystemTime->wMonth == 1)
4872 lpSystemTime->wMonth = 12;
4873 else
4874 lpSystemTime->wMonth--;
4875
4876 lpSystemTime->wYear = 1899 - (r.tm_year - 1900);
4877
4878 if (!isleap(lpSystemTime->wYear) )
4879 lpSystemTime->wDay = Days_Per_Month[13 - lpSystemTime->wMonth] - r.tm_mday;
4880 else
4881 lpSystemTime->wDay = Days_Per_Month_LY[13 - lpSystemTime->wMonth] - r.tm_mday;
4882
4883
4884 }
4885
4886 if (!isleap(lpSystemTime->wYear))
4887 {
4888 /*
4889 (Century_Code+Month_Code+Year_Code+Day) % 7
4890
4891 The century code repeats every 400 years , so the array
4892 works out like this,
4893
4894 Century_Code[0] is for 16th/20th Centry
4895 Century_Code[1] is for 17th/21th Centry
4896 Century_Code[2] is for 18th/22th Centry
4897 Century_Code[3] is for 19th/23th Centry
4898
4899 The year code is found with the formula (year + (year / 4))
4900 the "year" must be between 0 and 99 .
4901
4902 The Month Code (Month_Code[1]) starts with January and
4903 ends with December.
4904 */
4905
4906 lpSystemTime->wDayOfWeek = (
4907 Century_Code[(( (lpSystemTime->wYear+100) - lpSystemTime->wYear%100) /100) %4]+
4908 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4909 Month_Code[lpSystemTime->wMonth]+
4910 lpSystemTime->wDay) % 7;
4911
4912 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4913 else lpSystemTime->wDayOfWeek -= 1;
4914 }
4915 else
4916 {
4917 lpSystemTime->wDayOfWeek = (
4918 Century_Code[(((lpSystemTime->wYear+100) - lpSystemTime->wYear%100)/100)%4]+
4919 ((lpSystemTime->wYear%100)+(lpSystemTime->wYear%100)/4)+
4920 Month_Code_LY[lpSystemTime->wMonth]+
4921 lpSystemTime->wDay) % 7;
4922
4923 if (lpSystemTime->wDayOfWeek == 0) lpSystemTime->wDayOfWeek = 7;
4924 else lpSystemTime->wDayOfWeek -= 1;
4925 }
4926
4927 t = floor(vtime);
4928 timeofday = vtime - t;
4929
4930 lpSystemTime->wMilliseconds = (timeofday
4931 - lpSystemTime->wHour*(1/24)
4932 - lpSystemTime->wMinute*(1/1440)
4933 - lpSystemTime->wSecond*(1/86400) )*(1/5184000);
4934
4935 return 1;
4936 }
4937
4938 /***********************************************************************
4939 * VarUdateFromDate [OLEAUT32.331]
4940 */
4941 HRESULT WINAPI VarUdateFromDate( DATE datein, ULONG dwFlags, UDATE *pudateout)
4942 {
4943 HRESULT i = 0;
4944 static const BYTE Days_Per_Month[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4945 static const BYTE Days_Per_Month_LY[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
4946
4947 TRACE("DATE = %f\n", (double)datein);
4948 i = VariantTimeToSystemTime(datein, &(pudateout->st) );
4949
4950 if (i)
4951 {
4952 pudateout->wDayOfYear = 0;
4953
4954 if (isleap(pudateout->st.wYear))
4955 {
4956 for (i =1; i<pudateout->st.wMonth; i++)
4957 pudateout->wDayOfYear += Days_Per_Month[i];
4958 }
4959 else
4960 {
4961 for (i =1; i<pudateout->st.wMonth; i++)
4962 pudateout->wDayOfYear += Days_Per_Month_LY[i];
4963 }
4964
4965 pudateout->wDayOfYear += pudateout->st.wDay;
4966 dwFlags = 0; /*VAR_VALIDDATE*/
4967 }
4968 else dwFlags = 0;
4969
4970 return i;
4971 }
4972
4973 /***********************************************************************
4974 * VarDateFromUdate [OLEAUT32.330]
4975 */
4976 HRESULT WINAPI VarDateFromUdate(UDATE *pudateout,
4977 ULONG dwFlags, DATE *datein)
4978 {
4979 HRESULT i;
4980 double t = 0;
4981 TRACE(" %d/%d/%d %d:%d:%d\n",
4982 pudateout->st.wMonth, pudateout->st.wDay,
4983 pudateout->st.wYear, pudateout->st.wHour,
4984 pudateout->st.wMinute, pudateout->st.wSecond);
4985
4986
4987 i = SystemTimeToVariantTime(&(pudateout->st), &t);
4988 *datein = t;
4989
4990 if (i) return S_OK;
4991 else return E_INVALIDARG;
4992 }
4993
4994
4995 /**********************************************************************
4996 * VarBstrCmp [OLEAUT32.314]
4997 *
4998 * flags can be:
4999 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5000 * NORM_IGNORESTRINGWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5001 *
5002 */
5003 HRESULT WINAPI VarBstrCmp(BSTR left, BSTR right, LCID lcid, DWORD flags)
5004 {
5005 INT r;
5006
5007 TRACE("( %s %s %ld %lx ) partial stub\n", debugstr_w(left), debugstr_w(right), lcid, flags);
5008
5009 /* Contrary to the MSDN, this returns eq for null vs null, null vs L"" and L"" vs NULL */
5010 if((!left) || (!right)) {
5011
5012 if (!left && (!right || *right==0)) return VARCMP_EQ;
5013 else if (!right && (!left || *left==0)) return VARCMP_EQ;
5014 else return VARCMP_NULL;
5015 }
5016
5017 if(flags&NORM_IGNORECASE)
5018 r = lstrcmpiW(left,right);
5019 else
5020 r = lstrcmpW(left,right);
5021
5022 if(r<0)
5023 return VARCMP_LT;
5024 if(r>0)
5025 return VARCMP_GT;
5026
5027 return VARCMP_EQ;
5028 }
5029
5030 /**********************************************************************
5031 * VarBstrCat [OLEAUT32.313]
5032 */
5033 HRESULT WINAPI VarBstrCat(BSTR left, BSTR right, BSTR *out)
5034 {
5035 BSTR result;
5036 int size = 0;
5037
5038 TRACE("( %s %s %p )\n", debugstr_w(left), debugstr_w(right), out);
5039
5040 /* On Windows, NULL parms are still handled (as empty strings) */
5041 if (left) size=size + lstrlenW(left);
5042 if (right) size=size + lstrlenW(right);
5043
5044 if (out) {
5045 result = SysAllocStringLen(NULL, size);
5046 *out = result;
5047 if (left) lstrcatW(result,left);
5048 if (right) lstrcatW(result,right);
5049 TRACE("result = %s, [%p]\n", debugstr_w(result), result);
5050 }
5051 return S_OK;
5052 }
5053
5054 /**********************************************************************
5055 * VarCat [OLEAUT32.318]
5056 */
5057 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
5058 {
5059 /* Should we VariantClear out? */
5060 /* Can we handle array, vector, by ref etc. */
5061 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL &&
5062 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5063 {
5064 V_VT(out) = VT_NULL;
5065 return S_OK;
5066 }
5067
5068 if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR)
5069 {
5070 V_VT(out) = VT_BSTR;
5071 VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out));
5072 return S_OK;
5073 }
5074 if (V_VT(left) == VT_BSTR) {
5075 VARIANT bstrvar;
5076 HRESULT hres;
5077
5078 V_VT(out) = VT_BSTR;
5079 hres = VariantChangeTypeEx(&bstrvar,right,0,0,VT_BSTR);
5080 if (hres) {
5081 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5082 return hres;
5083 }
5084 VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar), &V_BSTR(out));
5085 return S_OK;
5086 }
5087 if (V_VT(right) == VT_BSTR) {
5088 VARIANT bstrvar;
5089 HRESULT hres;
5090
5091 V_VT(out) = VT_BSTR;
5092 hres = VariantChangeTypeEx(&bstrvar,left,0,0,VT_BSTR);
5093 if (hres) {
5094 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
5095 return hres;
5096 }
5097 VarBstrCat (V_BSTR(&bstrvar), V_BSTR(right), &V_BSTR(out));
5098 return S_OK;
5099 }
5100 FIXME ("types %d / %d not supported\n",V_VT(left)&VT_TYPEMASK, V_VT(right)&VT_TYPEMASK);
5101 return S_OK;
5102 }
5103
5104 /**********************************************************************
5105 * VarCmp [OLEAUT32.176]
5106 *
5107 * flags can be:
5108 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
5109 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
5110 *
5111 */
5112 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
5113 {
5114
5115
5116 BOOL lOk = TRUE;
5117 BOOL rOk = TRUE;
5118 LONGLONG lVal = -1;
5119 LONGLONG rVal = -1;
5120 VARIANT rv,lv;
5121 DWORD xmask;
5122 HRESULT rc;
5123
5124 VariantInit(&lv);VariantInit(&rv);
5125 V_VT(right) &= ~0x8000; /* hack since we sometime get this flag. */
5126 V_VT(left) &= ~0x8000; /* hack since we sometime get this flag. */
5127
5128 TRACE("Left Var:\n");
5129 dump_Variant(left);
5130 TRACE("Right Var:\n");
5131 dump_Variant(right);
5132
5133 /* If either are null, then return VARCMP_NULL */
5134 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL ||
5135 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
5136 return VARCMP_NULL;
5137
5138 /* Strings - use VarBstrCmp */
5139 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5140 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5141 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
5142 }
5143
5144 xmask = (1<<(V_VT(left)&VT_TYPEMASK))|(1<<(V_VT(right)&VT_TYPEMASK));
5145 if (xmask & (1<<VT_R8)) {
5146 rc = VariantChangeType(&lv,left,0,VT_R8);
5147 if (FAILED(rc)) return rc;
5148 rc = VariantChangeType(&rv,right,0,VT_R8);
5149 if (FAILED(rc)) return rc;
5150
5151 if (V_R8(&lv) == V_R8(&rv)) return VARCMP_EQ;
5152 if (V_R8(&lv) < V_R8(&rv)) return VARCMP_LT;
5153 if (V_R8(&lv) > V_R8(&rv)) return VARCMP_GT;
5154 return E_FAIL; /* can't get here */
5155 }
5156 if (xmask & (1<<VT_R4)) {
5157 rc = VariantChangeType(&lv,left,0,VT_R4);
5158 if (FAILED(rc)) return rc;
5159 rc = VariantChangeType(&rv,right,0,VT_R4);
5160 if (FAILED(rc)) return rc;
5161
5162 if (V_R4(&lv) == V_R4(&rv)) return VARCMP_EQ;
5163 if (V_R4(&lv) < V_R4(&rv)) return VARCMP_LT;
5164 if (V_R4(&lv) > V_R4(&rv)) return VARCMP_GT;
5165 return E_FAIL; /* can't get here */
5166 }
5167
5168 /* Integers - Ideally like to use VarDecCmp, but no Dec support yet
5169 Use LONGLONG to maximize ranges */
5170 lOk = TRUE;
5171 switch (V_VT(left)&VT_TYPEMASK) {
5172 case VT_I1 : lVal = V_UNION(left,cVal); break;
5173 case VT_I2 : lVal = V_UNION(left,iVal); break;
5174 case VT_I4 : lVal = V_UNION(left,lVal); break;
5175 case VT_INT : lVal = V_UNION(left,lVal); break;
5176 case VT_UI1 : lVal = V_UNION(left,bVal); break;
5177 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
5178 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
5179 case VT_UINT : lVal = V_UNION(left,ulVal); break;
5180 case VT_BOOL : lVal = V_UNION(left,boolVal); break;
5181 default: lOk = FALSE;
5182 }
5183
5184 rOk = TRUE;
5185 switch (V_VT(right)&VT_TYPEMASK) {
5186 case VT_I1 : rVal = V_UNION(right,cVal); break;
5187 case VT_I2 : rVal = V_UNION(right,iVal); break;
5188 case VT_I4 : rVal = V_UNION(right,lVal); break;
5189 case VT_INT : rVal = V_UNION(right,lVal); break;
5190 case VT_UI1 : rVal = V_UNION(right,bVal); break;
5191 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
5192 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
5193 case VT_UINT : rVal = V_UNION(right,ulVal); break;
5194 case VT_BOOL : rVal = V_UNION(right,boolVal); break;
5195 default: rOk = FALSE;
5196 }
5197
5198 if (lOk && rOk) {
5199 if (lVal < rVal) {
5200 return VARCMP_LT;
5201 } else if (lVal > rVal) {
5202 return VARCMP_GT;
5203 } else {
5204 return VARCMP_EQ;
5205 }
5206 }
5207
5208 /* Strings - use VarBstrCmp */
5209 if ((V_VT(left)&VT_TYPEMASK) == VT_DATE &&
5210 (V_VT(right)&VT_TYPEMASK) == VT_DATE) {
5211
5212 if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) {
5213 /* Due to floating point rounding errors, calculate varDate in whole numbers) */
5214 double wholePart = 0.0;
5215 double leftR;
5216 double rightR;
5217
5218 /* Get the fraction * 24*60*60 to make it into whole seconds */
5219 wholePart = (double) floor( V_UNION(left,date) );
5220 if (wholePart == 0) wholePart = 1;
5221 leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60));
5222
5223 wholePart = (double) floor( V_UNION(right,date) );
5224 if (wholePart == 0) wholePart = 1;
5225 rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60));
5226
5227 if (leftR < rightR) {
5228 return VARCMP_LT;
5229 } else if (leftR > rightR) {
5230 return VARCMP_GT;
5231 } else {
5232 return VARCMP_EQ;
5233 }
5234
5235 } else if (V_UNION(left,date) < V_UNION(right,date)) {
5236 return VARCMP_LT;
5237 } else if (V_UNION(left,date) > V_UNION(right,date)) {
5238 return VARCMP_GT;
5239 }
5240 }
5241 FIXME("VarCmp partial implementation, doesnt support vt 0x%x / 0x%x\n",V_VT(left), V_VT(right));
5242 return E_FAIL;
5243 }
5244
5245 /**********************************************************************
5246 * VarAnd [OLEAUT32.142]
5247 *
5248 */
5249 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5250 {
5251 HRESULT rc = E_FAIL;
5252
5253 TRACE("Left Var:\n");
5254 dump_Variant(left);
5255 TRACE("Right Var:\n");
5256 dump_Variant(right);
5257
5258 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5259 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5260
5261 V_VT(result) = VT_BOOL;
5262 if (V_BOOL(left) && V_BOOL(right)) {
5263 V_BOOL(result) = VARIANT_TRUE;
5264 } else {
5265 V_BOOL(result) = VARIANT_FALSE;
5266 }
5267 rc = S_OK;
5268
5269 } else {
5270 /* Integers */
5271 BOOL lOk = TRUE;
5272 BOOL rOk = TRUE;
5273 LONGLONG lVal = -1;
5274 LONGLONG rVal = -1;
5275 LONGLONG res = -1;
5276 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5277 becomes I4, even unsigned ints (incl. UI2) */
5278
5279 lOk = TRUE;
5280 switch (V_VT(left)&VT_TYPEMASK) {
5281 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5282 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5283 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5284 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5285 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5286 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5287 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5288 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5289 default: lOk = FALSE;
5290 }
5291
5292 rOk = TRUE;
5293 switch (V_VT(right)&VT_TYPEMASK) {
5294 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5295 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5296 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5297 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5298 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5299 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5300 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5301 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5302 default: rOk = FALSE;
5303 }
5304
5305 if (lOk && rOk) {
5306 res = (lVal & rVal);
5307 V_VT(result) = resT;
5308 switch (resT) {
5309 case VT_I2 : V_UNION(result,iVal) = res; break;
5310 case VT_I4 : V_UNION(result,lVal) = res; break;
5311 default:
5312 FIXME("Unexpected result variant type %x\n", resT);
5313 V_UNION(result,lVal) = res;
5314 }
5315 rc = S_OK;
5316
5317 } else {
5318 FIXME("VarAnd stub\n");
5319 }
5320 }
5321
5322 TRACE("rc=%d, Result:\n", (int) rc);
5323 dump_Variant(result);
5324 return rc;
5325 }
5326
5327 /**********************************************************************
5328 * VarAdd [OLEAUT32.141]
5329 * FIXME: From MSDN: If ... Then
5330 * Both expressions are of the string type Concatenated.
5331 * One expression is a string type and the other a character Addition.
5332 * One expression is numeric and the other is a string Addition.
5333 * Both expressions are numeric Addition.
5334 * Either expression is NULL NULL is returned.
5335 * Both expressions are empty Integer subtype is returned.
5336 *
5337 */
5338 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5339 {
5340 HRESULT rc = E_FAIL;
5341
5342 TRACE("Left Var:\n");
5343 dump_Variant(left);
5344 TRACE("Right Var:\n");
5345 dump_Variant(right);
5346
5347 /* Handle strings as concat */
5348 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
5349 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
5350 V_VT(result) = VT_BSTR;
5351 rc = VarBstrCat(V_BSTR(left), V_BSTR(right), &V_BSTR(result));
5352 } else {
5353
5354 /* Integers */
5355 BOOL lOk = TRUE;
5356 BOOL rOk = TRUE;
5357 LONGLONG lVal = -1;
5358 LONGLONG rVal = -1;
5359 LONGLONG res = -1;
5360 int resT = 0; /* Testing has shown I2 + I2 == I2, all else
5361 becomes I4 */
5362
5363 lOk = TRUE;
5364 switch (V_VT(left)&VT_TYPEMASK) {
5365 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5366 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5367 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5368 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5369 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5370 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5371 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5372 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5373 default: lOk = FALSE;
5374 }
5375
5376 rOk = TRUE;
5377 switch (V_VT(right)&VT_TYPEMASK) {
5378 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5379 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5380 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5381 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5382 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5383 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5384 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5385 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5386 default: rOk = FALSE;
5387 }
5388
5389 if (lOk && rOk) {
5390 res = (lVal + rVal);
5391 V_VT(result) = resT;
5392 switch (resT) {
5393 case VT_I2 : V_UNION(result,iVal) = res; break;
5394 case VT_I4 : V_UNION(result,lVal) = res; break;
5395 default:
5396 FIXME("Unexpected result variant type %x\n", resT);
5397 V_UNION(result,lVal) = res;
5398 }
5399 rc = S_OK;
5400
5401 } else {
5402 FIXME("unimplemented part\n");
5403 }
5404 }
5405
5406 TRACE("rc=%d, Result:\n", (int) rc);
5407 dump_Variant(result);
5408 return rc;
5409 }
5410
5411 /**********************************************************************
5412 * VarMul [OLEAUT32.156]
5413 *
5414 */
5415 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5416 {
5417 HRESULT rc = E_FAIL;
5418 VARTYPE lvt,rvt,resvt;
5419 VARIANT lv,rv;
5420 BOOL found;
5421
5422 TRACE("left: ");dump_Variant(left);
5423 TRACE("right: ");dump_Variant(right);
5424
5425 VariantInit(&lv);VariantInit(&rv);
5426 lvt = V_VT(left)&VT_TYPEMASK;
5427 rvt = V_VT(right)&VT_TYPEMASK;
5428 found = FALSE;resvt=VT_VOID;
5429 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
5430 found = TRUE;
5431 resvt = VT_R8;
5432 }
5433 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)))) {
5434 found = TRUE;
5435 resvt = VT_I4;
5436 }
5437 if (!found) {
5438 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
5439 return E_FAIL;
5440 }
5441 rc = VariantChangeType(&lv, left, 0, resvt);
5442 if (FAILED(rc)) {
5443 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
5444 return rc;
5445 }
5446 rc = VariantChangeType(&rv, right, 0, resvt);
5447 if (FAILED(rc)) {
5448 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
5449 return rc;
5450 }
5451 switch (resvt) {
5452 case VT_R8:
5453 V_VT(result) = resvt;
5454 V_R8(result) = V_R8(&lv) * V_R8(&rv);
5455 rc = S_OK;
5456 break;
5457 case VT_I4:
5458 V_VT(result) = resvt;
5459 V_I4(result) = V_I4(&lv) * V_I4(&rv);
5460 rc = S_OK;
5461 break;
5462 }
5463 TRACE("rc=%d, Result:\n", (int) rc);
5464 dump_Variant(result);
5465 return rc;
5466 }
5467
5468 /**********************************************************************
5469 * VarDiv [OLEAUT32.143]
5470 *
5471 */
5472 HRESULT WINAPI VarDiv(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 * VarSub [OLEAUT32.159]
5527 *
5528 */
5529 HRESULT WINAPI VarSub(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 * VarOr [OLEAUT32.157]
5584 *
5585 */
5586 HRESULT WINAPI VarOr(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5587 {
5588 HRESULT rc = E_FAIL;
5589
5590 TRACE("Left Var:\n");
5591 dump_Variant(left);
5592 TRACE("Right Var:\n");
5593 dump_Variant(right);
5594
5595 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
5596 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
5597
5598 V_VT(result) = VT_BOOL;
5599 if (V_BOOL(left) || V_BOOL(right)) {
5600 V_BOOL(result) = VARIANT_TRUE;
5601 } else {
5602 V_BOOL(result) = VARIANT_FALSE;
5603 }
5604 rc = S_OK;
5605
5606 } else {
5607 /* Integers */
5608 BOOL lOk = TRUE;
5609 BOOL rOk = TRUE;
5610 LONGLONG lVal = -1;
5611 LONGLONG rVal = -1;
5612 LONGLONG res = -1;
5613 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
5614 becomes I4, even unsigned ints (incl. UI2) */
5615
5616 lOk = TRUE;
5617 switch (V_VT(left)&VT_TYPEMASK) {
5618 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
5619 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
5620 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5621 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
5622 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
5623 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
5624 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5625 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
5626 default: lOk = FALSE;
5627 }
5628
5629 rOk = TRUE;
5630 switch (V_VT(right)&VT_TYPEMASK) {
5631 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
5632 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
5633 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5634 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
5635 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
5636 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
5637 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5638 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
5639 default: rOk = FALSE;
5640 }
5641
5642 if (lOk && rOk) {
5643 res = (lVal | rVal);
5644 V_VT(result) = resT;
5645 switch (resT) {
5646 case VT_I2 : V_UNION(result,iVal) = res; break;
5647 case VT_I4 : V_UNION(result,lVal) = res; break;
5648 default:
5649 FIXME("Unexpected result variant type %x\n", resT);
5650 V_UNION(result,lVal) = res;
5651 }
5652 rc = S_OK;
5653
5654 } else {
5655 FIXME("unimplemented part\n");
5656 }
5657 }
5658
5659 TRACE("rc=%d, Result:\n", (int) rc);
5660 dump_Variant(result);
5661 return rc;
5662 }
5663
5664 /**********************************************************************
5665 * VarNot [OLEAUT32.174]
5666 *
5667 */
5668 HRESULT WINAPI VarNot(LPVARIANT in, LPVARIANT result)
5669 {
5670 HRESULT rc = E_FAIL;
5671
5672 TRACE("Var In:\n");
5673 dump_Variant(in);
5674
5675 if ((V_VT(in)&VT_TYPEMASK) == VT_BOOL) {
5676
5677 V_VT(result) = VT_BOOL;
5678 if (V_BOOL(in)) {
5679 V_BOOL(result) = VARIANT_FALSE;
5680 } else {
5681 V_BOOL(result) = VARIANT_TRUE;
5682 }
5683 rc = S_OK;
5684
5685 } else {
5686 FIXME("VarNot stub\n");
5687 }
5688
5689 TRACE("rc=%d, Result:\n", (int) rc);
5690 dump_Variant(result);
5691 return rc;
5692 }
5693
5694 /**********************************************************************
5695 * VarTokenizeFormatString [OLEAUT32.140]
5696 *
5697 * From investigation on W2K, a list is built up which is:
5698 *
5699 * <0x00> AA BB - Copy from AA for BB chars (Note 1 byte with wrap!)
5700 * <token> - Insert appropriate token
5701 *
5702 */
5703 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR format, LPBYTE rgbTok,
5704 int cbTok, int iFirstDay, int iFirstWeek,
5705 LCID lcid, int *pcbActual) {
5706
5707 FORMATHDR *hdr;
5708 int realLen, formatLeft;
5709 BYTE *pData;
5710 LPSTR pFormatA, pStart;
5711 int checkStr;
5712 BOOL insertCopy = FALSE;
5713 LPSTR copyFrom = NULL;
5714
5715 TRACE("'%s', %p %d %d %d only date support\n", debugstr_w(format), rgbTok, cbTok,
5716 iFirstDay, iFirstWeek);
5717
5718 /* Big enough for header? */
5719 if (cbTok < sizeof(FORMATHDR)) {
5720 return TYPE_E_BUFFERTOOSMALL;
5721 }
5722
5723 /* Insert header */
5724 hdr = (FORMATHDR *) rgbTok;
5725 memset(hdr, 0x00, sizeof(FORMATHDR));
5726 hdr->hex3 = 0x03; /* No idea what these are */
5727 hdr->hex6 = 0x06;
5728
5729 /* Start parsing string */
5730 realLen = sizeof(FORMATHDR);
5731 pData = rgbTok + realLen;
5732 pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5733 pStart = pFormatA;
5734 formatLeft = strlen(pFormatA);
5735
5736 /* Work through the format */
5737 while (*pFormatA != 0x00) {
5738
5739 checkStr = 0;
5740 while (checkStr>=0 && (formatTokens[checkStr].tokenSize != 0x00)) {
5741 if (formatLeft >= formatTokens[checkStr].tokenSize &&
5742 strncmp(formatTokens[checkStr].str, pFormatA,
5743 formatTokens[checkStr].tokenSize) == 0) {
5744 TRACE("match on '%s'\n", formatTokens[checkStr].str);
5745
5746 /* Found Match! */
5747
5748 /* If we have skipped chars, insert the copy */
5749 if (insertCopy == TRUE) {
5750
5751 if ((realLen + 3) > cbTok) {
5752 HeapFree( GetProcessHeap(), 0, pFormatA );
5753 return TYPE_E_BUFFERTOOSMALL;
5754 }
5755 insertCopy = FALSE;
5756 *pData = TOK_COPY;
5757 pData++;
5758 *pData = (BYTE)(copyFrom - pStart);
5759 pData++;
5760 *pData = (BYTE)(pFormatA - copyFrom);
5761 pData++;
5762 realLen = realLen + 3;
5763 }
5764
5765
5766 /* Now insert the token itself */
5767 if ((realLen + 1) > cbTok) {
5768 HeapFree( GetProcessHeap(), 0, pFormatA );
5769 return TYPE_E_BUFFERTOOSMALL;
5770 }
5771 *pData = formatTokens[checkStr].tokenId;
5772 pData = pData + 1;
5773 realLen = realLen + 1;
5774
5775 pFormatA = pFormatA + formatTokens[checkStr].tokenSize;
5776 formatLeft = formatLeft - formatTokens[checkStr].tokenSize;
5777 checkStr = -1; /* Flag as found and break out of while loop */
5778 } else {
5779 checkStr++;
5780 }
5781 }
5782
5783 /* Did we ever match a token? */
5784 if (checkStr != -1 && insertCopy == FALSE) {
5785 TRACE("No match - need to insert copy from %p [%p]\n", pFormatA, pStart);
5786 insertCopy = TRUE;
5787 copyFrom = pFormatA;
5788 } else if (checkStr != -1) {
5789 pFormatA = pFormatA + 1;
5790 }
5791
5792 }
5793
5794 /* Finally, if we have skipped chars, insert the copy */
5795 if (insertCopy == TRUE) {
5796
5797 TRACE("Chars left over, so still copy %p,%p,%p\n", copyFrom, pStart, pFormatA);
5798 if ((realLen + 3) > cbTok) {
5799 HeapFree( GetProcessHeap(), 0, pFormatA );
5800 return TYPE_E_BUFFERTOOSMALL;
5801 }
5802 insertCopy = FALSE;
5803 *pData = TOK_COPY;
5804 pData++;
5805 *pData = (BYTE)(copyFrom - pStart);
5806 pData++;
5807 *pData = (BYTE)(pFormatA - copyFrom);
5808 pData++;
5809 realLen = realLen + 3;
5810 }
5811
5812 /* Finally insert the terminator */
5813 if ((realLen + 1) > cbTok) {
5814 HeapFree( GetProcessHeap(), 0, pFormatA );
5815 return TYPE_E_BUFFERTOOSMALL;
5816 }
5817 *pData++ = TOK_END;
5818 realLen = realLen + 1;
5819
5820 /* Finally fill in the length */
5821 hdr->len = realLen;
5822 *pcbActual = realLen;
5823
5824 #if 0
5825 { int i,j;
5826 for (i=0; i<realLen; i=i+0x10) {
5827 printf(" %4.4x : ", i);
5828 for (j=0; j<0x10 && (i+j < realLen); j++) {
5829 printf("%2.2x ", rgbTok[i+j]);
5830 }
5831 printf("\n");
5832 }
5833 }
5834 #endif
5835 HeapFree( GetProcessHeap(), 0, pFormatA );
5836
5837 return S_OK;
5838 }
5839
5840 /**********************************************************************
5841 * VarFormatFromTokens [OLEAUT32.139]
5842 * FIXME: No account of flags or iFirstDay etc
5843 */
5844 HRESULT WINAPI VarFormatFromTokens(LPVARIANT varIn, LPOLESTR format,
5845 LPBYTE pbTokCur, ULONG dwFlags, BSTR *pbstrOut,
5846 LCID lcid) {
5847
5848 FORMATHDR *hdr = (FORMATHDR *)pbTokCur;
5849 BYTE *pData = pbTokCur + sizeof (FORMATHDR);
5850 LPSTR pFormatA = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
5851 char output[BUFFER_MAX];
5852 char *pNextPos;
5853 int size, whichToken;
5854 VARIANTARG Variant;
5855 struct tm TM;
5856
5857
5858
5859 TRACE("'%s', %p %lx %p only date support\n", pFormatA, pbTokCur, dwFlags, pbstrOut);
5860 TRACE("varIn:\n");
5861 dump_Variant(varIn);
5862
5863 memset(output, 0x00, BUFFER_MAX);
5864 pNextPos = output;
5865
5866 while (*pData != TOK_END && ((pData - pbTokCur) <= (hdr->len))) {
5867
5868 TRACE("Output looks like : '%s'\n", output);
5869
5870 /* Convert varient to appropriate data type */
5871 whichToken = 0;
5872 while ((formatTokens[whichToken].tokenSize != 0x00) &&
5873 (formatTokens[whichToken].tokenId != *pData)) {
5874 whichToken++;
5875 }
5876
5877 /* Use Variant local from here downwards as always correct type */
5878 if (formatTokens[whichToken].tokenSize > 0 &&
5879 formatTokens[whichToken].varTypeRequired != 0) {
5880 VariantInit( &Variant );
5881 if (Coerce( &Variant, lcid, dwFlags, varIn,
5882 formatTokens[whichToken].varTypeRequired ) != S_OK) {
5883 HeapFree( GetProcessHeap(), 0, pFormatA );
5884 return DISP_E_TYPEMISMATCH;
5885 } else if (formatTokens[whichToken].varTypeRequired == VT_DATE) {
5886 if( DateToTm( V_UNION(&Variant,date), dwFlags, &TM ) == FALSE ) {
5887 HeapFree( GetProcessHeap(), 0, pFormatA );
5888 return E_INVALIDARG;
5889 }
5890 }
5891 }
5892
5893 TRACE("Looking for match on token '%x'\n", *pData);
5894 switch (*pData) {
5895 case TOK_COPY:
5896 TRACE("Copy from %d for %d bytes\n", *(pData+1), *(pData+2));
5897 memcpy(pNextPos, &pFormatA[*(pData+1)], *(pData+2));
5898 pNextPos = pNextPos + *(pData+2);
5899 pData = pData + 3;
5900 break;
5901
5902 case TOK_COLON :
5903 /* Get locale information - Time Seperator */
5904 size = GetLocaleInfoA(lcid, LOCALE_STIME, NULL, 0);
5905 GetLocaleInfoA(lcid, LOCALE_STIME, pNextPos, size);
5906 TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos);
5907 pNextPos = pNextPos + size;
5908 pData = pData + 1;
5909 break;
5910
5911 case TOK_SLASH :
5912 /* Get locale information - Date Seperator */
5913 size = GetLocaleInfoA(lcid, LOCALE_SDATE, NULL, 0);
5914 GetLocaleInfoA(lcid, LOCALE_SDATE, pNextPos, size);
5915 TRACE("TOK_COLON Time seperator is '%s'\n", pNextPos);
5916 pNextPos = pNextPos + size;
5917 pData = pData + 1;
5918 break;
5919
5920 case TOK_d :
5921 sprintf(pNextPos, "%d", TM.tm_mday);
5922 pNextPos = pNextPos + strlen(pNextPos);
5923 pData = pData + 1;
5924 break;
5925
5926 case TOK_dd :
5927 sprintf(pNextPos, "%2.2d", TM.tm_mday);
5928 pNextPos = pNextPos + strlen(pNextPos);
5929 pData = pData + 1;
5930 break;
5931
5932 case TOK_w :
5933 sprintf(pNextPos, "%d", TM.tm_wday+1);
5934 pNextPos = pNextPos + strlen(pNextPos);
5935 pData = pData + 1;
5936 break;
5937
5938 case TOK_m :
5939 sprintf(pNextPos, "%d", TM.tm_mon+1);
5940 pNextPos = pNextPos + strlen(pNextPos);
5941 pData = pData + 1;
5942 break;
5943
5944 case TOK_mm :
5945 sprintf(pNextPos, "%2.2d", TM.tm_mon+1);
5946 pNextPos = pNextPos + strlen(pNextPos);
5947 pData = pData + 1;
5948 break;
5949
5950 case TOK_q :
5951 sprintf(pNextPos, "%d", ((TM.tm_mon+1)/4)+1);
5952 pNextPos = pNextPos + strlen(pNextPos);
5953 pData = pData + 1;
5954 break;
5955
5956 case TOK_y :
5957 sprintf(pNextPos, "%2.2d", TM.tm_yday+1);
5958 pNextPos = pNextPos + strlen(pNextPos);
5959 pData = pData + 1;
5960 break;
5961
5962 case TOK_yy :
5963 sprintf(pNextPos, "%2.2d", TM.tm_year);
5964 pNextPos = pNextPos + strlen(pNextPos);
5965 pData = pData + 1;
5966 break;
5967
5968 case TOK_yyyy :
5969 sprintf(pNextPos, "%4.4d", TM.tm_year);
5970 pNextPos = pNextPos + strlen(pNextPos);
5971 pData = pData + 1;
5972 break;
5973
5974 case TOK_h :
5975 sprintf(pNextPos, "%d", TM.tm_hour);
5976 pNextPos = pNextPos + strlen(pNextPos);
5977 pData = pData + 1;
5978 break;
5979
5980 case TOK_Hh :
5981 sprintf(pNextPos, "%2.2d", TM.tm_hour);
5982 pNextPos = pNextPos + strlen(pNextPos);
5983 pData = pData + 1;
5984 break;
5985
5986 case TOK_N :
5987 sprintf(pNextPos, "%d", TM.tm_min);
5988 pNextPos = pNextPos + strlen(pNextPos);
5989 pData = pData + 1;
5990 break;
5991
5992 case TOK_Nn :
5993 sprintf(pNextPos, "%2.2d", TM.tm_min);
5994 pNextPos = pNextPos + strlen(pNextPos);
5995 pData = pData + 1;
5996 break;
5997
5998 case TOK_S :
5999 sprintf(pNextPos, "%d", TM.tm_sec);
6000 pNextPos = pNextPos + strlen(pNextPos);
6001 pData = pData + 1;
6002 break;
6003
6004 case TOK_Ss :
6005 sprintf(pNextPos, "%2.2d", TM.tm_sec);
6006 pNextPos = pNextPos + strlen(pNextPos);
6007 pData = pData + 1;
6008 break;
6009
6010 /* FIXME: To Do! */
6011 case TOK_ttttt :
6012 case TOK_AMsPM :
6013 case TOK_amspm :
6014 case TOK_AsP :
6015 case TOK_asp :
6016 case TOK_AMPM :
6017 case TOK_c :
6018 case TOK_ddd :
6019 case TOK_dddd :
6020 case TOK_ddddd :
6021 case TOK_dddddd :
6022 case TOK_ww :
6023 case TOK_mmm :
6024 case TOK_mmmm :
6025 default:
6026 FIXME("Unhandled token for VarFormat %d\n", *pData);
6027 HeapFree( GetProcessHeap(), 0, pFormatA );
6028 return E_INVALIDARG;
6029 }
6030
6031 }
6032
6033 *pbstrOut = StringDupAtoBstr( output );
6034 HeapFree( GetProcessHeap(), 0, pFormatA );
6035 return S_OK;
6036 }
6037
6038 /**********************************************************************
6039 * VarFormat [OLEAUT32.87]
6040 *
6041 */
6042 HRESULT WINAPI VarFormat(LPVARIANT varIn, LPOLESTR format,
6043 int firstDay, int firstWeek, ULONG dwFlags,
6044 BSTR *pbstrOut) {
6045
6046 LPSTR pNewString = NULL;
6047 HRESULT rc = S_OK;
6048
6049 TRACE("mostly stub! format='%s' day=%d, wk=%d, flags=%ld\n",
6050 debugstr_w(format), firstDay, firstWeek, dwFlags);
6051 TRACE("varIn:\n");
6052 dump_Variant(varIn);
6053
6054 /* Note: Must Handle references type Variants (contain ptrs
6055 to values rather than values */
6056
6057 /* Get format string */
6058 pNewString = HEAP_strdupWtoA( GetProcessHeap(), 0, format );
6059
6060 /* FIXME: Handle some simple pre-definted format strings : */
6061 if (((V_VT(varIn)&VT_TYPEMASK) == VT_CY) && (lstrcmpiA(pNewString, "Currency") == 0)) {
6062
6063 /* Can't use VarBstrFromCy as it does not put currency sign on nor decimal places */
6064 double curVal;
6065
6066
6067 /* Handle references type Variants (contain ptrs to values rather than values */
6068 if (V_VT(varIn)&VT_BYREF) {
6069 rc = VarR8FromCy(*(CY *)V_UNION(varIn,byref), &curVal);
6070 } else {
6071 rc = VarR8FromCy(V_UNION(varIn,cyVal), &curVal);
6072 }
6073
6074 if (rc == S_OK) {
6075 char tmpStr[BUFFER_MAX];
6076 sprintf(tmpStr, "%f", curVal);
6077 if (GetCurrencyFormatA(GetUserDefaultLCID(), dwFlags, tmpStr, NULL, pBuffer, BUFFER_MAX) == 0) {
6078 return E_FAIL;
6079 } else {
6080 *pbstrOut = StringDupAtoBstr( pBuffer );
6081 }
6082 }
6083
6084 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_DATE) {
6085
6086 /* Attempt to do proper formatting! */
6087 int firstToken = -1;
6088
6089 rc = VarTokenizeFormatString(format, pBuffer, sizeof(pBuffer), firstDay,
6090 firstWeek, GetUserDefaultLCID(), &firstToken);
6091 if (rc==S_OK) {
6092 rc = VarFormatFromTokens(varIn, format, pBuffer, dwFlags, pbstrOut, GetUserDefaultLCID());
6093 }
6094
6095 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_R8) {
6096 if (V_VT(varIn)&VT_BYREF) {
6097 sprintf(pBuffer, "%f", *V_UNION(varIn,pdblVal));
6098 } else {
6099 sprintf(pBuffer, "%f", V_UNION(varIn,dblVal));
6100 }
6101 *pbstrOut = StringDupAtoBstr( pBuffer );
6102 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_I2) {
6103 if (V_VT(varIn)&VT_BYREF) {
6104 sprintf(pBuffer, "%d", *V_UNION(varIn,piVal));
6105 } else {
6106 sprintf(pBuffer, "%d", V_UNION(varIn,iVal));
6107 }
6108 *pbstrOut = StringDupAtoBstr( pBuffer );
6109 } else if ((V_VT(varIn)&VT_TYPEMASK) == VT_BSTR) {
6110 if (V_VT(varIn)&VT_BYREF)
6111 *pbstrOut = SysAllocString( *V_UNION(varIn,pbstrVal) );
6112 else
6113 *pbstrOut = SysAllocString( V_UNION(varIn,bstrVal) );
6114 } else {
6115 FIXME("VarFormat: Unsupported format %d!\n", V_VT(varIn)&VT_TYPEMASK);
6116 *pbstrOut = StringDupAtoBstr( "??" );
6117 }
6118
6119 /* Free allocated storage */
6120 HeapFree( GetProcessHeap(), 0, pNewString );
6121 TRACE("result: '%s'\n", debugstr_w(*pbstrOut));
6122 return rc;
6123 }
6124
6125 /**********************************************************************
6126 * VarCyMulI4 [OLEAUT32.304]
6127 * Multiply currency value by integer
6128 */
6129 HRESULT WINAPI VarCyMulI4(CY cyIn, LONG mulBy, CY *pcyOut) {
6130
6131 double cyVal = 0;
6132 HRESULT rc = S_OK;
6133
6134 rc = VarR8FromCy(cyIn, &cyVal);
6135 if (rc == S_OK) {
6136 rc = VarCyFromR8((cyVal * (double) mulBy), pcyOut);
6137 TRACE("Multiply %f by %ld = %f [%ld,%lu]\n", cyVal, mulBy, (cyVal * (double) mulBy),
6138 pcyOut->s.Hi, pcyOut->s.Lo);
6139 }
6140 return rc;
6141 }
Maarten's multimedia branch