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