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