?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Moved more GDI definitions to gdi_private.h.
[wine/testsucceed.git] / dlls / oleaut32 / variant.c
blobcdfb3787e3a42edd26a38aa2d5060df5af38afd5
1 /*
2 * VARIANT
3 *
4 * Copyright 1998 Jean-Claude Cote
5 * Copyright 2003 Jon Griffiths
6 * The alorithm for conversion from Julian days to day/month/year is based on
7 * that devised by Henry Fliegel, as implemented in PostgreSQL, which is
8 * Copyright 1994-7 Regents of the University of California
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include "config.h"
26
27 #include <string.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30
31 #define NONAMELESSUNION
32 #define NONAMELESSSTRUCT
33 #include "windef.h"
34 #include "winbase.h"
35 #include "oleauto.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38 #include "winerror.h"
39 #include "variant.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42
43 const char* wine_vtypes[VT_CLSID] =
44 {
45 "VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE",
46 "VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN",
47 "VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8",
48 "VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY",
49 "VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR""32","33","34","35",
50 "VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45",
51 "46","47","48","49","50","51","52","53","54","55","56","57","58","59","60",
52 "61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE",
53 "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID"
54 };
55
56 const char* wine_vflags[16] =
57 {
58 "",
59 "|VT_VECTOR",
60 "|VT_ARRAY",
61 "|VT_VECTOR|VT_ARRAY",
62 "|VT_BYREF",
63 "|VT_VECTOR|VT_ARRAY",
64 "|VT_ARRAY|VT_BYREF",
65 "|VT_VECTOR|VT_ARRAY|VT_BYREF",
66 "|VT_HARDTYPE",
67 "|VT_VECTOR|VT_HARDTYPE",
68 "|VT_ARRAY|VT_HARDTYPE",
69 "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE",
70 "|VT_BYREF|VT_HARDTYPE",
71 "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE",
72 "|VT_ARRAY|VT_BYREF|VT_HARDTYPE",
73 "|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_HARDTYPE",
74 };
75
76 /* Convert a variant from one type to another */
77 static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
78 VARIANTARG* ps, VARTYPE vt)
79 {
80 HRESULT res = DISP_E_TYPEMISMATCH;
81 VARTYPE vtFrom = V_TYPE(ps);
82 DWORD dwFlags = 0;
83
84 TRACE("(%p->(%s%s),0x%08lx,0x%04x,%p->(%s%s),%s%s)\n", pd, debugstr_VT(pd),
85 debugstr_VF(pd), lcid, wFlags, ps, debugstr_VT(ps), debugstr_VF(ps),
86 debugstr_vt(vt), debugstr_vf(vt));
87
88 if (vt == VT_BSTR || vtFrom == VT_BSTR)
89 {
90 /* All flags passed to low level function are only used for
91 * changing to or from strings. Map these here.
92 */
93 if (wFlags & VARIANT_LOCALBOOL)
94 dwFlags |= VAR_LOCALBOOL;
95 if (wFlags & VARIANT_CALENDAR_HIJRI)
96 dwFlags |= VAR_CALENDAR_HIJRI;
97 if (wFlags & VARIANT_CALENDAR_THAI)
98 dwFlags |= VAR_CALENDAR_THAI;
99 if (wFlags & VARIANT_CALENDAR_GREGORIAN)
100 dwFlags |= VAR_CALENDAR_GREGORIAN;
101 if (wFlags & VARIANT_NOUSEROVERRIDE)
102 dwFlags |= LOCALE_NOUSEROVERRIDE;
103 if (wFlags & VARIANT_USE_NLS)
104 dwFlags |= LOCALE_USE_NLS;
105 }
106
107 /* Map int/uint to i4/ui4 */
108 if (vt == VT_INT)
109 vt = VT_I4;
110 else if (vt == VT_UINT)
111 vt = VT_UI4;
112
113 if (vtFrom == VT_INT)
114 vtFrom = VT_I4;
115 else if (vtFrom == VT_UINT)
116 vtFrom = VT_UI4;
117
118 if (vt == vtFrom)
119 return VariantCopy(pd, ps);
120
121 if (wFlags & VARIANT_NOVALUEPROP && vtFrom == VT_DISPATCH && vt != VT_UNKNOWN)
122 {
123 /* VARIANT_NOVALUEPROP prevents IDispatch objects from being coerced by
124 * accessing the default object property.
125 */
126 return DISP_E_TYPEMISMATCH;
127 }
128
129 switch (vt)
130 {
131 case VT_EMPTY:
132 if (vtFrom == VT_NULL)
133 return DISP_E_TYPEMISMATCH;
134 /* ... Fall through */
135 case VT_NULL:
136 if (vtFrom <= VT_UINT && vtFrom != (VARTYPE)15 && vtFrom != VT_ERROR)
137 {
138 res = VariantClear( pd );
139 if (vt == VT_NULL && SUCCEEDED(res))
140 V_VT(pd) = VT_NULL;
141 }
142 return res;
143
144 case VT_I1:
145 switch (vtFrom)
146 {
147 case VT_EMPTY: V_I1(pd) = 0; return S_OK;
148 case VT_I2: return VarI1FromI2(V_I2(ps), &V_I1(pd));
149 case VT_I4: return VarI1FromI4(V_I4(ps), &V_I1(pd));
150 case VT_UI1: return VarI1FromUI1(V_UI1(ps), &V_I1(pd));
151 case VT_UI2: return VarI1FromUI2(V_UI2(ps), &V_I1(pd));
152 case VT_UI4: return VarI1FromUI4(V_UI4(ps), &V_I1(pd));
153 case VT_I8: return VarI1FromI8(V_I8(ps), &V_I1(pd));
154 case VT_UI8: return VarI1FromUI8(V_UI8(ps), &V_I1(pd));
155 case VT_R4: return VarI1FromR4(V_R4(ps), &V_I1(pd));
156 case VT_R8: return VarI1FromR8(V_R8(ps), &V_I1(pd));
157 case VT_DATE: return VarI1FromDate(V_DATE(ps), &V_I1(pd));
158 case VT_BOOL: return VarI1FromBool(V_BOOL(ps), &V_I1(pd));
159 case VT_CY: return VarI1FromCy(V_CY(ps), &V_I1(pd));
160 case VT_DECIMAL: return VarI1FromDec(&V_DECIMAL(ps), &V_I1(pd) );
161 case VT_DISPATCH: return VarI1FromDisp(V_DISPATCH(ps), lcid, &V_I1(pd) );
162 case VT_BSTR: return VarI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_I1(pd) );
163 }
164 break;
165
166 case VT_I2:
167 switch (vtFrom)
168 {
169 case VT_EMPTY: V_I2(pd) = 0; return S_OK;
170 case VT_I1: return VarI2FromI1(V_I1(ps), &V_I2(pd));
171 case VT_I4: return VarI2FromI4(V_I4(ps), &V_I2(pd));
172 case VT_UI1: return VarI2FromUI1(V_UI1(ps), &V_I2(pd));
173 case VT_UI2: return VarI2FromUI2(V_UI2(ps), &V_I2(pd));
174 case VT_UI4: return VarI2FromUI4(V_UI4(ps), &V_I2(pd));
175 case VT_I8: return VarI2FromI8(V_I8(ps), &V_I2(pd));
176 case VT_UI8: return VarI2FromUI8(V_UI8(ps), &V_I2(pd));
177 case VT_R4: return VarI2FromR4(V_R4(ps), &V_I2(pd));
178 case VT_R8: return VarI2FromR8(V_R8(ps), &V_I2(pd));
179 case VT_DATE: return VarI2FromDate(V_DATE(ps), &V_I2(pd));
180 case VT_BOOL: return VarI2FromBool(V_BOOL(ps), &V_I2(pd));
181 case VT_CY: return VarI2FromCy(V_CY(ps), &V_I2(pd));
182 case VT_DECIMAL: return VarI2FromDec(&V_DECIMAL(ps), &V_I2(pd));
183 case VT_DISPATCH: return VarI2FromDisp(V_DISPATCH(ps), lcid, &V_I2(pd));
184 case VT_BSTR: return VarI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_I2(pd));
185 }
186 break;
187
188 case VT_I4:
189 switch (vtFrom)
190 {
191 case VT_EMPTY: V_I4(pd) = 0; return S_OK;
192 case VT_I1: return VarI4FromI1(V_I1(ps), &V_I4(pd));
193 case VT_I2: return VarI4FromI2(V_I2(ps), &V_I4(pd));
194 case VT_UI1: return VarI4FromUI1(V_UI1(ps), &V_I4(pd));
195 case VT_UI2: return VarI4FromUI2(V_UI2(ps), &V_I4(pd));
196 case VT_UI4: return VarI4FromUI4(V_UI4(ps), &V_I4(pd));
197 case VT_I8: return VarI4FromI8(V_I8(ps), &V_I4(pd));
198 case VT_UI8: return VarI4FromUI8(V_UI8(ps), &V_I4(pd));
199 case VT_R4: return VarI4FromR4(V_R4(ps), &V_I4(pd));
200 case VT_R8: return VarI4FromR8(V_R8(ps), &V_I4(pd));
201 case VT_DATE: return VarI4FromDate(V_DATE(ps), &V_I4(pd));
202 case VT_BOOL: return VarI4FromBool(V_BOOL(ps), &V_I4(pd));
203 case VT_CY: return VarI4FromCy(V_CY(ps), &V_I4(pd));
204 case VT_DECIMAL: return VarI4FromDec(&V_DECIMAL(ps), &V_I4(pd));
205 case VT_DISPATCH: return VarI4FromDisp(V_DISPATCH(ps), lcid, &V_I4(pd));
206 case VT_BSTR: return VarI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_I4(pd));
207 }
208 break;
209
210 case VT_UI1:
211 switch (vtFrom)
212 {
213 case VT_EMPTY: V_UI1(pd) = 0; return S_OK;
214 case VT_I1: return VarUI1FromI1(V_I1(ps), &V_UI1(pd));
215 case VT_I2: return VarUI1FromI2(V_I2(ps), &V_UI1(pd));
216 case VT_I4: return VarUI1FromI4(V_I4(ps), &V_UI1(pd));
217 case VT_UI2: return VarUI1FromUI2(V_UI2(ps), &V_UI1(pd));
218 case VT_UI4: return VarUI1FromUI4(V_UI4(ps), &V_UI1(pd));
219 case VT_I8: return VarUI1FromI8(V_I8(ps), &V_UI1(pd));
220 case VT_UI8: return VarUI1FromUI8(V_UI8(ps), &V_UI1(pd));
221 case VT_R4: return VarUI1FromR4(V_R4(ps), &V_UI1(pd));
222 case VT_R8: return VarUI1FromR8(V_R8(ps), &V_UI1(pd));
223 case VT_DATE: return VarUI1FromDate(V_DATE(ps), &V_UI1(pd));
224 case VT_BOOL: return VarUI1FromBool(V_BOOL(ps), &V_UI1(pd));
225 case VT_CY: return VarUI1FromCy(V_CY(ps), &V_UI1(pd));
226 case VT_DECIMAL: return VarUI1FromDec(&V_DECIMAL(ps), &V_UI1(pd));
227 case VT_DISPATCH: return VarUI1FromDisp(V_DISPATCH(ps), lcid, &V_UI1(pd));
228 case VT_BSTR: return VarUI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI1(pd));
229 }
230 break;
231
232 case VT_UI2:
233 switch (vtFrom)
234 {
235 case VT_EMPTY: V_UI2(pd) = 0; return S_OK;
236 case VT_I1: return VarUI2FromI1(V_I1(ps), &V_UI2(pd));
237 case VT_I2: return VarUI2FromI2(V_I2(ps), &V_UI2(pd));
238 case VT_I4: return VarUI2FromI4(V_I4(ps), &V_UI2(pd));
239 case VT_UI1: return VarUI2FromUI1(V_UI1(ps), &V_UI2(pd));
240 case VT_UI4: return VarUI2FromUI4(V_UI4(ps), &V_UI2(pd));
241 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
242 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
243 case VT_R4: return VarUI2FromR4(V_R4(ps), &V_UI2(pd));
244 case VT_R8: return VarUI2FromR8(V_R8(ps), &V_UI2(pd));
245 case VT_DATE: return VarUI2FromDate(V_DATE(ps), &V_UI2(pd));
246 case VT_BOOL: return VarUI2FromBool(V_BOOL(ps), &V_UI2(pd));
247 case VT_CY: return VarUI2FromCy(V_CY(ps), &V_UI2(pd));
248 case VT_DECIMAL: return VarUI2FromDec(&V_DECIMAL(ps), &V_UI2(pd));
249 case VT_DISPATCH: return VarUI2FromDisp(V_DISPATCH(ps), lcid, &V_UI2(pd));
250 case VT_BSTR: return VarUI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI2(pd));
251 }
252 break;
253
254 case VT_UI4:
255 switch (vtFrom)
256 {
257 case VT_EMPTY: V_UI4(pd) = 0; return S_OK;
258 case VT_I1: return VarUI4FromI1(V_I1(ps), &V_UI4(pd));
259 case VT_I2: return VarUI4FromI2(V_I2(ps), &V_UI4(pd));
260 case VT_I4: return VarUI4FromI4(V_I4(ps), &V_UI4(pd));
261 case VT_UI1: return VarUI4FromUI1(V_UI1(ps), &V_UI4(pd));
262 case VT_UI2: return VarUI4FromUI2(V_UI2(ps), &V_UI4(pd));
263 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
264 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
265 case VT_R4: return VarUI4FromR4(V_R4(ps), &V_UI4(pd));
266 case VT_R8: return VarUI4FromR8(V_R8(ps), &V_UI4(pd));
267 case VT_DATE: return VarUI4FromDate(V_DATE(ps), &V_UI4(pd));
268 case VT_BOOL: return VarUI4FromBool(V_BOOL(ps), &V_UI4(pd));
269 case VT_CY: return VarUI4FromCy(V_CY(ps), &V_UI4(pd));
270 case VT_DECIMAL: return VarUI4FromDec(&V_DECIMAL(ps), &V_UI4(pd));
271 case VT_DISPATCH: return VarUI4FromDisp(V_DISPATCH(ps), lcid, &V_UI4(pd));
272 case VT_BSTR: return VarUI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI4(pd));
273 }
274 break;
275
276 case VT_UI8:
277 switch (vtFrom)
278 {
279 case VT_EMPTY: V_UI8(pd) = 0; return S_OK;
280 case VT_I4: if (V_I4(ps) < 0) return DISP_E_OVERFLOW; V_UI8(pd) = V_I4(ps); return S_OK;
281 case VT_I1: return VarUI8FromI1(V_I1(ps), &V_UI8(pd));
282 case VT_I2: return VarUI8FromI2(V_I2(ps), &V_UI8(pd));
283 case VT_UI1: return VarUI8FromUI1(V_UI1(ps), &V_UI8(pd));
284 case VT_UI2: return VarUI8FromUI2(V_UI2(ps), &V_UI8(pd));
285 case VT_UI4: return VarUI8FromUI4(V_UI4(ps), &V_UI8(pd));
286 case VT_I8: return VarUI8FromI8(V_I8(ps), &V_UI8(pd));
287 case VT_R4: return VarUI8FromR4(V_R4(ps), &V_UI8(pd));
288 case VT_R8: return VarUI8FromR8(V_R8(ps), &V_UI8(pd));
289 case VT_DATE: return VarUI8FromDate(V_DATE(ps), &V_UI8(pd));
290 case VT_BOOL: return VarUI8FromBool(V_BOOL(ps), &V_UI8(pd));
291 case VT_CY: return VarUI8FromCy(V_CY(ps), &V_UI8(pd));
292 case VT_DECIMAL: return VarUI8FromDec(&V_DECIMAL(ps), &V_UI8(pd));
293 case VT_DISPATCH: return VarUI8FromDisp(V_DISPATCH(ps), lcid, &V_UI8(pd));
294 case VT_BSTR: return VarUI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI8(pd));
295 }
296 break;
297
298 case VT_I8:
299 switch (vtFrom)
300 {
301 case VT_EMPTY: V_I8(pd) = 0; return S_OK;
302 case VT_I4: V_I8(pd) = V_I4(ps); return S_OK;
303 case VT_I1: return VarI8FromI1(V_I1(ps), &V_I8(pd));
304 case VT_I2: return VarI8FromI2(V_I2(ps), &V_I8(pd));
305 case VT_UI1: return VarI8FromUI1(V_UI1(ps), &V_I8(pd));
306 case VT_UI2: return VarI8FromUI2(V_UI2(ps), &V_I8(pd));
307 case VT_UI4: return VarI8FromUI4(V_UI4(ps), &V_I8(pd));
308 case VT_UI8: return VarI8FromUI8(V_I8(ps), &V_I8(pd));
309 case VT_R4: return VarI8FromR4(V_R4(ps), &V_I8(pd));
310 case VT_R8: return VarI8FromR8(V_R8(ps), &V_I8(pd));
311 case VT_DATE: return VarI8FromDate(V_DATE(ps), &V_I8(pd));
312 case VT_BOOL: return VarI8FromBool(V_BOOL(ps), &V_I8(pd));
313 case VT_CY: return VarI8FromCy(V_CY(ps), &V_I8(pd));
314 case VT_DECIMAL: return VarI8FromDec(&V_DECIMAL(ps), &V_I8(pd));
315 case VT_DISPATCH: return VarI8FromDisp(V_DISPATCH(ps), lcid, &V_I8(pd));
316 case VT_BSTR: return VarI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_I8(pd));
317 }
318 break;
319
320 case VT_R4:
321 switch (vtFrom)
322 {
323 case VT_EMPTY: V_R4(pd) = 0.0f; return S_OK;
324 case VT_I1: return VarR4FromI1(V_I1(ps), &V_R4(pd));
325 case VT_I2: return VarR4FromI2(V_I2(ps), &V_R4(pd));
326 case VT_I4: return VarR4FromI4(V_I4(ps), &V_R4(pd));
327 case VT_UI1: return VarR4FromUI1(V_UI1(ps), &V_R4(pd));
328 case VT_UI2: return VarR4FromUI2(V_UI2(ps), &V_R4(pd));
329 case VT_UI4: return VarR4FromUI4(V_UI4(ps), &V_R4(pd));
330 case VT_I8: return VarR4FromI8(V_I8(ps), &V_R4(pd));
331 case VT_UI8: return VarR4FromUI8(V_UI8(ps), &V_R4(pd));
332 case VT_R8: return VarR4FromR8(V_R8(ps), &V_R4(pd));
333 case VT_DATE: return VarR4FromDate(V_DATE(ps), &V_R4(pd));
334 case VT_BOOL: return VarR4FromBool(V_BOOL(ps), &V_R4(pd));
335 case VT_CY: return VarR4FromCy(V_CY(ps), &V_R4(pd));
336 case VT_DECIMAL: return VarR4FromDec(&V_DECIMAL(ps), &V_R4(pd));
337 case VT_DISPATCH: return VarR4FromDisp(V_DISPATCH(ps), lcid, &V_R4(pd));
338 case VT_BSTR: return VarR4FromStr(V_BSTR(ps), lcid, dwFlags, &V_R4(pd));
339 }
340 break;
341
342 case VT_R8:
343 switch (vtFrom)
344 {
345 case VT_EMPTY: V_R8(pd) = 0.0; return S_OK;
346 case VT_I1: return VarR8FromI1(V_I1(ps), &V_R8(pd));
347 case VT_I2: return VarR8FromI2(V_I2(ps), &V_R8(pd));
348 case VT_I4: return VarR8FromI4(V_I4(ps), &V_R8(pd));
349 case VT_UI1: return VarR8FromUI1(V_UI1(ps), &V_R8(pd));
350 case VT_UI2: return VarR8FromUI2(V_UI2(ps), &V_R8(pd));
351 case VT_UI4: return VarR8FromUI4(V_UI4(ps), &V_R8(pd));
352 case VT_I8: return VarR8FromI8(V_I8(ps), &V_R8(pd));
353 case VT_UI8: return VarR8FromUI8(V_UI8(ps), &V_R8(pd));
354 case VT_R4: return VarR8FromR4(V_R4(ps), &V_R8(pd));
355 case VT_DATE: return VarR8FromDate(V_DATE(ps), &V_R8(pd));
356 case VT_BOOL: return VarR8FromBool(V_BOOL(ps), &V_R8(pd));
357 case VT_CY: return VarR8FromCy(V_CY(ps), &V_R8(pd));
358 case VT_DECIMAL: return VarR8FromDec(&V_DECIMAL(ps), &V_R8(pd));
359 case VT_DISPATCH: return VarR8FromDisp(V_DISPATCH(ps), lcid, &V_R8(pd));
360 case VT_BSTR: return VarR8FromStr(V_BSTR(ps), lcid, dwFlags, &V_R8(pd));
361 }
362 break;
363
364 case VT_DATE:
365 switch (vtFrom)
366 {
367 case VT_EMPTY: V_DATE(pd) = 0.0; return S_OK;
368 case VT_I1: return VarDateFromI1(V_I1(ps), &V_DATE(pd));
369 case VT_I2: return VarDateFromI2(V_I2(ps), &V_DATE(pd));
370 case VT_I4: return VarDateFromI4(V_I4(ps), &V_DATE(pd));
371 case VT_UI1: return VarDateFromUI1(V_UI1(ps), &V_DATE(pd));
372 case VT_UI2: return VarDateFromUI2(V_UI2(ps), &V_DATE(pd));
373 case VT_UI4: return VarDateFromUI4(V_UI4(ps), &V_DATE(pd));
374 case VT_I8: return VarDateFromI8(V_I8(ps), &V_DATE(pd));
375 case VT_UI8: return VarDateFromUI8(V_UI8(ps), &V_DATE(pd));
376 case VT_R4: return VarDateFromR4(V_R4(ps), &V_DATE(pd));
377 case VT_R8: return VarDateFromR8(V_R8(ps), &V_DATE(pd));
378 case VT_BOOL: return VarDateFromBool(V_BOOL(ps), &V_DATE(pd));
379 case VT_CY: return VarDateFromCy(V_CY(ps), &V_DATE(pd));
380 case VT_DECIMAL: return VarDateFromDec(&V_DECIMAL(ps), &V_DATE(pd));
381 case VT_DISPATCH: return VarDateFromDisp(V_DISPATCH(ps), lcid, &V_DATE(pd));
382 case VT_BSTR: return VarDateFromStr(V_BSTR(ps), lcid, dwFlags, &V_DATE(pd));
383 }
384 break;
385
386 case VT_BOOL:
387 switch (vtFrom)
388 {
389 case VT_EMPTY: V_BOOL(pd) = 0; return S_OK;
390 case VT_I1: return VarBoolFromI1(V_I1(ps), &V_BOOL(pd));
391 case VT_I2: return VarBoolFromI2(V_I2(ps), &V_BOOL(pd));
392 case VT_I4: return VarBoolFromI4(V_I4(ps), &V_BOOL(pd));
393 case VT_UI1: return VarBoolFromUI1(V_UI1(ps), &V_BOOL(pd));
394 case VT_UI2: return VarBoolFromUI2(V_UI2(ps), &V_BOOL(pd));
395 case VT_UI4: return VarBoolFromUI4(V_UI4(ps), &V_BOOL(pd));
396 case VT_I8: return VarBoolFromI8(V_I8(ps), &V_BOOL(pd));
397 case VT_UI8: return VarBoolFromUI8(V_UI8(ps), &V_BOOL(pd));
398 case VT_R4: return VarBoolFromR4(V_R4(ps), &V_BOOL(pd));
399 case VT_R8: return VarBoolFromR8(V_R8(ps), &V_BOOL(pd));
400 case VT_DATE: return VarBoolFromDate(V_DATE(ps), &V_BOOL(pd));
401 case VT_CY: return VarBoolFromCy(V_CY(ps), &V_BOOL(pd));
402 case VT_DECIMAL: return VarBoolFromDec(&V_DECIMAL(ps), &V_BOOL(pd));
403 case VT_DISPATCH: return VarBoolFromDisp(V_DISPATCH(ps), lcid, &V_BOOL(pd));
404 case VT_BSTR: return VarBoolFromStr(V_BSTR(ps), lcid, dwFlags, &V_BOOL(pd));
405 }
406 break;
407
408 case VT_BSTR:
409 switch (vtFrom)
410 {
411 case VT_EMPTY:
412 V_BSTR(pd) = SysAllocStringLen(NULL, 0);
413 return V_BSTR(pd) ? S_OK : E_OUTOFMEMORY;
414 case VT_BOOL:
415 if (wFlags & (VARIANT_ALPHABOOL|VARIANT_LOCALBOOL))
416 return VarBstrFromBool(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
417 return VarBstrFromI2(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
418 case VT_I1: return VarBstrFromI1(V_I1(ps), lcid, dwFlags, &V_BSTR(pd));
419 case VT_I2: return VarBstrFromI2(V_I2(ps), lcid, dwFlags, &V_BSTR(pd));
420 case VT_I4: return VarBstrFromI4(V_I4(ps), lcid, dwFlags, &V_BSTR(pd));
421 case VT_UI1: return VarBstrFromUI1(V_UI1(ps), lcid, dwFlags, &V_BSTR(pd));
422 case VT_UI2: return VarBstrFromUI2(V_UI2(ps), lcid, dwFlags, &V_BSTR(pd));
423 case VT_UI4: return VarBstrFromUI4(V_UI4(ps), lcid, dwFlags, &V_BSTR(pd));
424 case VT_I8: return VarBstrFromI8(V_I8(ps), lcid, dwFlags, &V_BSTR(pd));
425 case VT_UI8: return VarBstrFromUI8(V_UI8(ps), lcid, dwFlags, &V_BSTR(pd));
426 case VT_R4: return VarBstrFromR4(V_R4(ps), lcid, dwFlags, &V_BSTR(pd));
427 case VT_R8: return VarBstrFromR8(V_R8(ps), lcid, dwFlags, &V_BSTR(pd));
428 case VT_DATE: return VarBstrFromDate(V_DATE(ps), lcid, dwFlags, &V_BSTR(pd));
429 case VT_CY: return VarBstrFromCy(V_CY(ps), lcid, dwFlags, &V_BSTR(pd));
430 case VT_DECIMAL: return VarBstrFromDec(&V_DECIMAL(ps), lcid, dwFlags, &V_BSTR(pd));
431 /* case VT_DISPATCH: return VarBstrFromDisp(V_DISPATCH(ps), lcid, dwFlags, &V_BSTR(pd)); */
432 }
433 break;
434
435 case VT_CY:
436 switch (vtFrom)
437 {
438 case VT_EMPTY: V_CY(pd).int64 = 0; return S_OK;
439 case VT_I1: return VarCyFromI1(V_I1(ps), &V_CY(pd));
440 case VT_I2: return VarCyFromI2(V_I2(ps), &V_CY(pd));
441 case VT_I4: return VarCyFromI4(V_I4(ps), &V_CY(pd));
442 case VT_UI1: return VarCyFromUI1(V_UI1(ps), &V_CY(pd));
443 case VT_UI2: return VarCyFromUI2(V_UI2(ps), &V_CY(pd));
444 case VT_UI4: return VarCyFromUI4(V_UI4(ps), &V_CY(pd));
445 case VT_I8: return VarCyFromI8(V_I8(ps), &V_CY(pd));
446 case VT_UI8: return VarCyFromUI8(V_UI8(ps), &V_CY(pd));
447 case VT_R4: return VarCyFromR4(V_R4(ps), &V_CY(pd));
448 case VT_R8: return VarCyFromR8(V_R8(ps), &V_CY(pd));
449 case VT_DATE: return VarCyFromDate(V_DATE(ps), &V_CY(pd));
450 case VT_BOOL: return VarCyFromBool(V_BOOL(ps), &V_CY(pd));
451 case VT_DECIMAL: return VarCyFromDec(&V_DECIMAL(ps), &V_CY(pd));
452 case VT_DISPATCH: return VarCyFromDisp(V_DISPATCH(ps), lcid, &V_CY(pd));
453 case VT_BSTR: return VarCyFromStr(V_BSTR(ps), lcid, dwFlags, &V_CY(pd));
454 }
455 break;
456
457 case VT_DECIMAL:
458 switch (vtFrom)
459 {
460 case VT_EMPTY:
461 case VT_BOOL:
462 DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0);
463 DEC_HI32(&V_DECIMAL(pd)) = 0;
464 DEC_MID32(&V_DECIMAL(pd)) = 0;
465 /* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0.
466 * VT_NULL and VT_EMPTY always give a 0 value.
467 */
468 DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
469 return S_OK;
470 case VT_I1: return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd));
471 case VT_I2: return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd));
472 case VT_I4: return VarDecFromI4(V_I4(ps), &V_DECIMAL(pd));
473 case VT_UI1: return VarDecFromUI1(V_UI1(ps), &V_DECIMAL(pd));
474 case VT_UI2: return VarDecFromUI2(V_UI2(ps), &V_DECIMAL(pd));
475 case VT_UI4: return VarDecFromUI4(V_UI4(ps), &V_DECIMAL(pd));
476 case VT_I8: return VarDecFromI8(V_I8(ps), &V_DECIMAL(pd));
477 case VT_UI8: return VarDecFromUI8(V_UI8(ps), &V_DECIMAL(pd));
478 case VT_R4: return VarDecFromR4(V_R4(ps), &V_DECIMAL(pd));
479 case VT_R8: return VarDecFromR8(V_R8(ps), &V_DECIMAL(pd));
480 case VT_DATE: return VarDecFromDate(V_DATE(ps), &V_DECIMAL(pd));
481 case VT_CY: return VarDecFromCy(V_CY(pd), &V_DECIMAL(ps));
482 case VT_DISPATCH: return VarDecFromDisp(V_DISPATCH(ps), lcid, &V_DECIMAL(ps));
483 case VT_BSTR: return VarDecFromStr(V_BSTR(ps), lcid, dwFlags, &V_DECIMAL(pd));
484 }
485 break;
486
487 case VT_UNKNOWN:
488 switch (vtFrom)
489 {
490 case VT_DISPATCH:
491 if (V_DISPATCH(ps) == NULL)
492 V_UNKNOWN(pd) = NULL;
493 else
494 res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
495 break;
496 }
497 break;
498
499 case VT_DISPATCH:
500 switch (vtFrom)
501 {
502 case VT_UNKNOWN:
503 if (V_UNKNOWN(ps) == NULL)
504 V_DISPATCH(pd) = NULL;
505 else
506 res = IUnknown_QueryInterface(V_UNKNOWN(ps), &IID_IDispatch, (LPVOID*)&V_DISPATCH(pd));
507 break;
508 }
509 break;
510
511 case VT_RECORD:
512 break;
513 }
514 return res;
515 }
516
517 /* Coerce to/from an array */
518 static inline HRESULT VARIANT_CoerceArray(VARIANTARG* pd, VARIANTARG* ps, VARTYPE vt)
519 {
520 if (vt == VT_BSTR && V_VT(ps) == (VT_ARRAY|VT_UI1))
521 return BstrFromVector(V_ARRAY(ps), &V_BSTR(pd));
522
523 if (V_VT(ps) == VT_BSTR && vt == (VT_ARRAY|VT_UI1))
524 return VectorFromBstr(V_BSTR(ps), &V_ARRAY(ps));
525
526 if (V_VT(ps) == vt)
527 return SafeArrayCopy(V_ARRAY(ps), &V_ARRAY(pd));
528
529 return DISP_E_TYPEMISMATCH;
530 }
531
532 /******************************************************************************
533 * Check if a variants type is valid.
534 */
535 static inline HRESULT VARIANT_ValidateType(VARTYPE vt)
536 {
537 VARTYPE vtExtra = vt & VT_EXTRA_TYPE;
538
539 vt &= VT_TYPEMASK;
540
541 if (!(vtExtra & (VT_VECTOR|VT_RESERVED)))
542 {
543 if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID)
544 {
545 if ((vtExtra & (VT_BYREF|VT_ARRAY)) && vt <= VT_NULL)
546 return DISP_E_BADVARTYPE;
547 if (vt != (VARTYPE)15)
548 return S_OK;
549 }
550 }
551 return DISP_E_BADVARTYPE;
552 }
553
554 /******************************************************************************
555 * VariantInit [OLEAUT32.8]
556 *
557 * Initialise a variant.
558 *
559 * PARAMS
560 * pVarg [O] Variant to initialise
561 *
562 * RETURNS
563 * Nothing.
564 *
565 * NOTES
566 * This function simply sets the type of the variant to VT_EMPTY. It does not
567 * free any existing value, use VariantClear() for that.
568 */
569 void WINAPI VariantInit(VARIANTARG* pVarg)
570 {
571 TRACE("(%p)\n", pVarg);
572
573 V_VT(pVarg) = VT_EMPTY; /* Native doesn't set any other fields */
574 }
575
576 /******************************************************************************
577 * VariantClear [OLEAUT32.9]
578 *
579 * Clear a variant.
580 *
581 * PARAMS
582 * pVarg [I/O] Variant to clear
583 *
584 * RETURNS
585 * Success: S_OK. Any previous value in pVarg is freed and its type is set to VT_EMPTY.
586 * Failure: DISP_E_BADVARTYPE, if the variant is a not a valid variant type.
587 */
588 HRESULT WINAPI VariantClear(VARIANTARG* pVarg)
589 {
590 HRESULT hres = S_OK;
591
592 TRACE("(%p->(%s%s))\n", pVarg, debugstr_VT(pVarg), debugstr_VF(pVarg));
593
594 hres = VARIANT_ValidateType(V_VT(pVarg));
595
596 if (SUCCEEDED(hres))
597 {
598 if (!V_ISBYREF(pVarg))
599 {
600 if (V_ISARRAY(pVarg) || V_VT(pVarg) == VT_SAFEARRAY)
601 {
602 if (V_ARRAY(pVarg))
603 hres = SafeArrayDestroy(V_ARRAY(pVarg));
604 }
605 else if (V_VT(pVarg) == VT_BSTR)
606 {
607 if (V_BSTR(pVarg))
608 SysFreeString(V_BSTR(pVarg));
609 }
610 else if (V_VT(pVarg) == VT_RECORD)
611 {
612 struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
613 if (pBr->pRecInfo)
614 {
615 IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
616 IRecordInfo_Release(pBr->pRecInfo);
617 }
618 }
619 else if (V_VT(pVarg) == VT_DISPATCH ||
620 V_VT(pVarg) == VT_UNKNOWN)
621 {
622 if (V_UNKNOWN(pVarg))
623 IUnknown_Release(V_UNKNOWN(pVarg));
624 }
625 else if (V_VT(pVarg) == VT_VARIANT)
626 {
627 if (V_VARIANTREF(pVarg))
628 VariantClear(V_VARIANTREF(pVarg));
629 }
630 }
631 V_VT(pVarg) = VT_EMPTY;
632 }
633 return hres;
634 }
635
636 /******************************************************************************
637 * Copy an IRecordInfo object contained in a variant.
638 */
639 static HRESULT VARIANT_CopyIRecordInfo(struct __tagBRECORD* pBr)
640 {
641 HRESULT hres = S_OK;
642
643 if (pBr->pRecInfo)
644 {
645 ULONG ulSize;
646
647 hres = IRecordInfo_GetSize(pBr->pRecInfo, &ulSize);
648 if (SUCCEEDED(hres))
649 {
650 PVOID pvRecord = HeapAlloc(GetProcessHeap(), 0, ulSize);
651 if (!pvRecord)
652 hres = E_OUTOFMEMORY;
653 else
654 {
655 memcpy(pvRecord, pBr->pvRecord, ulSize);
656 pBr->pvRecord = pvRecord;
657
658 hres = IRecordInfo_RecordCopy(pBr->pRecInfo, pvRecord, pvRecord);
659 if (SUCCEEDED(hres))
660 IRecordInfo_AddRef(pBr->pRecInfo);
661 }
662 }
663 }
664 else if (pBr->pvRecord)
665 hres = E_INVALIDARG;
666 return hres;
667 }
668
669 /******************************************************************************
670 * VariantCopy [OLEAUT32.10]
671 *
672 * Copy a variant.
673 *
674 * PARAMS
675 * pvargDest [O] Destination for copy
676 * pvargSrc [I] Source variant to copy
677 *
678 * RETURNS
679 * Success: S_OK. pvargDest contains a copy of pvargSrc.
680 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid type.
681 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an
682 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(),
683 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc.
684 *
685 * NOTES
686 * - If pvargSrc == pvargDest, this function does nothing, and succeeds if
687 * pvargSrc is valid. Otherwise, pvargDest is always cleared using
688 * VariantClear() before pvargSrc is copied to it. If clearing pvargDest
689 * fails, so does this function.
690 * - VT_CLSID is a valid type type for pvargSrc, but not for pvargDest.
691 * - For by-value non-intrinsic types, a deep copy is made, i.e. The whole value
692 * is copied rather than just any pointers to it.
693 * - For by-value object types the object pointer is copied and the objects
694 * reference count increased using IUnknown_AddRef().
695 * - For all by-reference types, only the referencing pointer is copied.
696 */
697 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc)
698 {
699 HRESULT hres = S_OK;
700
701 TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest),
702 debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc),
703 debugstr_VF(pvargSrc));
704
705 if (V_TYPE(pvargSrc) == VT_CLSID || /* VT_CLSID is a special case */
706 FAILED(VARIANT_ValidateType(V_VT(pvargSrc))))
707 return DISP_E_BADVARTYPE;
708
709 if (pvargSrc != pvargDest &&
710 SUCCEEDED(hres = VariantClear(pvargDest)))
711 {
712 *pvargDest = *pvargSrc; /* Shallow copy the value */
713
714 if (!V_ISBYREF(pvargSrc))
715 {
716 if (V_ISARRAY(pvargSrc))
717 {
718 if (V_ARRAY(pvargSrc))
719 hres = SafeArrayCopy(V_ARRAY(pvargSrc), &V_ARRAY(pvargDest));
720 }
721 else if (V_VT(pvargSrc) == VT_BSTR)
722 {
723 if (V_BSTR(pvargSrc))
724 {
725 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)V_BSTR(pvargSrc), SysStringByteLen(V_BSTR(pvargSrc)));
726 if (!V_BSTR(pvargDest))
727 {
728 TRACE("!V_BSTR(pvargDest), SysAllocStringByteLen() failed to allocate %d bytes\n", SysStringByteLen(V_BSTR(pvargSrc)));
729 hres = E_OUTOFMEMORY;
730 }
731 }
732 }
733 else if (V_VT(pvargSrc) == VT_RECORD)
734 {
735 hres = VARIANT_CopyIRecordInfo(&V_UNION(pvargDest,brecVal));
736 }
737 else if (V_VT(pvargSrc) == VT_DISPATCH ||
738 V_VT(pvargSrc) == VT_UNKNOWN)
739 {
740 if (V_UNKNOWN(pvargSrc))
741 IUnknown_AddRef(V_UNKNOWN(pvargSrc));
742 }
743 }
744 }
745 return hres;
746 }
747
748 /* Return the byte size of a variants data */
749 static inline size_t VARIANT_DataSize(const VARIANT* pv)
750 {
751 switch (V_TYPE(pv))
752 {
753 case VT_I1:
754 case VT_UI1: return sizeof(BYTE); break;
755 case VT_I2:
756 case VT_UI2: return sizeof(SHORT); break;
757 case VT_INT:
758 case VT_UINT:
759 case VT_I4:
760 case VT_UI4: return sizeof(LONG); break;
761 case VT_I8:
762 case VT_UI8: return sizeof(LONGLONG); break;
763 case VT_R4: return sizeof(float); break;
764 case VT_R8: return sizeof(double); break;
765 case VT_DATE: return sizeof(DATE); break;
766 case VT_BOOL: return sizeof(VARIANT_BOOL); break;
767 case VT_DISPATCH:
768 case VT_UNKNOWN:
769 case VT_BSTR: return sizeof(void*); break;
770 case VT_CY: return sizeof(CY); break;
771 case VT_ERROR: return sizeof(SCODE); break;
772 }
773 TRACE("Shouldn't be called for vt %s%s!\n", debugstr_VT(pv), debugstr_VF(pv));
774 return 0;
775 }
776
777 /******************************************************************************
778 * VariantCopyInd [OLEAUT32.11]
779 *
780 * Copy a variant, dereferencing it it is by-reference.
781 *
782 * PARAMS
783 * pvargDest [O] Destination for copy
784 * pvargSrc [I] Source variant to copy
785 *
786 * RETURNS
787 * Success: S_OK. pvargDest contains a copy of pvargSrc.
788 * Failure: An HRESULT error code indicating the error.
789 *
790 * NOTES
791 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid by-value type.
792 * E_INVALIDARG, if pvargSrc is an invalid by-reference type.
793 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an
794 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(),
795 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc.
796 *
797 * NOTES
798 * - If pvargSrc is by-value, this function behaves exactly as VariantCopy().
799 * - If pvargSrc is by-reference, the value copied to pvargDest is the pointed-to
800 * value.
801 * - if pvargSrc == pvargDest, this function dereferences in place. Otherwise,
802 * pvargDest is always cleared using VariantClear() before pvargSrc is copied
803 * to it. If clearing pvargDest fails, so does this function.
804 */
805 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc)
806 {
807 VARIANTARG vTmp, *pSrc = pvargSrc;
808 VARTYPE vt;
809 HRESULT hres = S_OK;
810
811 TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest),
812 debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc),
813 debugstr_VF(pvargSrc));
814
815 if (!V_ISBYREF(pvargSrc))
816 return VariantCopy(pvargDest, pvargSrc);
817
818 /* Argument checking is more lax than VariantCopy()... */
819 vt = V_TYPE(pvargSrc);
820 if (V_ISARRAY(pvargSrc) ||
821 (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
822 !(V_VT(pvargSrc) & (VT_VECTOR|VT_RESERVED))))
823 {
824 /* OK */
825 }
826 else
827 return E_INVALIDARG; /* ...And the return value for invalid types differs too */
828
829 if (pvargSrc == pvargDest)
830 {
831 /* In place copy. Use a shallow copy of pvargSrc & init pvargDest.
832 * This avoids an expensive VariantCopy() call - e.g. SafeArrayCopy().
833 */
834 vTmp = *pvargSrc;
835 pSrc = &vTmp;
836 V_VT(pvargDest) = VT_EMPTY;
837 }
838 else
839 {
840 /* Copy into another variant. Free the variant in pvargDest */
841 if (FAILED(hres = VariantClear(pvargDest)))
842 {
843 TRACE("VariantClear() of destination failed\n");
844 return hres;
845 }
846 }
847
848 if (V_ISARRAY(pSrc))
849 {
850 /* Native doesn't check that *V_ARRAYREF(pSrc) is valid */
851 hres = SafeArrayCopy(*V_ARRAYREF(pSrc), &V_ARRAY(pvargDest));
852 }
853 else if (V_VT(pSrc) == (VT_BSTR|VT_BYREF))
854 {
855 /* Native doesn't check that *V_BSTRREF(pSrc) is valid */
856 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)*V_BSTRREF(pSrc), SysStringByteLen(*V_BSTRREF(pSrc)));
857 }
858 else if (V_VT(pSrc) == (VT_RECORD|VT_BYREF))
859 {
860 V_UNION(pvargDest,brecVal) = V_UNION(pvargSrc,brecVal);
861 hres = VARIANT_CopyIRecordInfo(&V_UNION(pvargDest,brecVal));
862 }
863 else if (V_VT(pSrc) == (VT_DISPATCH|VT_BYREF) ||
864 V_VT(pSrc) == (VT_UNKNOWN|VT_BYREF))
865 {
866 /* Native doesn't check that *V_UNKNOWNREF(pSrc) is valid */
867 V_UNKNOWN(pvargDest) = *V_UNKNOWNREF(pSrc);
868 if (*V_UNKNOWNREF(pSrc))
869 IUnknown_AddRef(*V_UNKNOWNREF(pSrc));
870 }
871 else if (V_VT(pSrc) == (VT_VARIANT|VT_BYREF))
872 {
873 /* Native doesn't check that *V_VARIANTREF(pSrc) is valid */
874 if (V_VT(V_VARIANTREF(pSrc)) == (VT_VARIANT|VT_BYREF))
875 hres = E_INVALIDARG; /* Don't dereference more than one level */
876 else
877 hres = VariantCopyInd(pvargDest, V_VARIANTREF(pSrc));
878
879 /* Use the dereferenced variants type value, not VT_VARIANT */
880 goto VariantCopyInd_Return;
881 }
882 else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF))
883 {
884 memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)),
885 sizeof(DECIMAL) - sizeof(USHORT));
886 }
887 else
888 {
889 /* Copy the pointed to data into this variant */
890 memcpy(&V_BYREF(pvargDest), V_BYREF(pSrc), VARIANT_DataSize(pSrc));
891 }
892
893 V_VT(pvargDest) = V_VT(pSrc) & ~VT_BYREF;
894
895 VariantCopyInd_Return:
896
897 if (pSrc != pvargSrc)
898 VariantClear(pSrc);
899
900 TRACE("returning 0x%08lx, %p->(%s%s)\n", hres, pvargDest,
901 debugstr_VT(pvargDest), debugstr_VF(pvargDest));
902 return hres;
903 }
904
905 /******************************************************************************
906 * VariantChangeType [OLEAUT32.12]
907 *
908 * Change the type of a variant.
909 *
910 * PARAMS
911 * pvargDest [O] Destination for the converted variant
912 * pvargSrc [O] Source variant to change the type of
913 * wFlags [I] VARIANT_ flags from "oleauto.h"
914 * vt [I] Variant type to change pvargSrc into
915 *
916 * RETURNS
917 * Success: S_OK. pvargDest contains the converted value.
918 * Failure: An HRESULT error code describing the failure.
919 *
920 * NOTES
921 * The LCID used for the conversion is LOCALE_USER_DEFAULT.
922 * See VariantChangeTypeEx.
923 */
924 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
925 USHORT wFlags, VARTYPE vt)
926 {
927 return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt );
928 }
929
930 /******************************************************************************
931 * VariantChangeTypeEx [OLEAUT32.147]
932 *
933 * Change the type of a variant.
934 *
935 * PARAMS
936 * pvargDest [O] Destination for the converted variant
937 * pvargSrc [O] Source variant to change the type of
938 * lcid [I] LCID for the conversion
939 * wFlags [I] VARIANT_ flags from "oleauto.h"
940 * vt [I] Variant type to change pvargSrc into
941 *
942 * RETURNS
943 * Success: S_OK. pvargDest contains the converted value.
944 * Failure: An HRESULT error code describing the failure.
945 *
946 * NOTES
947 * pvargDest and pvargSrc can point to the same variant to perform an in-place
948 * conversion. If the conversion is successful, pvargSrc will be freed.
949 */
950 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc,
951 LCID lcid, USHORT wFlags, VARTYPE vt)
952 {
953 HRESULT res = S_OK;
954
955 TRACE("(%p->(%s%s),%p->(%s%s),0x%08lx,0x%04x,%s%s)\n", pvargDest,
956 debugstr_VT(pvargDest), debugstr_VF(pvargDest), pvargSrc,
957 debugstr_VT(pvargSrc), debugstr_VF(pvargSrc), lcid, wFlags,
958 debugstr_vt(vt), debugstr_vf(vt));
959
960 if (vt == VT_CLSID)
961 res = DISP_E_BADVARTYPE;
962 else
963 {
964 res = VARIANT_ValidateType(V_VT(pvargSrc));
965
966 if (SUCCEEDED(res))
967 {
968 res = VARIANT_ValidateType(vt);
969
970 if (SUCCEEDED(res))
971 {
972 VARIANTARG vTmp;
973
974 V_VT(&vTmp) = VT_EMPTY;
975 res = VariantCopyInd(&vTmp, pvargSrc);
976
977 if (SUCCEEDED(res))
978 {
979 res = VariantClear(pvargDest);
980
981 if (SUCCEEDED(res))
982 {
983 if (V_ISARRAY(&vTmp) || (vt & VT_ARRAY))
984 res = VARIANT_CoerceArray(pvargDest, &vTmp, vt);
985 else
986 res = VARIANT_Coerce(pvargDest, lcid, wFlags, &vTmp, vt);
987
988 if (SUCCEEDED(res))
989 V_VT(pvargDest) = vt;
990 }
991 VariantClear(&vTmp);
992 }
993 }
994 }
995 }
996
997 TRACE("returning 0x%08lx, %p->(%s%s)\n", res, pvargDest,
998 debugstr_VT(pvargDest), debugstr_VF(pvargDest));
999 return res;
1000 }
1001
1002 /* Date Conversions */
1003
1004 #define IsLeapYear(y) (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
1005
1006 /* Convert a VT_DATE value to a Julian Date */
1007 static inline int VARIANT_JulianFromDate(int dateIn)
1008 {
1009 int julianDays = dateIn;
1010
1011 julianDays -= DATE_MIN; /* Convert to + days from 1 Jan 100 AD */
1012 julianDays += 1757585; /* Convert to + days from 23 Nov 4713 BC (Julian) */
1013 return julianDays;
1014 }
1015
1016 /* Convert a Julian Date to a VT_DATE value */
1017 static inline int VARIANT_DateFromJulian(int dateIn)
1018 {
1019 int julianDays = dateIn;
1020
1021 julianDays -= 1757585; /* Convert to + days from 1 Jan 100 AD */
1022 julianDays += DATE_MIN; /* Convert to +/- days from 1 Jan 1899 AD */
1023 return julianDays;
1024 }
1025
1026 /* Convert a Julian date to Day/Month/Year - from PostgreSQL */
1027 static inline void VARIANT_DMYFromJulian(int jd, USHORT *year, USHORT *month, USHORT *day)
1028 {
1029 int j, i, l, n;
1030
1031 l = jd + 68569;
1032 n = l * 4 / 146097;
1033 l -= (n * 146097 + 3) / 4;
1034 i = (4000 * (l + 1)) / 1461001;
1035 l += 31 - (i * 1461) / 4;
1036 j = (l * 80) / 2447;
1037 *day = l - (j * 2447) / 80;
1038 l = j / 11;
1039 *month = (j + 2) - (12 * l);
1040 *year = 100 * (n - 49) + i + l;
1041 }
1042
1043 /* Convert Day/Month/Year to a Julian date - from PostgreSQL */
1044 static inline double VARIANT_JulianFromDMY(USHORT year, USHORT month, USHORT day)
1045 {
1046 int m12 = (month - 14) / 12;
1047
1048 return ((1461 * (year + 4800 + m12)) / 4 + (367 * (month - 2 - 12 * m12)) / 12 -
1049 (3 * ((year + 4900 + m12) / 100)) / 4 + day - 32075);
1050 }
1051
1052 /* Macros for accessing DOS format date/time fields */
1053 #define DOS_YEAR(x) (1980 + (x >> 9))
1054 #define DOS_MONTH(x) ((x >> 5) & 0xf)
1055 #define DOS_DAY(x) (x & 0x1f)
1056 #define DOS_HOUR(x) (x >> 11)
1057 #define DOS_MINUTE(x) ((x >> 5) & 0x3f)
1058 #define DOS_SECOND(x) ((x & 0x1f) << 1)
1059 /* Create a DOS format date/time */
1060 #define DOS_DATE(d,m,y) (d | (m << 5) | ((y-1980) << 9))
1061 #define DOS_TIME(h,m,s) ((s >> 1) | (m << 5) | (h << 11))
1062
1063 /* Roll a date forwards or backwards to correct it */
1064 static HRESULT VARIANT_RollUdate(UDATE *lpUd)
1065 {
1066 static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
1067
1068 TRACE("Raw date: %d/%d/%d %d:%d:%d\n", lpUd->st.wDay, lpUd->st.wMonth,
1069 lpUd->st.wYear, lpUd->st.wHour, lpUd->st.wMinute, lpUd->st.wSecond);
1070
1071 /* Years < 100 are treated as 1900 + year */
1072 if (lpUd->st.wYear < 100)
1073 lpUd->st.wYear += 1900;
1074
1075 if (!lpUd->st.wMonth)
1076 {
1077 /* Roll back to December of the previous year */
1078 lpUd->st.wMonth = 12;
1079 lpUd->st.wYear--;
1080 }
1081 else while (lpUd->st.wMonth > 12)
1082 {
1083 /* Roll forward the correct number of months */
1084 lpUd->st.wYear++;
1085 lpUd->st.wMonth -= 12;
1086 }
1087
1088 if (lpUd->st.wYear > 9999 || lpUd->st.wHour > 23 ||
1089 lpUd->st.wMinute > 59 || lpUd->st.wSecond > 59)
1090 return E_INVALIDARG; /* Invalid values */
1091
1092 if (!lpUd->st.wDay)
1093 {
1094 /* Roll back the date one day */
1095 if (lpUd->st.wMonth == 1)
1096 {
1097 /* Roll back to December 31 of the previous year */
1098 lpUd->st.wDay = 31;
1099 lpUd->st.wMonth = 12;
1100 lpUd->st.wYear--;
1101 }
1102 else
1103 {
1104 lpUd->st.wMonth--; /* Previous month */
1105 if (lpUd->st.wMonth == 2 && IsLeapYear(lpUd->st.wYear))
1106 lpUd->st.wDay = 29; /* Februaury has 29 days on leap years */
1107 else
1108 lpUd->st.wDay = days[lpUd->st.wMonth]; /* Last day of the month */
1109 }
1110 }
1111 else if (lpUd->st.wDay > 28)
1112 {
1113 int rollForward = 0;
1114
1115 /* Possibly need to roll the date forward */
1116 if (lpUd->st.wMonth == 2 && IsLeapYear(lpUd->st.wYear))
1117 rollForward = lpUd->st.wDay - 29; /* Februaury has 29 days on leap years */
1118 else
1119 rollForward = lpUd->st.wDay - days[lpUd->st.wMonth];
1120
1121 if (rollForward > 0)
1122 {
1123 lpUd->st.wDay = rollForward;
1124 lpUd->st.wMonth++;
1125 if (lpUd->st.wMonth > 12)
1126 {
1127 lpUd->st.wMonth = 1; /* Roll forward into January of the next year */
1128 lpUd->st.wYear++;
1129 }
1130 }
1131 }
1132 TRACE("Rolled date: %d/%d/%d %d:%d:%d\n", lpUd->st.wDay, lpUd->st.wMonth,
1133 lpUd->st.wYear, lpUd->st.wHour, lpUd->st.wMinute, lpUd->st.wSecond);
1134 return S_OK;
1135 }
1136
1137 /**********************************************************************
1138 * DosDateTimeToVariantTime [OLEAUT32.14]
1139 *
1140 * Convert a Dos format date and time into variant VT_DATE format.
1141 *
1142 * PARAMS
1143 * wDosDate [I] Dos format date
1144 * wDosTime [I] Dos format time
1145 * pDateOut [O] Destination for VT_DATE format
1146 *
1147 * RETURNS
1148 * Success: TRUE. pDateOut contains the converted time.
1149 * Failure: FALSE, if wDosDate or wDosTime are invalid (see notes).
1150 *
1151 * NOTES
1152 * - Dos format dates can only hold dates from 1-Jan-1980 to 31-Dec-2099.
1153 * - Dos format times are accurate to only 2 second precision.
1154 * - The format of a Dos Date is:
1155 *| Bits Values Meaning
1156 *| ---- ------ -------
1157 *| 0-4 1-31 Day of the week. 0 rolls back one day. A value greater than
1158 *| the days in the month rolls forward the extra days.
1159 *| 5-8 1-12 Month of the year. 0 rolls back to December of the previous
1160 *| year. 13-15 are invalid.
1161 *| 9-15 0-119 Year based from 1980 (Max 2099). 120-127 are invalid.
1162 * - The format of a Dos Time is:
1163 *| Bits Values Meaning
1164 *| ---- ------ -------
1165 *| 0-4 0-29 Seconds/2. 30 and 31 are invalid.
1166 *| 5-10 0-59 Minutes. 60-63 are invalid.
1167 *| 11-15 0-23 Hours (24 hour clock). 24-32 are invalid.
1168 */
1169 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
1170 double *pDateOut)
1171 {
1172 UDATE ud;
1173
1174 TRACE("(0x%x(%d/%d/%d),0x%x(%d:%d:%d),%p)\n",
1175 wDosDate, DOS_YEAR(wDosDate), DOS_MONTH(wDosDate), DOS_DAY(wDosDate),
1176 wDosTime, DOS_HOUR(wDosTime), DOS_MINUTE(wDosTime), DOS_SECOND(wDosTime),
1177 pDateOut);
1178
1179 ud.st.wYear = DOS_YEAR(wDosDate);
1180 ud.st.wMonth = DOS_MONTH(wDosDate);
1181 if (ud.st.wYear > 2099 || ud.st.wMonth > 12)
1182 return FALSE;
1183 ud.st.wDay = DOS_DAY(wDosDate);
1184 ud.st.wHour = DOS_HOUR(wDosTime);
1185 ud.st.wMinute = DOS_MINUTE(wDosTime);
1186 ud.st.wSecond = DOS_SECOND(wDosTime);
1187 ud.st.wDayOfWeek = ud.st.wMilliseconds = 0;
1188
1189 return !VarDateFromUdate(&ud, 0, pDateOut);
1190 }
1191
1192 /**********************************************************************
1193 * VariantTimeToDosDateTime [OLEAUT32.13]
1194 *
1195 * Convert a variant format date into a Dos format date and time.
1196 *
1197 * dateIn [I] VT_DATE time format
1198 * pwDosDate [O] Destination for Dos format date
1199 * pwDosTime [O] Destination for Dos format time
1200 *
1201 * RETURNS
1202 * Success: TRUE. pwDosDate and pwDosTime contains the converted values.
1203 * Failure: FALSE, if dateIn cannot be represented in Dos format.
1204 *
1205 * NOTES
1206 * See DosDateTimeToVariantTime() for Dos format details and bugs.
1207 */
1208 INT WINAPI VariantTimeToDosDateTime(double dateIn, USHORT *pwDosDate, USHORT *pwDosTime)
1209 {
1210 UDATE ud;
1211
1212 TRACE("(%g,%p,%p)\n", dateIn, pwDosDate, pwDosTime);
1213
1214 if (FAILED(VarUdateFromDate(dateIn, 0, &ud)))
1215 return FALSE;
1216
1217 if (ud.st.wYear < 1980 || ud.st.wYear > 2099)
1218 return FALSE;
1219
1220 *pwDosDate = DOS_DATE(ud.st.wDay, ud.st.wMonth, ud.st.wYear);
1221 *pwDosTime = DOS_TIME(ud.st.wHour, ud.st.wMinute, ud.st.wSecond);
1222
1223 TRACE("Returning 0x%x(%d/%d/%d), 0x%x(%d:%d:%d)\n",
1224 *pwDosDate, DOS_YEAR(*pwDosDate), DOS_MONTH(*pwDosDate), DOS_DAY(*pwDosDate),
1225 *pwDosTime, DOS_HOUR(*pwDosTime), DOS_MINUTE(*pwDosTime), DOS_SECOND(*pwDosTime));
1226 return TRUE;
1227 }
1228
1229 /***********************************************************************
1230 * SystemTimeToVariantTime [OLEAUT32.184]
1231 *
1232 * Convert a System format date and time into variant VT_DATE format.
1233 *
1234 * PARAMS
1235 * lpSt [I] System format date and time
1236 * pDateOut [O] Destination for VT_DATE format date
1237 *
1238 * RETURNS
1239 * Success: TRUE. *pDateOut contains the converted value.
1240 * Failure: FALSE, if lpSt cannot be represented in VT_DATE format.
1241 */
1242 INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut)
1243 {
1244 UDATE ud;
1245
1246 TRACE("(%p->%d/%d/%d %d:%d:%d,%p)\n", lpSt, lpSt->wDay, lpSt->wMonth,
1247 lpSt->wYear, lpSt->wHour, lpSt->wMinute, lpSt->wSecond, pDateOut);
1248
1249 if (lpSt->wMonth > 12)
1250 return FALSE;
1251
1252 memcpy(&ud.st, lpSt, sizeof(ud.st));
1253 return !VarDateFromUdate(&ud, 0, pDateOut);
1254 }
1255
1256 /***********************************************************************
1257 * VariantTimeToSystemTime [OLEAUT32.185]
1258 *
1259 * Convert a variant VT_DATE into a System format date and time.
1260 *
1261 * PARAMS
1262 * datein [I] Variant VT_DATE format date
1263 * lpSt [O] Destination for System format date and time
1264 *
1265 * RETURNS
1266 * Success: TRUE. *lpSt contains the converted value.
1267 * Failure: FALSE, if dateIn is too large or small.
1268 */
1269 INT WINAPI VariantTimeToSystemTime(double dateIn, LPSYSTEMTIME lpSt)
1270 {
1271 UDATE ud;
1272
1273 TRACE("(%g,%p)\n", dateIn, lpSt);
1274
1275 if (FAILED(VarUdateFromDate(dateIn, 0, &ud)))
1276 return FALSE;
1277
1278 memcpy(lpSt, &ud.st, sizeof(ud.st));
1279 return TRUE;
1280 }
1281
1282 /***********************************************************************
1283 * VarDateFromUdate [OLEAUT32.330]
1284 *
1285 * Convert an unpacked format date and time to a variant VT_DATE.
1286 *
1287 * PARAMS
1288 * pUdateIn [I] Unpacked format date and time to convert
1289 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1290 * pDateOut [O] Destination for variant VT_DATE.
1291 *
1292 * RETURNS
1293 * Success: S_OK. *pDateOut contains the converted value.
1294 * Failure: E_INVALIDARG, if pUdateIn cannot be represented in VT_DATE format.
1295 */
1296 HRESULT WINAPI VarDateFromUdate(UDATE *pUdateIn, ULONG dwFlags, DATE *pDateOut)
1297 {
1298 UDATE ud;
1299 double dateVal;
1300
1301 TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08lx,%p)\n", pUdateIn,
1302 pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
1303 pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond,
1304 pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek,
1305 pUdateIn->wDayOfYear, dwFlags, pDateOut);
1306
1307 memcpy(&ud, pUdateIn, sizeof(ud));
1308
1309 if (dwFlags & VAR_VALIDDATE)
1310 WARN("Ignoring VAR_VALIDDATE\n");
1311
1312 if (FAILED(VARIANT_RollUdate(&ud)))
1313 return E_INVALIDARG;
1314
1315 /* Date */
1316 dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay));
1317
1318 /* Time */
1319 dateVal += ud.st.wHour / 24.0;
1320 dateVal += ud.st.wMinute / 1440.0;
1321 dateVal += ud.st.wSecond / 86400.0;
1322 dateVal += ud.st.wMilliseconds / 86400000.0;
1323
1324 TRACE("Returning %g\n", dateVal);
1325 *pDateOut = dateVal;
1326 return S_OK;
1327 }
1328
1329 /***********************************************************************
1330 * VarUdateFromDate [OLEAUT32.331]
1331 *
1332 * Convert a variant VT_DATE into an unpacked format date and time.
1333 *
1334 * PARAMS
1335 * datein [I] Variant VT_DATE format date
1336 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1337 * lpUdate [O] Destination for unpacked format date and time
1338 *
1339 * RETURNS
1340 * Success: S_OK. *lpUdate contains the converted value.
1341 * Failure: E_INVALIDARG, if dateIn is too large or small.
1342 */
1343 HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
1344 {
1345 /* Cumulative totals of days per month */
1346 static const USHORT cumulativeDays[] =
1347 {
1348 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
1349 };
1350 double datePart, timePart;
1351 int julianDays;
1352
1353 TRACE("(%g,0x%08lx,%p)\n", dateIn, dwFlags, lpUdate);
1354
1355 if (dateIn <= (DATE_MIN - 1.0) || dateIn >= (DATE_MAX + 1.0))
1356 return E_INVALIDARG;
1357
1358 datePart = dateIn < 0.0 ? ceil(dateIn) : floor(dateIn);
1359 /* Compensate for int truncation (always downwards) */
1360 timePart = dateIn - datePart + 0.00000000001;
1361 if (timePart >= 1.0)
1362 timePart -= 0.00000000001;
1363
1364 /* Date */
1365 julianDays = VARIANT_JulianFromDate(dateIn);
1366 VARIANT_DMYFromJulian(julianDays, &lpUdate->st.wYear, &lpUdate->st.wMonth,
1367 &lpUdate->st.wDay);
1368
1369 datePart = (datePart + 1.5) / 7.0;
1370 lpUdate->st.wDayOfWeek = (datePart - floor(datePart)) * 7;
1371 if (lpUdate->st.wDayOfWeek == 0)
1372 lpUdate->st.wDayOfWeek = 5;
1373 else if (lpUdate->st.wDayOfWeek == 1)
1374 lpUdate->st.wDayOfWeek = 6;
1375 else
1376 lpUdate->st.wDayOfWeek -= 2;
1377
1378 if (lpUdate->st.wMonth > 2 && IsLeapYear(lpUdate->st.wYear))
1379 lpUdate->wDayOfYear = 1; /* After February, in a leap year */
1380 else
1381 lpUdate->wDayOfYear = 0;
1382
1383 lpUdate->wDayOfYear += cumulativeDays[lpUdate->st.wMonth];
1384 lpUdate->wDayOfYear += lpUdate->st.wDay;
1385
1386 /* Time */
1387 timePart *= 24.0;
1388 lpUdate->st.wHour = timePart;
1389 timePart -= lpUdate->st.wHour;
1390 timePart *= 60.0;
1391 lpUdate->st.wMinute = timePart;
1392 timePart -= lpUdate->st.wMinute;
1393 timePart *= 60.0;
1394 lpUdate->st.wSecond = timePart;
1395 timePart -= lpUdate->st.wSecond;
1396 lpUdate->st.wMilliseconds = 0;
1397 if (timePart > 0.5)
1398 {
1399 /* Round the milliseconds, adjusting the time/date forward if needed */
1400 if (lpUdate->st.wSecond < 59)
1401 lpUdate->st.wSecond++;
1402 else
1403 {
1404 lpUdate->st.wSecond = 0;
1405 if (lpUdate->st.wMinute < 59)
1406 lpUdate->st.wMinute++;
1407 else
1408 {
1409 lpUdate->st.wMinute = 0;
1410 if (lpUdate->st.wHour < 23)
1411 lpUdate->st.wHour++;
1412 else
1413 {
1414 lpUdate->st.wHour = 0;
1415 /* Roll over a whole day */
1416 if (++lpUdate->st.wDay > 28)
1417 VARIANT_RollUdate(lpUdate);
1418 }
1419 }
1420 }
1421 }
1422 return S_OK;
1423 }
1424
1425 #define GET_NUMBER_TEXT(fld,name) \
1426 buff[0] = 0; \
1427 if (!GetLocaleInfoW(lcid, lctype|fld, buff, 2)) \
1428 WARN("buffer too small for " #fld "\n"); \
1429 else \
1430 if (buff[0]) lpChars->name = buff[0]; \
1431 TRACE("lcid 0x%lx, " #name "=%d '%c'\n", lcid, lpChars->name, lpChars->name)
1432
1433 /* Get the valid number characters for an lcid */
1434 void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags)
1435 {
1436 static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',',','$',0,'.',',' };
1437 LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE;
1438 WCHAR buff[4];
1439
1440 memcpy(lpChars, &defaultChars, sizeof(defaultChars));
1441 GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol);
1442 GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol);
1443 GET_NUMBER_TEXT(LOCALE_SDECIMAL, cDecimalPoint);
1444 GET_NUMBER_TEXT(LOCALE_STHOUSAND, cDigitSeperator);
1445 GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint);
1446 GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeperator);
1447
1448 /* Local currency symbols are often 2 characters */
1449 lpChars->cCurrencyLocal2 = '\0';
1450 switch(GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, buff, sizeof(buff)/sizeof(WCHAR)))
1451 {
1452 case 3: lpChars->cCurrencyLocal2 = buff[1]; /* Fall through */
1453 case 2: lpChars->cCurrencyLocal = buff[0];
1454 break;
1455 default: WARN("buffer too small for LOCALE_SCURRENCY\n");
1456 }
1457 TRACE("lcid 0x%lx, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal,
1458 lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2);
1459 }
1460
1461 /* Number Parsing States */
1462 #define B_PROCESSING_EXPONENT 0x1
1463 #define B_NEGATIVE_EXPONENT 0x2
1464 #define B_EXPONENT_START 0x4
1465 #define B_INEXACT_ZEROS 0x8
1466 #define B_LEADING_ZERO 0x10
1467
1468 /**********************************************************************
1469 * VarParseNumFromStr [OLEAUT32.46]
1470 *
1471 * Parse a string containing a number into a NUMPARSE structure.
1472 *
1473 * PARAMS
1474 * lpszStr [I] String to parse number from
1475 * lcid [I] Locale Id for the conversion
1476 * dwFlags [I] 0, or LOCALE_NOUSEROVERRIDE to use system default number chars
1477 * pNumprs [I/O] Destination for parsed number
1478 * rgbDig [O] Destination for digits read in
1479 *
1480 * RETURNS
1481 * Success: S_OK. pNumprs and rgbDig contain the parsed representation of
1482 * the number.
1483 * Failure: E_INVALIDARG, if any parameter is invalid.
1484 * DISP_E_TYPEMISMATCH, if the string is not a number or is formatted
1485 * incorrectly.
1486 * DISP_E_OVERFLOW, if rgbDig is too small to hold the number.
1487 *
1488 * NOTES
1489 * pNumprs must have the following fields set:
1490 * cDig: Set to the size of rgbDig.
1491 * dwInFlags: Set to the allowable syntax of the number using NUMPRS_ flags
1492 * from "oleauto.h".
1493 *
1494 * FIXME
1495 * - I am unsure if this function should parse non-arabic (e.g. Thai)
1496 * numerals, so this has not been implemented.
1497 */
1498 HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
1499 NUMPARSE *pNumprs, BYTE *rgbDig)
1500 {
1501 VARIANT_NUMBER_CHARS chars;
1502 BYTE rgbTmp[1024];
1503 DWORD dwState = B_EXPONENT_START|B_INEXACT_ZEROS;
1504 int iMaxDigits = sizeof(rgbTmp) / sizeof(BYTE);
1505 int cchUsed = 0;
1506
1507 TRACE("(%s,%ld,0x%08lx,%p,%p)\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
1508
1509 if (!pNumprs || !rgbDig)
1510 return E_INVALIDARG;
1511
1512 if (pNumprs->cDig < iMaxDigits)
1513 iMaxDigits = pNumprs->cDig;
1514
1515 pNumprs->cDig = 0;
1516 pNumprs->dwOutFlags = 0;
1517 pNumprs->cchUsed = 0;
1518 pNumprs->nBaseShift = 0;
1519 pNumprs->nPwr10 = 0;
1520
1521 if (!lpszStr)
1522 return DISP_E_TYPEMISMATCH;
1523
1524 VARIANT_GetLocalisedNumberChars(&chars, lcid, dwFlags);
1525
1526 /* First consume all the leading symbols and space from the string */
1527 while (1)
1528 {
1529 if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && isspaceW(*lpszStr))
1530 {
1531 pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE;
1532 do
1533 {
1534 cchUsed++;
1535 lpszStr++;
1536 } while (isspaceW(*lpszStr));
1537 }
1538 else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS &&
1539 *lpszStr == chars.cPositiveSymbol &&
1540 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS))
1541 {
1542 pNumprs->dwOutFlags |= NUMPRS_LEADING_PLUS;
1543 cchUsed++;
1544 lpszStr++;
1545 }
1546 else if (pNumprs->dwInFlags & NUMPRS_LEADING_MINUS &&
1547 *lpszStr == chars.cNegativeSymbol &&
1548 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS))
1549 {
1550 pNumprs->dwOutFlags |= (NUMPRS_LEADING_MINUS|NUMPRS_NEG);
1551 cchUsed++;
1552 lpszStr++;
1553 }
1554 else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
1555 !(pNumprs->dwOutFlags & NUMPRS_CURRENCY) &&
1556 *lpszStr == chars.cCurrencyLocal &&
1557 (!chars.cCurrencyLocal2 || lpszStr[1] == chars.cCurrencyLocal2))
1558 {
1559 pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
1560 cchUsed++;
1561 lpszStr++;
1562 /* Only accept currency characters */
1563 chars.cDecimalPoint = chars.cCurrencyDecimalPoint;
1564 chars.cDigitSeperator = chars.cCurrencyDigitSeperator;
1565 }
1566 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == '(' &&
1567 !(pNumprs->dwOutFlags & NUMPRS_PARENS))
1568 {
1569 pNumprs->dwOutFlags |= NUMPRS_PARENS;
1570 cchUsed++;
1571 lpszStr++;
1572 }
1573 else
1574 break;
1575 }
1576
1577 if (!(pNumprs->dwOutFlags & NUMPRS_CURRENCY))
1578 {
1579 /* Only accept non-currency characters */
1580 chars.cCurrencyDecimalPoint = chars.cDecimalPoint;
1581 chars.cCurrencyDigitSeperator = chars.cDigitSeperator;
1582 }
1583
1584 /* Strip Leading zeros */
1585 while (*lpszStr == '0')
1586 {
1587 dwState |= B_LEADING_ZERO;
1588 cchUsed++;
1589 lpszStr++;
1590 }
1591
1592 while (*lpszStr)
1593 {
1594 if (isdigitW(*lpszStr))
1595 {
1596 if (dwState & B_PROCESSING_EXPONENT)
1597 {
1598 int exponentSize = 0;
1599 if (dwState & B_EXPONENT_START)
1600 {
1601 while (*lpszStr == '0')
1602 {
1603 /* Skip leading zero's in the exponent */
1604 cchUsed++;
1605 lpszStr++;
1606 }
1607 if (!isdigitW(*lpszStr))
1608 break; /* No exponent digits - invalid */
1609 }
1610
1611 while (isdigitW(*lpszStr))
1612 {
1613 exponentSize *= 10;
1614 exponentSize += *lpszStr - '0';
1615 cchUsed++;
1616 lpszStr++;
1617 }
1618 if (dwState & B_NEGATIVE_EXPONENT)
1619 exponentSize = -exponentSize;
1620 /* Add the exponent into the powers of 10 */
1621 pNumprs->nPwr10 += exponentSize;
1622 dwState &= ~(B_PROCESSING_EXPONENT|B_EXPONENT_START);
1623 lpszStr--; /* back up to allow processing of next char */
1624 }
1625 else
1626 {
1627 if (pNumprs->cDig >= iMaxDigits)
1628 {
1629 pNumprs->dwOutFlags |= NUMPRS_INEXACT;
1630
1631 if (*lpszStr != '0')
1632 dwState &= ~B_INEXACT_ZEROS; /* Inexact number with non-trailing zeros */
1633
1634 /* This digit can't be represented, but count it in nPwr10 */
1635 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1636 pNumprs->nPwr10--;
1637 else
1638 pNumprs->nPwr10++;
1639 }
1640 else
1641 {
1642 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1643 pNumprs->nPwr10--; /* Count decimal points in nPwr10 */
1644 rgbTmp[pNumprs->cDig] = *lpszStr - '0';
1645 }
1646 pNumprs->cDig++;
1647 cchUsed++;
1648 }
1649 }
1650 else if (*lpszStr == chars.cDigitSeperator && pNumprs->dwInFlags & NUMPRS_THOUSANDS)
1651 {
1652 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
1653 cchUsed++;
1654 }
1655 else if (*lpszStr == chars.cDecimalPoint &&
1656 pNumprs->dwInFlags & NUMPRS_DECIMAL &&
1657 !(pNumprs->dwOutFlags & (NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
1658 {
1659 pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
1660 cchUsed++;
1661
1662 /* Remove trailing zeros from the whole number part */
1663 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1])
1664 {
1665 pNumprs->nPwr10++;
1666 pNumprs->cDig--;
1667 }
1668
1669 /* If we have no digits so far, skip leading zeros */
1670 if (!pNumprs->cDig)
1671 {
1672 while (lpszStr[1] == '0')
1673 {
1674 dwState |= B_LEADING_ZERO;
1675 cchUsed++;
1676 lpszStr++;
1677 }
1678 }
1679 }
1680 else if ((*lpszStr == 'e' || *lpszStr == 'E') &&
1681 pNumprs->dwInFlags & NUMPRS_EXPONENT &&
1682 !(pNumprs->dwOutFlags & NUMPRS_EXPONENT))
1683 {
1684 dwState |= B_PROCESSING_EXPONENT;
1685 pNumprs->dwOutFlags |= NUMPRS_EXPONENT;
1686 cchUsed++;
1687 }
1688 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cPositiveSymbol)
1689 {
1690 cchUsed++; /* Ignore positive exponent */
1691 }
1692 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cNegativeSymbol)
1693 {
1694 dwState |= B_NEGATIVE_EXPONENT;
1695 cchUsed++;
1696 }
1697 else
1698 break; /* Stop at an unrecognised character */
1699
1700 lpszStr++;
1701 }
1702
1703 if (!pNumprs->cDig && dwState & B_LEADING_ZERO)
1704 {
1705 /* Ensure a 0 on its own gets stored */
1706 pNumprs->cDig = 1;
1707 rgbTmp[0] = 0;
1708 }
1709
1710 if (pNumprs->dwOutFlags & NUMPRS_EXPONENT && dwState & B_PROCESSING_EXPONENT)
1711 {
1712 pNumprs->cchUsed = cchUsed;
1713 return DISP_E_TYPEMISMATCH; /* Failed to completely parse the exponent */
1714 }
1715
1716 if (pNumprs->dwOutFlags & NUMPRS_INEXACT)
1717 {
1718 if (dwState & B_INEXACT_ZEROS)
1719 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* All zeros doesn't set NUMPRS_INEXACT */
1720 } else if(pNumprs->dwInFlags & NUMPRS_HEX_OCT)
1721 {
1722 /* copy all of the digits into the output digit buffer */
1723 /* this is exactly what windows does although it also returns */
1724 /* cDig of X and writes X+Y where Y>=0 number of digits to rgbDig */
1725 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE));
1726
1727 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1])
1728 {
1729 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1730 pNumprs->nPwr10--;
1731 else
1732 pNumprs->nPwr10++;
1733
1734 pNumprs->cDig--;
1735 }
1736 } else
1737 {
1738 /* Remove trailing zeros from the last (whole number or decimal) part */
1739 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1])
1740 {
1741 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1742 pNumprs->nPwr10--;
1743 else
1744 pNumprs->nPwr10++;
1745
1746 pNumprs->cDig--;
1747 }
1748 }
1749
1750 if (pNumprs->cDig <= iMaxDigits)
1751 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* Ignore stripped zeros for NUMPRS_INEXACT */
1752 else
1753 pNumprs->cDig = iMaxDigits; /* Only return iMaxDigits worth of digits */
1754
1755 /* Copy the digits we processed into rgbDig */
1756 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE));
1757
1758 /* Consume any trailing symbols and space */
1759 while (1)
1760 {
1761 if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && isspaceW(*lpszStr))
1762 {
1763 pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE;
1764 do
1765 {
1766 cchUsed++;
1767 lpszStr++;
1768 } while (isspaceW(*lpszStr));
1769 }
1770 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_PLUS &&
1771 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS) &&
1772 *lpszStr == chars.cPositiveSymbol)
1773 {
1774 pNumprs->dwOutFlags |= NUMPRS_TRAILING_PLUS;
1775 cchUsed++;
1776 lpszStr++;
1777 }
1778 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_MINUS &&
1779 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS) &&
1780 *lpszStr == chars.cNegativeSymbol)
1781 {
1782 pNumprs->dwOutFlags |= (NUMPRS_TRAILING_MINUS|NUMPRS_NEG);
1783 cchUsed++;
1784 lpszStr++;
1785 }
1786 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == ')' &&
1787 pNumprs->dwOutFlags & NUMPRS_PARENS)
1788 {
1789 cchUsed++;
1790 lpszStr++;
1791 pNumprs->dwOutFlags |= NUMPRS_NEG;
1792 }
1793 else
1794 break;
1795 }
1796
1797 if (pNumprs->dwOutFlags & NUMPRS_PARENS && !(pNumprs->dwOutFlags & NUMPRS_NEG))
1798 {
1799 pNumprs->cchUsed = cchUsed;
1800 return DISP_E_TYPEMISMATCH; /* Opening parenthesis not matched */
1801 }
1802
1803 if (pNumprs->dwInFlags & NUMPRS_USE_ALL && *lpszStr != '\0')
1804 return DISP_E_TYPEMISMATCH; /* Not all chars were consumed */
1805
1806 if (!pNumprs->cDig)
1807 return DISP_E_TYPEMISMATCH; /* No Number found */
1808
1809 pNumprs->cchUsed = cchUsed;
1810 return S_OK;
1811 }
1812
1813 /* VTBIT flags indicating an integer value */
1814 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
1815 /* VTBIT flags indicating a real number value */
1816 #define REAL_VTBITS (VTBIT_R4|VTBIT_R8|VTBIT_CY)
1817
1818 /**********************************************************************
1819 * VarNumFromParseNum [OLEAUT32.47]
1820 *
1821 * Convert a NUMPARSE structure into a numeric Variant type.
1822 *
1823 * PARAMS
1824 * pNumprs [I] Source for parsed number. cDig must be set to the size of rgbDig
1825 * rgbDig [I] Source for the numbers digits
1826 * dwVtBits [I] VTBIT_ flags from "oleauto.h" indicating the acceptable dest types
1827 * pVarDst [O] Destination for the converted Variant value.
1828 *
1829 * RETURNS
1830 * Success: S_OK. pVarDst contains the converted value.
1831 * Failure: E_INVALIDARG, if any parameter is invalid.
1832 * DISP_E_OVERFLOW, if the number is too big for the types set in dwVtBits.
1833 *
1834 * NOTES
1835 * - The smallest favoured type present in dwVtBits that can represent the
1836 * number in pNumprs without losing precision is used.
1837 * - Signed types are preferrred over unsigned types of the same size.
1838 * - Preferred types in order are: integer, float, double, currency then decimal.
1839 * - Rounding (dropping of decimal points) occurs without error. See VarI8FromR8()
1840 * for details of the rounding method.
1841 * - pVarDst is not cleared before the result is stored in it.
1842 */
1843 HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
1844 ULONG dwVtBits, VARIANT *pVarDst)
1845 {
1846 /* Scale factors and limits for double arithmetic */
1847 static const double dblMultipliers[11] = {
1848 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0,
1849 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0
1850 };
1851 static const double dblMinimums[11] = {
1852 R8_MIN, R8_MIN*10.0, R8_MIN*100.0, R8_MIN*1000.0, R8_MIN*10000.0,
1853 R8_MIN*100000.0, R8_MIN*1000000.0, R8_MIN*10000000.0,
1854 R8_MIN*100000000.0, R8_MIN*1000000000.0, R8_MIN*10000000000.0
1855 };
1856 static const double dblMaximums[11] = {
1857 R8_MAX, R8_MAX/10.0, R8_MAX/100.0, R8_MAX/1000.0, R8_MAX/10000.0,
1858 R8_MAX/100000.0, R8_MAX/1000000.0, R8_MAX/10000000.0,
1859 R8_MAX/100000000.0, R8_MAX/1000000000.0, R8_MAX/10000000000.0
1860 };
1861
1862 int wholeNumberDigits, fractionalDigits, divisor10 = 0, multiplier10 = 0;
1863
1864 TRACE("(%p,%p,0x%lx,%p)\n", pNumprs, rgbDig, dwVtBits, pVarDst);
1865
1866 if (pNumprs->nBaseShift)
1867 {
1868 /* nBaseShift indicates a hex or octal number */
1869 FIXME("nBaseShift=%d not yet implemented, returning overflow\n", pNumprs->nBaseShift);
1870 return DISP_E_OVERFLOW;
1871 }
1872
1873 /* Count the number of relevant fractional and whole digits stored,
1874 * And compute the divisor/multiplier to scale the number by.
1875 */
1876 if (pNumprs->nPwr10 < 0)
1877 {
1878 if (-pNumprs->nPwr10 >= pNumprs->cDig)
1879 {
1880 /* A real number < +/- 1.0 e.g. 0.1024 or 0.01024 */
1881 wholeNumberDigits = 0;
1882 fractionalDigits = pNumprs->cDig;
1883 divisor10 = -pNumprs->nPwr10;
1884 }
1885 else
1886 {
1887 /* An exactly represented real number e.g. 1.024 */
1888 wholeNumberDigits = pNumprs->cDig + pNumprs->nPwr10;
1889 fractionalDigits = pNumprs->cDig - wholeNumberDigits;
1890 divisor10 = pNumprs->cDig - wholeNumberDigits;
1891 }
1892 }
1893 else if (pNumprs->nPwr10 == 0)
1894 {
1895 /* An exactly represented whole number e.g. 1024 */
1896 wholeNumberDigits = pNumprs->cDig;
1897 fractionalDigits = 0;
1898 }
1899 else /* pNumprs->nPwr10 > 0 */
1900 {
1901 /* A whole number followed by nPwr10 0's e.g. 102400 */
1902 wholeNumberDigits = pNumprs->cDig;
1903 fractionalDigits = 0;
1904 multiplier10 = pNumprs->nPwr10;
1905 }
1906
1907 TRACE("cDig %d; nPwr10 %d, whole %d, frac %d ", pNumprs->cDig,
1908 pNumprs->nPwr10, wholeNumberDigits, fractionalDigits);
1909 TRACE("mult %d; div %d\n", multiplier10, divisor10);
1910
1911 if (dwVtBits & (INTEGER_VTBITS|VTBIT_DECIMAL) &&
1912 (!fractionalDigits || !(dwVtBits & (REAL_VTBITS|VTBIT_CY|VTBIT_DECIMAL))))
1913 {
1914 /* We have one or more integer output choices, and either:
1915 * 1) An integer input value, or
1916 * 2) A real number input value but no floating output choices.
1917 * Alternately, we have a DECIMAL output available and an integer input.
1918 *
1919 * So, place the integer value into pVarDst, using the smallest type
1920 * possible and preferring signed over unsigned types.
1921 */
1922 BOOL bOverflow = FALSE, bNegative;
1923 ULONG64 ul64 = 0;
1924 int i;
1925
1926 /* Convert the integer part of the number into a UI8 */
1927 for (i = 0; i < wholeNumberDigits; i++)
1928 {
1929 if (ul64 > (UI8_MAX / 10 - rgbDig[i]))
1930 {
1931 TRACE("Overflow multiplying digits\n");
1932 bOverflow = TRUE;
1933 break;
1934 }
1935 ul64 = ul64 * 10 + rgbDig[i];
1936 }
1937
1938 /* Account for the scale of the number */
1939 if (!bOverflow && multiplier10)
1940 {
1941 for (i = 0; i < multiplier10; i++)
1942 {
1943 if (ul64 > (UI8_MAX / 10))
1944 {
1945 TRACE("Overflow scaling number\n");
1946 bOverflow = TRUE;
1947 break;
1948 }
1949 ul64 = ul64 * 10;
1950 }
1951 }
1952
1953 /* If we have any fractional digits, round the value.
1954 * Note we don't have to do this if divisor10 is < 1,
1955 * because this means the fractional part must be < 0.5
1956 */
1957 if (!bOverflow && fractionalDigits && divisor10 > 0)
1958 {
1959 const BYTE* fracDig = rgbDig + wholeNumberDigits;
1960 BOOL bAdjust = FALSE;
1961
1962 TRACE("first decimal value is %d\n", *fracDig);
1963
1964 if (*fracDig > 5)
1965 bAdjust = TRUE; /* > 0.5 */
1966 else if (*fracDig == 5)
1967 {
1968 for (i = 1; i < fractionalDigits; i++)
1969 {
1970 if (fracDig[i])
1971 {
1972 bAdjust = TRUE; /* > 0.5 */
1973 break;
1974 }
1975 }
1976 /* If exactly 0.5, round only odd values */
1977 if (i == fractionalDigits && (ul64 & 1))
1978 bAdjust = TRUE;
1979 }
1980
1981 if (bAdjust)
1982 {
1983 if (ul64 == UI8_MAX)
1984 {
1985 TRACE("Overflow after rounding\n");
1986 bOverflow = TRUE;
1987 }
1988 ul64++;
1989 }
1990 }
1991
1992 /* Zero is not a negative number */
1993 bNegative = pNumprs->dwOutFlags & NUMPRS_NEG && ul64 ? TRUE : FALSE;
1994
1995 TRACE("Integer value is %lld, bNeg %d\n", ul64, bNegative);
1996
1997 /* For negative integers, try the signed types in size order */
1998 if (!bOverflow && bNegative)
1999 {
2000 if (dwVtBits & (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8))
2001 {
2002 if (dwVtBits & VTBIT_I1 && ul64 <= -I1_MIN)
2003 {
2004 V_VT(pVarDst) = VT_I1;
2005 V_I1(pVarDst) = -ul64;
2006 return S_OK;
2007 }
2008 else if (dwVtBits & VTBIT_I2 && ul64 <= -I2_MIN)
2009 {
2010 V_VT(pVarDst) = VT_I2;
2011 V_I2(pVarDst) = -ul64;
2012 return S_OK;
2013 }
2014 else if (dwVtBits & VTBIT_I4 && ul64 <= -((LONGLONG)I4_MIN))
2015 {
2016 V_VT(pVarDst) = VT_I4;
2017 V_I4(pVarDst) = -ul64;
2018 return S_OK;
2019 }
2020 else if (dwVtBits & VTBIT_I8 && ul64 <= (ULONGLONG)I8_MAX + 1)
2021 {
2022 V_VT(pVarDst) = VT_I8;
2023 V_I8(pVarDst) = -ul64;
2024 return S_OK;
2025 }
2026 else if ((dwVtBits & REAL_VTBITS) == VTBIT_DECIMAL)
2027 {
2028 /* Decimal is only output choice left - fast path */
2029 V_VT(pVarDst) = VT_DECIMAL;
2030 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_NEG,0);
2031 DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
2032 DEC_LO64(&V_DECIMAL(pVarDst)) = -ul64;
2033 return S_OK;
2034 }
2035 }
2036 }
2037 else if (!bOverflow)
2038 {
2039 /* For positive integers, try signed then unsigned types in size order */
2040 if (dwVtBits & VTBIT_I1 && ul64 <= I1_MAX)
2041 {
2042 V_VT(pVarDst) = VT_I1;
2043 V_I1(pVarDst) = ul64;
2044 return S_OK;
2045 }
2046 else if (dwVtBits & VTBIT_UI1 && ul64 <= UI1_MAX)
2047 {
2048 V_VT(pVarDst) = VT_UI1;
2049 V_UI1(pVarDst) = ul64;
2050 return S_OK;
2051 }
2052 else if (dwVtBits & VTBIT_I2 && ul64 <= I2_MAX)
2053 {
2054 V_VT(pVarDst) = VT_I2;
2055 V_I2(pVarDst) = ul64;
2056 return S_OK;
2057 }
2058 else if (dwVtBits & VTBIT_UI2 && ul64 <= UI2_MAX)
2059 {
2060 V_VT(pVarDst) = VT_UI2;
2061 V_UI2(pVarDst) = ul64;
2062 return S_OK;
2063 }
2064 else if (dwVtBits & VTBIT_I4 && ul64 <= I4_MAX)
2065 {
2066 V_VT(pVarDst) = VT_I4;
2067 V_I4(pVarDst) = ul64;
2068 return S_OK;
2069 }
2070 else if (dwVtBits & VTBIT_UI4 && ul64 <= UI4_MAX)
2071 {
2072 V_VT(pVarDst) = VT_UI4;
2073 V_UI4(pVarDst) = ul64;
2074 return S_OK;
2075 }
2076 else if (dwVtBits & VTBIT_I8 && ul64 <= I8_MAX)
2077 {
2078 V_VT(pVarDst) = VT_I8;
2079 V_I8(pVarDst) = ul64;
2080 return S_OK;
2081 }
2082 else if (dwVtBits & VTBIT_UI8)
2083 {
2084 V_VT(pVarDst) = VT_UI8;
2085 V_UI8(pVarDst) = ul64;
2086 return S_OK;
2087 }
2088 else if ((dwVtBits & REAL_VTBITS) == VTBIT_DECIMAL)
2089 {
2090 /* Decimal is only output choice left - fast path */
2091 V_VT(pVarDst) = VT_DECIMAL;
2092 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
2093 DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
2094 DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
2095 return S_OK;
2096 }
2097 }
2098 }
2099
2100 if (dwVtBits & REAL_VTBITS)
2101 {
2102 /* Try to put the number into a float or real */
2103 BOOL bOverflow = FALSE, bNegative = pNumprs->dwOutFlags & NUMPRS_NEG;
2104 double whole = 0.0;
2105 int i;
2106
2107 /* Convert the number into a double */
2108 for (i = 0; i < pNumprs->cDig; i++)
2109 whole = whole * 10.0 + rgbDig[i];
2110
2111 TRACE("Whole double value is %16.16g\n", whole);
2112
2113 /* Account for the scale */
2114 while (multiplier10 > 10)
2115 {
2116 if (whole > dblMaximums[10])
2117 {
2118 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY);
2119 bOverflow = TRUE;
2120 break;
2121 }
2122 whole = whole * dblMultipliers[10];
2123 multiplier10 -= 10;
2124 }
2125 if (multiplier10)
2126 {
2127 if (whole > dblMaximums[multiplier10])
2128 {
2129 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY);
2130 bOverflow = TRUE;
2131 }
2132 else
2133 whole = whole * dblMultipliers[multiplier10];
2134 }
2135
2136 TRACE("Scaled double value is %16.16g\n", whole);
2137
2138 while (divisor10 > 10)
2139 {
2140 if (whole < dblMinimums[10])
2141 {
2142 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); /* Underflow */
2143 bOverflow = TRUE;
2144 break;
2145 }
2146 whole = whole / dblMultipliers[10];
2147 divisor10 -= 10;
2148 }
2149 if (divisor10)
2150 {
2151 if (whole < dblMinimums[divisor10])
2152 {
2153 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); /* Underflow */
2154 bOverflow = TRUE;
2155 }
2156 else
2157 whole = whole / dblMultipliers[divisor10];
2158 }
2159 if (!bOverflow)
2160 TRACE("Final double value is %16.16g\n", whole);
2161
2162 if (dwVtBits & VTBIT_R4 &&
2163 ((whole <= R4_MAX && whole >= R4_MIN) || whole == 0.0))
2164 {
2165 TRACE("Set R4 to final value\n");
2166 V_VT(pVarDst) = VT_R4; /* Fits into a float */
2167 V_R4(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole;
2168 return S_OK;
2169 }
2170
2171 if (dwVtBits & VTBIT_R8)
2172 {
2173 TRACE("Set R8 to final value\n");
2174 V_VT(pVarDst) = VT_R8; /* Fits into a double */
2175 V_R8(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole;
2176 return S_OK;
2177 }
2178
2179 if (dwVtBits & VTBIT_CY)
2180 {
2181 if (SUCCEEDED(VarCyFromR8(bNegative ? -whole : whole, &V_CY(pVarDst))))
2182 {
2183 V_VT(pVarDst) = VT_CY; /* Fits into a currency */
2184 TRACE("Set CY to final value\n");
2185 return S_OK;
2186 }
2187 TRACE("Value Overflows CY\n");
2188 }
2189 }
2190
2191 if (dwVtBits & VTBIT_DECIMAL)
2192 {
2193 int i;
2194 ULONG carry;
2195 ULONG64 tmp;
2196 DECIMAL* pDec = &V_DECIMAL(pVarDst);
2197
2198 DECIMAL_SETZERO(pDec);
2199 DEC_LO32(pDec) = 0;
2200
2201 if (pNumprs->dwOutFlags & NUMPRS_NEG)
2202 DEC_SIGN(pDec) = DECIMAL_NEG;
2203 else
2204 DEC_SIGN(pDec) = DECIMAL_POS;
2205
2206 /* Factor the significant digits */
2207 for (i = 0; i < pNumprs->cDig; i++)
2208 {
2209 tmp = (ULONG64)DEC_LO32(pDec) * 10 + rgbDig[i];
2210 carry = (ULONG)(tmp >> 32);
2211 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
2212 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
2213 carry = (ULONG)(tmp >> 32);
2214 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
2215 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
2216 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
2217
2218 if (tmp >> 32 & UI4_MAX)
2219 {
2220 VarNumFromParseNum_DecOverflow:
2221 TRACE("Overflow\n");
2222 DEC_LO32(pDec) = DEC_MID32(pDec) = DEC_HI32(pDec) = UI4_MAX;
2223 return DISP_E_OVERFLOW;
2224 }
2225 }
2226
2227 /* Account for the scale of the number */
2228 while (multiplier10 > 0)
2229 {
2230 tmp = (ULONG64)DEC_LO32(pDec) * 10;
2231 carry = (ULONG)(tmp >> 32);
2232 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
2233 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
2234 carry = (ULONG)(tmp >> 32);
2235 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
2236 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
2237 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
2238
2239 if (tmp >> 32 & UI4_MAX)
2240 goto VarNumFromParseNum_DecOverflow;
2241 multiplier10--;
2242 }
2243 DEC_SCALE(pDec) = divisor10;
2244
2245 V_VT(pVarDst) = VT_DECIMAL;
2246 return S_OK;
2247 }
2248 return DISP_E_OVERFLOW; /* No more output choices */
2249 }
2250
2251 /**********************************************************************
2252 * VarCat [OLEAUT32.318]
2253 */
2254 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
2255 {
2256 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2257 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), out);
2258
2259 /* Should we VariantClear out? */
2260 /* Can we handle array, vector, by ref etc. */
2261 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL &&
2262 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
2263 {
2264 V_VT(out) = VT_NULL;
2265 return S_OK;
2266 }
2267
2268 if (V_VT(left) == VT_BSTR && V_VT(right) == VT_BSTR)
2269 {
2270 V_VT(out) = VT_BSTR;
2271 VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out));
2272 return S_OK;
2273 }
2274 if (V_VT(left) == VT_BSTR) {
2275 VARIANT bstrvar;
2276 HRESULT hres;
2277
2278 V_VT(out) = VT_BSTR;
2279 hres = VariantChangeTypeEx(&bstrvar,right,0,0,VT_BSTR);
2280 if (hres) {
2281 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
2282 return hres;
2283 }
2284 VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar), &V_BSTR(out));
2285 return S_OK;
2286 }
2287 if (V_VT(right) == VT_BSTR) {
2288 VARIANT bstrvar;
2289 HRESULT hres;
2290
2291 V_VT(out) = VT_BSTR;
2292 hres = VariantChangeTypeEx(&bstrvar,left,0,0,VT_BSTR);
2293 if (hres) {
2294 FIXME("Failed to convert right side from vt %d to VT_BSTR?\n",V_VT(right));
2295 return hres;
2296 }
2297 VarBstrCat (V_BSTR(&bstrvar), V_BSTR(right), &V_BSTR(out));
2298 return S_OK;
2299 }
2300 FIXME ("types %d / %d not supported\n",V_VT(left)&VT_TYPEMASK, V_VT(right)&VT_TYPEMASK);
2301 return S_OK;
2302 }
2303
2304 /**********************************************************************
2305 * VarCmp [OLEAUT32.176]
2306 *
2307 * flags can be:
2308 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS
2309 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
2310 *
2311 */
2312 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
2313 {
2314 BOOL lOk = TRUE;
2315 BOOL rOk = TRUE;
2316 LONGLONG lVal = -1;
2317 LONGLONG rVal = -1;
2318 VARIANT rv,lv;
2319 DWORD xmask;
2320 HRESULT rc;
2321
2322 TRACE("(%p->(%s%s),%p->(%s%s),0x%08lx,0x%08lx)\n", left, debugstr_VT(left),
2323 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), lcid, flags);
2324
2325 VariantInit(&lv);VariantInit(&rv);
2326 V_VT(right) &= ~0x8000; /* hack since we sometime get this flag. */
2327 V_VT(left) &= ~0x8000; /* hack since we sometime get this flag. */
2328
2329 /* If either are null, then return VARCMP_NULL */
2330 if ((V_VT(left)&VT_TYPEMASK) == VT_NULL ||
2331 (V_VT(right)&VT_TYPEMASK) == VT_NULL)
2332 return VARCMP_NULL;
2333
2334 /* Strings - use VarBstrCmp */
2335 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
2336 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
2337 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
2338 }
2339
2340 xmask = (1<<(V_VT(left)&VT_TYPEMASK))|(1<<(V_VT(right)&VT_TYPEMASK));
2341 if (xmask & (1<<VT_R8)) {
2342 rc = VariantChangeType(&lv,left,0,VT_R8);
2343 if (FAILED(rc)) return rc;
2344 rc = VariantChangeType(&rv,right,0,VT_R8);
2345 if (FAILED(rc)) return rc;
2346
2347 if (V_R8(&lv) == V_R8(&rv)) return VARCMP_EQ;
2348 if (V_R8(&lv) < V_R8(&rv)) return VARCMP_LT;
2349 if (V_R8(&lv) > V_R8(&rv)) return VARCMP_GT;
2350 return E_FAIL; /* can't get here */
2351 }
2352 if (xmask & (1<<VT_R4)) {
2353 rc = VariantChangeType(&lv,left,0,VT_R4);
2354 if (FAILED(rc)) return rc;
2355 rc = VariantChangeType(&rv,right,0,VT_R4);
2356 if (FAILED(rc)) return rc;
2357
2358 if (V_R4(&lv) == V_R4(&rv)) return VARCMP_EQ;
2359 if (V_R4(&lv) < V_R4(&rv)) return VARCMP_LT;
2360 if (V_R4(&lv) > V_R4(&rv)) return VARCMP_GT;
2361 return E_FAIL; /* can't get here */
2362 }
2363
2364 /* Integers - Ideally like to use VarDecCmp, but no Dec support yet
2365 Use LONGLONG to maximize ranges */
2366 lOk = TRUE;
2367 switch (V_VT(left)&VT_TYPEMASK) {
2368 case VT_I1 : lVal = V_UNION(left,cVal); break;
2369 case VT_I2 : lVal = V_UNION(left,iVal); break;
2370 case VT_I4 : lVal = V_UNION(left,lVal); break;
2371 case VT_INT : lVal = V_UNION(left,lVal); break;
2372 case VT_UI1 : lVal = V_UNION(left,bVal); break;
2373 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
2374 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
2375 case VT_UINT : lVal = V_UNION(left,ulVal); break;
2376 case VT_BOOL : lVal = V_UNION(left,boolVal); break;
2377 default: lOk = FALSE;
2378 }
2379
2380 rOk = TRUE;
2381 switch (V_VT(right)&VT_TYPEMASK) {
2382 case VT_I1 : rVal = V_UNION(right,cVal); break;
2383 case VT_I2 : rVal = V_UNION(right,iVal); break;
2384 case VT_I4 : rVal = V_UNION(right,lVal); break;
2385 case VT_INT : rVal = V_UNION(right,lVal); break;
2386 case VT_UI1 : rVal = V_UNION(right,bVal); break;
2387 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
2388 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
2389 case VT_UINT : rVal = V_UNION(right,ulVal); break;
2390 case VT_BOOL : rVal = V_UNION(right,boolVal); break;
2391 default: rOk = FALSE;
2392 }
2393
2394 if (lOk && rOk) {
2395 if (lVal < rVal) {
2396 return VARCMP_LT;
2397 } else if (lVal > rVal) {
2398 return VARCMP_GT;
2399 } else {
2400 return VARCMP_EQ;
2401 }
2402 }
2403
2404 /* Strings - use VarBstrCmp */
2405 if ((V_VT(left)&VT_TYPEMASK) == VT_DATE &&
2406 (V_VT(right)&VT_TYPEMASK) == VT_DATE) {
2407
2408 if (floor(V_UNION(left,date)) == floor(V_UNION(right,date))) {
2409 /* Due to floating point rounding errors, calculate varDate in whole numbers) */
2410 double wholePart = 0.0;
2411 double leftR;
2412 double rightR;
2413
2414 /* Get the fraction * 24*60*60 to make it into whole seconds */
2415 wholePart = (double) floor( V_UNION(left,date) );
2416 if (wholePart == 0) wholePart = 1;
2417 leftR = floor(fmod( V_UNION(left,date), wholePart ) * (24*60*60));
2418
2419 wholePart = (double) floor( V_UNION(right,date) );
2420 if (wholePart == 0) wholePart = 1;
2421 rightR = floor(fmod( V_UNION(right,date), wholePart ) * (24*60*60));
2422
2423 if (leftR < rightR) {
2424 return VARCMP_LT;
2425 } else if (leftR > rightR) {
2426 return VARCMP_GT;
2427 } else {
2428 return VARCMP_EQ;
2429 }
2430
2431 } else if (V_UNION(left,date) < V_UNION(right,date)) {
2432 return VARCMP_LT;
2433 } else if (V_UNION(left,date) > V_UNION(right,date)) {
2434 return VARCMP_GT;
2435 }
2436 }
2437 FIXME("VarCmp partial implementation, doesn't support vt 0x%x / 0x%x\n",V_VT(left), V_VT(right));
2438 return E_FAIL;
2439 }
2440
2441 /**********************************************************************
2442 * VarAnd [OLEAUT32.142]
2443 *
2444 */
2445 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2446 {
2447 HRESULT rc = E_FAIL;
2448
2449 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2450 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2451
2452 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
2453 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
2454
2455 V_VT(result) = VT_BOOL;
2456 if (V_BOOL(left) && V_BOOL(right)) {
2457 V_BOOL(result) = VARIANT_TRUE;
2458 } else {
2459 V_BOOL(result) = VARIANT_FALSE;
2460 }
2461 rc = S_OK;
2462
2463 } else {
2464 /* Integers */
2465 BOOL lOk = TRUE;
2466 BOOL rOk = TRUE;
2467 LONGLONG lVal = -1;
2468 LONGLONG rVal = -1;
2469 LONGLONG res = -1;
2470 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
2471 becomes I4, even unsigned ints (incl. UI2) */
2472
2473 lOk = TRUE;
2474 switch (V_VT(left)&VT_TYPEMASK) {
2475 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
2476 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
2477 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2478 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2479 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
2480 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
2481 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2482 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2483 case VT_BOOL : rVal = V_UNION(left,boolVal); resT=VT_I4; break;
2484 default: lOk = FALSE;
2485 }
2486
2487 rOk = TRUE;
2488 switch (V_VT(right)&VT_TYPEMASK) {
2489 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
2490 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
2491 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2492 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2493 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
2494 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
2495 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2496 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2497 case VT_BOOL : rVal = V_UNION(right,boolVal); resT=VT_I4; break;
2498 default: rOk = FALSE;
2499 }
2500
2501 if (lOk && rOk) {
2502 res = (lVal & rVal);
2503 V_VT(result) = resT;
2504 switch (resT) {
2505 case VT_I2 : V_UNION(result,iVal) = res; break;
2506 case VT_I4 : V_UNION(result,lVal) = res; break;
2507 default:
2508 FIXME("Unexpected result variant type %x\n", resT);
2509 V_UNION(result,lVal) = res;
2510 }
2511 rc = S_OK;
2512
2513 } else {
2514 FIXME("VarAnd stub\n");
2515 }
2516 }
2517
2518 TRACE("returning 0x%8lx (%s%s),%ld\n", rc, debugstr_VT(result),
2519 debugstr_VF(result), V_VT(result) == VT_I4 ? V_I4(result) : V_I2(result));
2520 return rc;
2521 }
2522
2523 /**********************************************************************
2524 * VarAdd [OLEAUT32.141]
2525 * FIXME: From MSDN: If ... Then
2526 * Both expressions are of the string type Concatenated.
2527 * One expression is a string type and the other a character Addition.
2528 * One expression is numeric and the other is a string Addition.
2529 * Both expressions are numeric Addition.
2530 * Either expression is NULL NULL is returned.
2531 * Both expressions are empty Integer subtype is returned.
2532 *
2533 */
2534 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2535 {
2536 HRESULT rc = E_FAIL;
2537
2538 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2539 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2540
2541 if ((V_VT(left)&VT_TYPEMASK) == VT_EMPTY)
2542 return VariantCopy(result,right);
2543
2544 if ((V_VT(right)&VT_TYPEMASK) == VT_EMPTY)
2545 return VariantCopy(result,left);
2546
2547 /* check if we add doubles */
2548 if (((V_VT(left)&VT_TYPEMASK) == VT_R8) || ((V_VT(right)&VT_TYPEMASK) == VT_R8)) {
2549 BOOL lOk = TRUE;
2550 BOOL rOk = TRUE;
2551 double lVal = -1;
2552 double rVal = -1;
2553 double res = -1;
2554
2555 lOk = TRUE;
2556 switch (V_VT(left)&VT_TYPEMASK) {
2557 case VT_I1 : lVal = V_UNION(left,cVal); break;
2558 case VT_I2 : lVal = V_UNION(left,iVal); break;
2559 case VT_I4 : lVal = V_UNION(left,lVal); break;
2560 case VT_INT : lVal = V_UNION(left,lVal); break;
2561 case VT_UI1 : lVal = V_UNION(left,bVal); break;
2562 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
2563 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
2564 case VT_UINT : lVal = V_UNION(left,ulVal); break;
2565 case VT_R4 : lVal = V_UNION(left,fltVal); break;
2566 case VT_R8 : lVal = V_UNION(left,dblVal); break;
2567 case VT_NULL : lVal = 0.0; break;
2568 default: lOk = FALSE;
2569 }
2570
2571 rOk = TRUE;
2572 switch (V_VT(right)&VT_TYPEMASK) {
2573 case VT_I1 : rVal = V_UNION(right,cVal); break;
2574 case VT_I2 : rVal = V_UNION(right,iVal); break;
2575 case VT_I4 : rVal = V_UNION(right,lVal); break;
2576 case VT_INT : rVal = V_UNION(right,lVal); break;
2577 case VT_UI1 : rVal = V_UNION(right,bVal); break;
2578 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
2579 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
2580 case VT_UINT : rVal = V_UNION(right,ulVal); break;
2581 case VT_R4 : rVal = V_UNION(right,fltVal);break;
2582 case VT_R8 : rVal = V_UNION(right,dblVal);break;
2583 case VT_NULL : rVal = 0.0; break;
2584 default: rOk = FALSE;
2585 }
2586
2587 if (lOk && rOk) {
2588 res = (lVal + rVal);
2589 V_VT(result) = VT_R8;
2590 V_UNION(result,dblVal) = res;
2591 rc = S_OK;
2592 } else {
2593 FIXME("Unhandled type pair %d / %d in double addition.\n",
2594 (V_VT(left)&VT_TYPEMASK),
2595 (V_VT(right)&VT_TYPEMASK)
2596 );
2597 }
2598 return rc;
2599 }
2600
2601 /* now check if we add floats. VT_R8 can no longer happen here! */
2602 if (((V_VT(left)&VT_TYPEMASK) == VT_R4) || ((V_VT(right)&VT_TYPEMASK) == VT_R4)) {
2603 BOOL lOk = TRUE;
2604 BOOL rOk = TRUE;
2605 float lVal = -1;
2606 float rVal = -1;
2607 float res = -1;
2608
2609 lOk = TRUE;
2610 switch (V_VT(left)&VT_TYPEMASK) {
2611 case VT_I1 : lVal = V_UNION(left,cVal); break;
2612 case VT_I2 : lVal = V_UNION(left,iVal); break;
2613 case VT_I4 : lVal = V_UNION(left,lVal); break;
2614 case VT_INT : lVal = V_UNION(left,lVal); break;
2615 case VT_UI1 : lVal = V_UNION(left,bVal); break;
2616 case VT_UI2 : lVal = V_UNION(left,uiVal); break;
2617 case VT_UI4 : lVal = V_UNION(left,ulVal); break;
2618 case VT_UINT : lVal = V_UNION(left,ulVal); break;
2619 case VT_R4 : lVal = V_UNION(left,fltVal); break;
2620 case VT_NULL : lVal = 0.0; break;
2621 default: lOk = FALSE;
2622 }
2623
2624 rOk = TRUE;
2625 switch (V_VT(right)&VT_TYPEMASK) {
2626 case VT_I1 : rVal = V_UNION(right,cVal); break;
2627 case VT_I2 : rVal = V_UNION(right,iVal); break;
2628 case VT_I4 : rVal = V_UNION(right,lVal); break;
2629 case VT_INT : rVal = V_UNION(right,lVal); break;
2630 case VT_UI1 : rVal = V_UNION(right,bVal); break;
2631 case VT_UI2 : rVal = V_UNION(right,uiVal); break;
2632 case VT_UI4 : rVal = V_UNION(right,ulVal); break;
2633 case VT_UINT : rVal = V_UNION(right,ulVal); break;
2634 case VT_R4 : rVal = V_UNION(right,fltVal);break;
2635 case VT_NULL : rVal = 0.0; break;
2636 default: rOk = FALSE;
2637 }
2638
2639 if (lOk && rOk) {
2640 res = (lVal + rVal);
2641 V_VT(result) = VT_R4;
2642 V_UNION(result,fltVal) = res;
2643 rc = S_OK;
2644 } else {
2645 FIXME("Unhandled type pair %d / %d in float addition.\n",
2646 (V_VT(left)&VT_TYPEMASK),
2647 (V_VT(right)&VT_TYPEMASK)
2648 );
2649 }
2650 return rc;
2651 }
2652
2653 /* Handle strings as concat */
2654 if ((V_VT(left)&VT_TYPEMASK) == VT_BSTR &&
2655 (V_VT(right)&VT_TYPEMASK) == VT_BSTR) {
2656 V_VT(result) = VT_BSTR;
2657 return VarBstrCat(V_BSTR(left), V_BSTR(right), &V_BSTR(result));
2658 } else {
2659
2660 /* Integers */
2661 BOOL lOk = TRUE;
2662 BOOL rOk = TRUE;
2663 LONGLONG lVal = -1;
2664 LONGLONG rVal = -1;
2665 LONGLONG res = -1;
2666 int resT = 0; /* Testing has shown I2 + I2 == I2, all else
2667 becomes I4 */
2668
2669 lOk = TRUE;
2670 switch (V_VT(left)&VT_TYPEMASK) {
2671 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
2672 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
2673 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2674 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2675 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
2676 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
2677 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2678 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2679 case VT_NULL : lVal = 0; resT = VT_I4; break;
2680 default: lOk = FALSE;
2681 }
2682
2683 rOk = TRUE;
2684 switch (V_VT(right)&VT_TYPEMASK) {
2685 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
2686 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
2687 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2688 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2689 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
2690 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
2691 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2692 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2693 case VT_NULL : rVal = 0; resT=VT_I4; break;
2694 default: rOk = FALSE;
2695 }
2696
2697 if (lOk && rOk) {
2698 res = (lVal + rVal);
2699 V_VT(result) = resT;
2700 switch (resT) {
2701 case VT_I2 : V_UNION(result,iVal) = res; break;
2702 case VT_I4 : V_UNION(result,lVal) = res; break;
2703 default:
2704 FIXME("Unexpected result variant type %x\n", resT);
2705 V_UNION(result,lVal) = res;
2706 }
2707 rc = S_OK;
2708
2709 } else {
2710 FIXME("unimplemented part (0x%x + 0x%x)\n",V_VT(left), V_VT(right));
2711 }
2712 }
2713
2714 TRACE("returning 0x%8lx (%s%s),%ld\n", rc, debugstr_VT(result),
2715 debugstr_VF(result), V_VT(result) == VT_I4 ? V_I4(result) : V_I2(result));
2716 return rc;
2717 }
2718
2719 /**********************************************************************
2720 * VarMul [OLEAUT32.156]
2721 *
2722 */
2723 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2724 {
2725 HRESULT rc = E_FAIL;
2726 VARTYPE lvt,rvt,resvt;
2727 VARIANT lv,rv;
2728 BOOL found;
2729
2730 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2731 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2732
2733 VariantInit(&lv);VariantInit(&rv);
2734 lvt = V_VT(left)&VT_TYPEMASK;
2735 rvt = V_VT(right)&VT_TYPEMASK;
2736 found = FALSE;resvt=VT_VOID;
2737 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
2738 found = TRUE;
2739 resvt = VT_R8;
2740 }
2741 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)))) {
2742 found = TRUE;
2743 resvt = VT_I4;
2744 }
2745 if (!found) {
2746 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
2747 return E_FAIL;
2748 }
2749 rc = VariantChangeType(&lv, left, 0, resvt);
2750 if (FAILED(rc)) {
2751 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
2752 return rc;
2753 }
2754 rc = VariantChangeType(&rv, right, 0, resvt);
2755 if (FAILED(rc)) {
2756 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
2757 return rc;
2758 }
2759 switch (resvt) {
2760 case VT_R8:
2761 V_VT(result) = resvt;
2762 V_R8(result) = V_R8(&lv) * V_R8(&rv);
2763 rc = S_OK;
2764 break;
2765 case VT_I4:
2766 V_VT(result) = resvt;
2767 V_I4(result) = V_I4(&lv) * V_I4(&rv);
2768 rc = S_OK;
2769 break;
2770 }
2771 TRACE("returning 0x%8lx (%s%s),%g\n", rc, debugstr_VT(result),
2772 debugstr_VF(result), V_VT(result) == VT_R8 ? V_R8(result) : (double)V_I4(result));
2773 return rc;
2774 }
2775
2776 /**********************************************************************
2777 * VarDiv [OLEAUT32.143]
2778 *
2779 */
2780 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2781 {
2782 HRESULT rc = E_FAIL;
2783 VARTYPE lvt,rvt,resvt;
2784 VARIANT lv,rv;
2785 BOOL found;
2786
2787 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2788 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2789
2790 VariantInit(&lv);VariantInit(&rv);
2791 lvt = V_VT(left)&VT_TYPEMASK;
2792 rvt = V_VT(right)&VT_TYPEMASK;
2793 found = FALSE;resvt = VT_VOID;
2794 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_R4)|(1<<VT_R8))) {
2795 found = TRUE;
2796 resvt = VT_R8;
2797 }
2798 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)))) {
2799 found = TRUE;
2800 resvt = VT_I4;
2801 }
2802 if (!found) {
2803 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
2804 return E_FAIL;
2805 }
2806 rc = VariantChangeType(&lv, left, 0, resvt);
2807 if (FAILED(rc)) {
2808 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
2809 return rc;
2810 }
2811 rc = VariantChangeType(&rv, right, 0, resvt);
2812 if (FAILED(rc)) {
2813 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
2814 return rc;
2815 }
2816 switch (resvt) {
2817 case VT_R8:
2818 V_VT(result) = resvt;
2819 V_R8(result) = V_R8(&lv) / V_R8(&rv);
2820 rc = S_OK;
2821 break;
2822 case VT_I4:
2823 V_VT(result) = resvt;
2824 V_I4(result) = V_I4(&lv) / V_I4(&rv);
2825 rc = S_OK;
2826 break;
2827 }
2828 TRACE("returning 0x%8lx (%s%s),%g\n", rc, debugstr_VT(result),
2829 debugstr_VF(result), V_VT(result) == VT_R8 ? V_R8(result) : (double)V_I4(result));
2830 return rc;
2831 }
2832
2833 /**********************************************************************
2834 * VarSub [OLEAUT32.159]
2835 *
2836 */
2837 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2838 {
2839 HRESULT rc = E_FAIL;
2840 VARTYPE lvt,rvt,resvt;
2841 VARIANT lv,rv;
2842 BOOL found;
2843
2844 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2845 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2846
2847 VariantInit(&lv);VariantInit(&rv);
2848 lvt = V_VT(left)&VT_TYPEMASK;
2849 rvt = V_VT(right)&VT_TYPEMASK;
2850 found = FALSE;resvt = VT_VOID;
2851 if (((1<<lvt) | (1<<rvt)) & ((1<<VT_DATE)|(1<<VT_R4)|(1<<VT_R8))) {
2852 found = TRUE;
2853 resvt = VT_R8;
2854 }
2855 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)))) {
2856 found = TRUE;
2857 resvt = VT_I4;
2858 }
2859 if (!found) {
2860 FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
2861 return E_FAIL;
2862 }
2863 rc = VariantChangeType(&lv, left, 0, resvt);
2864 if (FAILED(rc)) {
2865 FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
2866 return rc;
2867 }
2868 rc = VariantChangeType(&rv, right, 0, resvt);
2869 if (FAILED(rc)) {
2870 FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
2871 return rc;
2872 }
2873 switch (resvt) {
2874 case VT_R8:
2875 V_VT(result) = resvt;
2876 V_R8(result) = V_R8(&lv) - V_R8(&rv);
2877 rc = S_OK;
2878 break;
2879 case VT_I4:
2880 V_VT(result) = resvt;
2881 V_I4(result) = V_I4(&lv) - V_I4(&rv);
2882 rc = S_OK;
2883 break;
2884 }
2885 TRACE("returning 0x%8lx (%s%s),%g\n", rc, debugstr_VT(result),
2886 debugstr_VF(result), V_VT(result) == VT_R8 ? V_R8(result) : (double)V_I4(result));
2887 return rc;
2888 }
2889
2890 /**********************************************************************
2891 * VarOr [OLEAUT32.157]
2892 *
2893 */
2894 HRESULT WINAPI VarOr(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2895 {
2896 HRESULT rc = E_FAIL;
2897
2898 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
2899 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
2900
2901 if ((V_VT(left)&VT_TYPEMASK) == VT_BOOL &&
2902 (V_VT(right)&VT_TYPEMASK) == VT_BOOL) {
2903
2904 V_VT(result) = VT_BOOL;
2905 if (V_BOOL(left) || V_BOOL(right)) {
2906 V_BOOL(result) = VARIANT_TRUE;
2907 } else {
2908 V_BOOL(result) = VARIANT_FALSE;
2909 }
2910 rc = S_OK;
2911
2912 } else {
2913 /* Integers */
2914 BOOL lOk = TRUE;
2915 BOOL rOk = TRUE;
2916 LONGLONG lVal = -1;
2917 LONGLONG rVal = -1;
2918 LONGLONG res = -1;
2919 int resT = 0; /* Testing has shown I2 & I2 == I2, all else
2920 becomes I4, even unsigned ints (incl. UI2) */
2921
2922 lOk = TRUE;
2923 switch (V_VT(left)&VT_TYPEMASK) {
2924 case VT_I1 : lVal = V_UNION(left,cVal); resT=VT_I4; break;
2925 case VT_I2 : lVal = V_UNION(left,iVal); resT=VT_I2; break;
2926 case VT_I4 : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2927 case VT_INT : lVal = V_UNION(left,lVal); resT=VT_I4; break;
2928 case VT_UI1 : lVal = V_UNION(left,bVal); resT=VT_I4; break;
2929 case VT_UI2 : lVal = V_UNION(left,uiVal); resT=VT_I4; break;
2930 case VT_UI4 : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2931 case VT_UINT : lVal = V_UNION(left,ulVal); resT=VT_I4; break;
2932 case VT_BOOL : lVal = V_UNION(left,boolVal); resT=VT_I4; break;
2933 default: lOk = FALSE;
2934 }
2935
2936 rOk = TRUE;
2937 switch (V_VT(right)&VT_TYPEMASK) {
2938 case VT_I1 : rVal = V_UNION(right,cVal); resT=VT_I4; break;
2939 case VT_I2 : rVal = V_UNION(right,iVal); resT=max(VT_I2, resT); break;
2940 case VT_I4 : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2941 case VT_INT : rVal = V_UNION(right,lVal); resT=VT_I4; break;
2942 case VT_UI1 : rVal = V_UNION(right,bVal); resT=VT_I4; break;
2943 case VT_UI2 : rVal = V_UNION(right,uiVal); resT=VT_I4; break;
2944 case VT_UI4 : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2945 case VT_UINT : rVal = V_UNION(right,ulVal); resT=VT_I4; break;
2946 case VT_BOOL : rVal = V_UNION(right,boolVal); resT=VT_I4; break;
2947 default: rOk = FALSE;
2948 }
2949
2950 if (lOk && rOk) {
2951 res = (lVal | rVal);
2952 V_VT(result) = resT;
2953 switch (resT) {
2954 case VT_I2 : V_UNION(result,iVal) = res; break;
2955 case VT_I4 : V_UNION(result,lVal) = res; break;
2956 default:
2957 FIXME("Unexpected result variant type %x\n", resT);
2958 V_UNION(result,lVal) = res;
2959 }
2960 rc = S_OK;
2961
2962 } else {
2963 FIXME("unimplemented part, V_VT(left) == 0x%X, V_VT(right) == 0x%X\n",
2964 V_VT(left) & VT_TYPEMASK, V_VT(right) & VT_TYPEMASK);
2965 }
2966 }
2967
2968 TRACE("returning 0x%8lx (%s%s),%ld\n", rc, debugstr_VT(result),
2969 debugstr_VF(result), V_VT(result) == VT_I4 ? V_I4(result) : V_I2(result));
2970 return rc;
2971 }
2972
2973 /**********************************************************************
2974 * VarAbs [OLEAUT32.168]
2975 *
2976 * Convert a variant to its absolute value.
2977 *
2978 * PARAMS
2979 * pVarIn [I] Source variant
2980 * pVarOut [O] Destination for converted value
2981 *
2982 * RETURNS
2983 * Success: S_OK. pVarOut contains the absolute value of pVarIn.
2984 * Failure: An HRESULT error code indicating the error.
2985 *
2986 * NOTES
2987 * - This function does not process by-reference variants.
2988 * - The type of the value stored in pVarOut depends on the type of pVarIn,
2989 * according to the following table:
2990 *| Input Type Output Type
2991 *| ---------- -----------
2992 *| VT_BOOL VT_I2
2993 *| VT_BSTR VT_R8
2994 *| (All others) Unchanged
2995 */
2996 HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
2997 {
2998 VARIANT varIn;
2999 HRESULT hRet = S_OK;
3000
3001 TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
3002 debugstr_VF(pVarIn), pVarOut);
3003
3004 if (V_ISARRAY(pVarIn) || V_VT(pVarIn) == VT_UNKNOWN ||
3005 V_VT(pVarIn) == VT_DISPATCH || V_VT(pVarIn) == VT_RECORD ||
3006 V_VT(pVarIn) == VT_ERROR)
3007 return DISP_E_TYPEMISMATCH;
3008
3009 *pVarOut = *pVarIn; /* Shallow copy the value, and invert it if needed */
3010
3011 #define ABS_CASE(typ,min) \
3012 case VT_##typ: if (V_##typ(pVarIn) == min) hRet = DISP_E_OVERFLOW; \
3013 else if (V_##typ(pVarIn) < 0) V_##typ(pVarOut) = -V_##typ(pVarIn); \
3014 break
3015
3016 switch (V_VT(pVarIn))
3017 {
3018 ABS_CASE(I1,I1_MIN);
3019 case VT_BOOL:
3020 V_VT(pVarOut) = VT_I2;
3021 /* BOOL->I2, Fall through ... */
3022 ABS_CASE(I2,I2_MIN);
3023 case VT_INT:
3024 ABS_CASE(I4,I4_MIN);
3025 ABS_CASE(I8,I8_MIN);
3026 ABS_CASE(R4,R4_MIN);
3027 case VT_BSTR:
3028 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
3029 if (FAILED(hRet))
3030 break;
3031 V_VT(pVarOut) = VT_R8;
3032 pVarIn = &varIn;
3033 /* Fall through ... */
3034 case VT_DATE:
3035 ABS_CASE(R8,R8_MIN);
3036 case VT_CY:
3037 hRet = VarCyAbs(V_CY(pVarIn), & V_CY(pVarOut));
3038 break;
3039 case VT_DECIMAL:
3040 DEC_SIGN(&V_DECIMAL(pVarOut)) &= ~DECIMAL_NEG;
3041 break;
3042 case VT_UI1:
3043 case VT_UI2:
3044 case VT_UINT:
3045 case VT_UI4:
3046 case VT_UI8:
3047 case VT_EMPTY:
3048 case VT_NULL:
3049 /* No-Op */
3050 break;
3051 default:
3052 hRet = DISP_E_BADVARTYPE;
3053 }
3054
3055 return hRet;
3056 }
3057
3058 /**********************************************************************
3059 * VarFix [OLEAUT32.169]
3060 *
3061 * Truncate a variants value to a whole number.
3062 *
3063 * PARAMS
3064 * pVarIn [I] Source variant
3065 * pVarOut [O] Destination for converted value
3066 *
3067 * RETURNS
3068 * Success: S_OK. pVarOut contains the converted value.
3069 * Failure: An HRESULT error code indicating the error.
3070 *
3071 * NOTES
3072 * - The type of the value stored in pVarOut depends on the type of pVarIn,
3073 * according to the following table:
3074 *| Input Type Output Type
3075 *| ---------- -----------
3076 *| VT_BOOL VT_I2
3077 *| VT_EMPTY VT_I2
3078 *| VT_BSTR VT_R8
3079 *| All Others Unchanged
3080 * - The difference between this function and VarInt() is that VarInt() rounds
3081 * negative numbers away from 0, while this function rounds them towards zero.
3082 */
3083 HRESULT WINAPI VarFix(LPVARIANT pVarIn, LPVARIANT pVarOut)
3084 {
3085 HRESULT hRet = S_OK;
3086
3087 TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
3088 debugstr_VF(pVarIn), pVarOut);
3089
3090 V_VT(pVarOut) = V_VT(pVarIn);
3091
3092 switch (V_VT(pVarIn))
3093 {
3094 case VT_UI1:
3095 V_UI1(pVarOut) = V_UI1(pVarIn);
3096 break;
3097 case VT_BOOL:
3098 V_VT(pVarOut) = VT_I2;
3099 /* Fall through */
3100 case VT_I2:
3101 V_I2(pVarOut) = V_I2(pVarIn);
3102 break;
3103 case VT_I4:
3104 V_I4(pVarOut) = V_I4(pVarIn);
3105 break;
3106 case VT_I8:
3107 V_I8(pVarOut) = V_I8(pVarIn);
3108 break;
3109 case VT_R4:
3110 if (V_R4(pVarIn) < 0.0f)
3111 V_R4(pVarOut) = (float)ceil(V_R4(pVarIn));
3112 else
3113 V_R4(pVarOut) = (float)floor(V_R4(pVarIn));
3114 break;
3115 case VT_BSTR:
3116 V_VT(pVarOut) = VT_R8;
3117 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
3118 pVarIn = pVarOut;
3119 /* Fall through */
3120 case VT_DATE:
3121 case VT_R8:
3122 if (V_R8(pVarIn) < 0.0)
3123 V_R8(pVarOut) = ceil(V_R8(pVarIn));
3124 else
3125 V_R8(pVarOut) = floor(V_R8(pVarIn));
3126 break;
3127 case VT_CY:
3128 hRet = VarCyFix(V_CY(pVarIn), &V_CY(pVarOut));
3129 break;
3130 case VT_DECIMAL:
3131 hRet = VarDecFix(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
3132 break;
3133 case VT_EMPTY:
3134 V_VT(pVarOut) = VT_I2;
3135 V_I2(pVarOut) = 0;
3136 break;
3137 case VT_NULL:
3138 /* No-Op */
3139 break;
3140 default:
3141 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
3142 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
3143 hRet = DISP_E_BADVARTYPE;
3144 else
3145 hRet = DISP_E_TYPEMISMATCH;
3146 }
3147 if (FAILED(hRet))
3148 V_VT(pVarOut) = VT_EMPTY;
3149
3150 return hRet;
3151 }
3152
3153 /**********************************************************************
3154 * VarInt [OLEAUT32.172]
3155 *
3156 * Truncate a variants value to a whole number.
3157 *
3158 * PARAMS
3159 * pVarIn [I] Source variant
3160 * pVarOut [O] Destination for converted value
3161 *
3162 * RETURNS
3163 * Success: S_OK. pVarOut contains the converted value.
3164 * Failure: An HRESULT error code indicating the error.
3165 *
3166 * NOTES
3167 * - The type of the value stored in pVarOut depends on the type of pVarIn,
3168 * according to the following table:
3169 *| Input Type Output Type
3170 *| ---------- -----------
3171 *| VT_BOOL VT_I2
3172 *| VT_EMPTY VT_I2
3173 *| VT_BSTR VT_R8
3174 *| All Others Unchanged
3175 * - The difference between this function and VarFix() is that VarFix() rounds
3176 * negative numbers towards 0, while this function rounds them away from zero.
3177 */
3178 HRESULT WINAPI VarInt(LPVARIANT pVarIn, LPVARIANT pVarOut)
3179 {
3180 HRESULT hRet = S_OK;
3181
3182 TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
3183 debugstr_VF(pVarIn), pVarOut);
3184
3185 V_VT(pVarOut) = V_VT(pVarIn);
3186
3187 switch (V_VT(pVarIn))
3188 {
3189 case VT_R4:
3190 V_R4(pVarOut) = (float)floor(V_R4(pVarIn));
3191 break;
3192 case VT_BSTR:
3193 V_VT(pVarOut) = VT_R8;
3194 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
3195 pVarIn = pVarOut;
3196 /* Fall through */
3197 case VT_DATE:
3198 case VT_R8:
3199 V_R8(pVarOut) = floor(V_R8(pVarIn));
3200 break;
3201 case VT_CY:
3202 hRet = VarCyInt(V_CY(pVarIn), &V_CY(pVarOut));
3203 break;
3204 case VT_DECIMAL:
3205 hRet = VarDecInt(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
3206 break;
3207 default:
3208 return VarFix(pVarIn, pVarOut);
3209 }
3210
3211 return hRet;
3212 }
3213
3214 /**********************************************************************
3215 * VarNeg [OLEAUT32.173]
3216 *
3217 * Negate the value of a variant.
3218 *
3219 * PARAMS
3220 * pVarIn [I] Source variant
3221 * pVarOut [O] Destination for converted value
3222 *
3223 * RETURNS
3224 * Success: S_OK. pVarOut contains the converted value.
3225 * Failure: An HRESULT error code indicating the error.
3226 *
3227 * NOTES
3228 * - The type of the value stored in pVarOut depends on the type of pVarIn,
3229 * according to the following table:
3230 *| Input Type Output Type
3231 *| ---------- -----------
3232 *| VT_EMPTY VT_I2
3233 *| VT_UI1 VT_I2
3234 *| VT_BOOL VT_I2
3235 *| VT_BSTR VT_R8
3236 *| All Others Unchanged (unless promoted)
3237 * - Where the negated value of a variant does not fit in its base type, the type
3238 * is promoted according to the following table:
3239 *| Input Type Promoted To
3240 *| ---------- -----------
3241 *| VT_I2 VT_I4
3242 *| VT_I4 VT_R8
3243 *| VT_I8 VT_R8
3244 * - The native version of this function returns DISP_E_BADVARTYPE for valid
3245 * variant types that cannot be negated, and returns DISP_E_TYPEMISMATCH
3246 * for types which are not valid. Since this is in contravention of the
3247 * meaning of those error codes and unlikely to be relied on by applications,
3248 * this implementation returns errors consistent with the other high level
3249 * variant math functions.
3250 */
3251 HRESULT WINAPI VarNeg(LPVARIANT pVarIn, LPVARIANT pVarOut)
3252 {
3253 HRESULT hRet = S_OK;
3254
3255 TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
3256 debugstr_VF(pVarIn), pVarOut);
3257
3258 V_VT(pVarOut) = V_VT(pVarIn);
3259
3260 switch (V_VT(pVarIn))
3261 {
3262 case VT_UI1:
3263 V_VT(pVarOut) = VT_I2;
3264 V_I2(pVarOut) = -V_UI1(pVarIn);
3265 break;
3266 case VT_BOOL:
3267 V_VT(pVarOut) = VT_I2;
3268 /* Fall through */
3269 case VT_I2:
3270 if (V_I2(pVarIn) == I2_MIN)
3271 {
3272 V_VT(pVarOut) = VT_I4;
3273 V_I4(pVarOut) = -(int)V_I2(pVarIn);
3274 }
3275 else
3276 V_I2(pVarOut) = -V_I2(pVarIn);
3277 break;
3278 case VT_I4:
3279 if (V_I4(pVarIn) == I4_MIN)
3280 {
3281 V_VT(pVarOut) = VT_R8;
3282 V_R8(pVarOut) = -(double)V_I4(pVarIn);
3283 }
3284 else
3285 V_I4(pVarOut) = -V_I4(pVarIn);
3286 break;
3287 case VT_I8:
3288 if (V_I8(pVarIn) == I8_MIN)
3289 {
3290 V_VT(pVarOut) = VT_R8;
3291 hRet = VarR8FromI8(V_I8(pVarIn), &V_R8(pVarOut));
3292 V_R8(pVarOut) *= -1.0;
3293 }
3294 else
3295 V_I8(pVarOut) = -V_I8(pVarIn);
3296 break;
3297 case VT_R4:
3298 V_R4(pVarOut) = -V_R4(pVarIn);
3299 break;
3300 case VT_DATE:
3301 case VT_R8:
3302 V_R8(pVarOut) = -V_R8(pVarIn);
3303 break;
3304 case VT_CY:
3305 hRet = VarCyNeg(V_CY(pVarIn), &V_CY(pVarOut));
3306 break;
3307 case VT_DECIMAL:
3308 hRet = VarDecNeg(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
3309 break;
3310 case VT_BSTR:
3311 V_VT(pVarOut) = VT_R8;
3312 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
3313 V_R8(pVarOut) = -V_R8(pVarOut);
3314 break;
3315 case VT_EMPTY:
3316 V_VT(pVarOut) = VT_I2;
3317 V_I2(pVarOut) = 0;
3318 break;
3319 case VT_NULL:
3320 /* No-Op */
3321 break;
3322 default:
3323 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
3324 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
3325 hRet = DISP_E_BADVARTYPE;
3326 else
3327 hRet = DISP_E_TYPEMISMATCH;
3328 }
3329 if (FAILED(hRet))
3330 V_VT(pVarOut) = VT_EMPTY;
3331
3332 return hRet;
3333 }
3334
3335 /**********************************************************************
3336 * VarNot [OLEAUT32.174]
3337 *
3338 * Perform a not operation on a variant.
3339 *
3340 * PARAMS
3341 * pVarIn [I] Source variant
3342 * pVarOut [O] Destination for converted value
3343 *
3344 * RETURNS
3345 * Success: S_OK. pVarOut contains the converted value.
3346 * Failure: An HRESULT error code indicating the error.
3347 *
3348 * NOTES
3349 * - Strictly speaking, this function performs a bitwise ones compliment
3350 * on the variants value (after possibly converting to VT_I4, see below).
3351 * This only behaves like a boolean not operation if the value in
3352 * pVarIn is either VARIANT_TRUE or VARIANT_FALSE and the type is signed.
3353 * - To perform a genuine not operation, convert the variant to a VT_BOOL
3354 * before calling this function.
3355 * - This function does not process by-reference variants.
3356 * - The type of the value stored in pVarOut depends on the type of pVarIn,
3357 * according to the following table:
3358 *| Input Type Output Type
3359 *| ---------- -----------
3360 *| VT_R4 VT_I4
3361 *| VT_R8 VT_I4
3362 *| VT_BSTR VT_I4
3363 *| VT_DECIMAL VT_I4
3364 *| VT_CY VT_I4
3365 *| (All others) Unchanged
3366 */
3367 HRESULT WINAPI VarNot(LPVARIANT pVarIn, LPVARIANT pVarOut)
3368 {
3369 VARIANT varIn;
3370 HRESULT hRet = S_OK;
3371
3372 TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
3373 debugstr_VF(pVarIn), pVarOut);
3374
3375 V_VT(pVarOut) = V_VT(pVarIn);
3376
3377 switch (V_VT(pVarIn))
3378 {
3379 case VT_I1: V_I1(pVarOut) = ~V_I1(pVarIn); break;
3380 case VT_UI1: V_UI1(pVarOut) = ~V_UI1(pVarIn); break;
3381 case VT_BOOL:
3382 case VT_I2: V_I2(pVarOut) = ~V_I2(pVarIn); break;
3383 case VT_UI2: V_UI2(pVarOut) = ~V_UI2(pVarIn); break;
3384 case VT_DECIMAL:
3385 hRet = VarI4FromDec(&V_DECIMAL(pVarIn), &V_I4(&varIn));
3386 if (FAILED(hRet))
3387 break;
3388 pVarIn = &varIn;
3389 V_VT(pVarOut) = VT_I4;
3390 /* Fall through ... */
3391 case VT_INT:
3392 case VT_I4: V_I4(pVarOut) = ~V_I4(pVarIn); break;
3393 case VT_UINT:
3394 case VT_UI4: V_UI4(pVarOut) = ~V_UI4(pVarIn); break;
3395 case VT_I8: V_I8(pVarOut) = ~V_I8(pVarIn); break;
3396 case VT_UI8: V_UI8(pVarOut) = ~V_UI8(pVarIn); break;
3397 case VT_R4:
3398 hRet = VarI4FromR4(V_R4(pVarIn), &V_I4(pVarOut));
3399 V_I4(pVarOut) = ~V_I4(pVarOut);
3400 V_VT(pVarOut) = VT_I4;
3401 break;
3402 case VT_BSTR:
3403 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
3404 if (FAILED(hRet))
3405 break;
3406 pVarIn = &varIn;
3407 /* Fall through ... */
3408 case VT_DATE:
3409 case VT_R8:
3410 hRet = VarI4FromR8(V_R8(pVarIn), &V_I4(pVarOut));
3411 V_I4(pVarOut) = ~V_I4(pVarOut);
3412 V_VT(pVarOut) = VT_I4;
3413 break;
3414 case VT_CY:
3415 hRet = VarI4FromCy(V_CY(pVarIn), &V_I4(pVarOut));
3416 V_I4(pVarOut) = ~V_I4(pVarOut);
3417 V_VT(pVarOut) = VT_I4;
3418 break;
3419 case VT_EMPTY:
3420 case VT_NULL:
3421 /* No-Op */
3422 break;
3423 default:
3424 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
3425 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
3426 hRet = DISP_E_BADVARTYPE;
3427 else
3428 hRet = DISP_E_TYPEMISMATCH;
3429 }
3430 if (FAILED(hRet))
3431 V_VT(pVarOut) = VT_EMPTY;
3432
3433 return hRet;
3434 }
3435
3436 /**********************************************************************
3437 * VarRound [OLEAUT32.175]
3438 *
3439 * Perform a round operation on a variant.
3440 *
3441 * PARAMS
3442 * pVarIn [I] Source variant
3443 * deci [I] Number of decimals to round to
3444 * pVarOut [O] Destination for converted value
3445 *
3446 * RETURNS
3447 * Success: S_OK. pVarOut contains the converted value.
3448 * Failure: An HRESULT error code indicating the error.
3449 *
3450 * NOTES
3451 * - Floating point values are rounded to the desired number of decimals.
3452 * - Some integer types are just copied to the return variable.
3453 * - Some other integer types are not handled and fail.
3454 */
3455 HRESULT WINAPI VarRound(LPVARIANT pVarIn, int deci, LPVARIANT pVarOut)
3456 {
3457 VARIANT varIn;
3458 HRESULT hRet = S_OK;
3459 float factor;
3460
3461 TRACE("(%p->(%s%s),%d)\n", pVarIn, debugstr_VT(pVarIn), debugstr_VF(pVarIn), deci);
3462
3463 switch (V_VT(pVarIn))
3464 {
3465 /* cases that fail on windows */
3466 case VT_I1:
3467 case VT_I8:
3468 case VT_UI2:
3469 case VT_UI4:
3470 hRet = DISP_E_BADVARTYPE;
3471 break;
3472
3473 /* cases just copying in to out */
3474 case VT_UI1:
3475 V_VT(pVarOut) = V_VT(pVarIn);
3476 V_UI1(pVarOut) = V_UI1(pVarIn);
3477 break;
3478 case VT_I2:
3479 V_VT(pVarOut) = V_VT(pVarIn);
3480 V_I2(pVarOut) = V_I2(pVarIn);
3481 break;
3482 case VT_I4:
3483 V_VT(pVarOut) = V_VT(pVarIn);
3484 V_I4(pVarOut) = V_I4(pVarIn);
3485 break;
3486 case VT_NULL:
3487 V_VT(pVarOut) = V_VT(pVarIn);
3488 /* value unchanged */
3489 break;
3490
3491 /* cases that change type */
3492 case VT_EMPTY:
3493 V_VT(pVarOut) = VT_I2;
3494 V_I2(pVarOut) = 0;
3495 break;
3496 case VT_BOOL:
3497 V_VT(pVarOut) = VT_I2;
3498 V_I2(pVarOut) = V_BOOL(pVarIn);
3499 break;
3500 case VT_BSTR:
3501 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
3502 if (FAILED(hRet))
3503 break;
3504 V_VT(&varIn)=VT_R8;
3505 pVarIn = &varIn;
3506 /* Fall through ... */
3507
3508 /* cases we need to do math */
3509 case VT_R8:
3510 if (V_R8(pVarIn)>0) {
3511 V_R8(pVarOut)=floor(V_R8(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
3512 } else {
3513 V_R8(pVarOut)=ceil(V_R8(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
3514 }
3515 V_VT(pVarOut) = V_VT(pVarIn);
3516 break;
3517 case VT_R4:
3518 if (V_R4(pVarIn)>0) {
3519 V_R4(pVarOut)=floor(V_R4(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
3520 } else {
3521 V_R4(pVarOut)=ceil(V_R4(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
3522 }
3523 V_VT(pVarOut) = V_VT(pVarIn);
3524 break;
3525 case VT_DATE:
3526 if (V_DATE(pVarIn)>0) {
3527 V_DATE(pVarOut)=floor(V_DATE(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
3528 } else {
3529 V_DATE(pVarOut)=ceil(V_DATE(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
3530 }
3531 V_VT(pVarOut) = V_VT(pVarIn);
3532 break;
3533 case VT_CY:
3534 if (deci>3)
3535 factor=1;
3536 else
3537 factor=pow(10, 4-deci);
3538
3539 if (V_CY(pVarIn).int64>0) {
3540 V_CY(pVarOut).int64=floor(V_CY(pVarIn).int64/factor)*factor;
3541 } else {
3542 V_CY(pVarOut).int64=ceil(V_CY(pVarIn).int64/factor)*factor;
3543 }
3544 V_VT(pVarOut) = V_VT(pVarIn);
3545 break;
3546
3547 /* cases we don't know yet */
3548 default:
3549 FIXME("unimplemented part, V_VT(pVarIn) == 0x%X, deci == %d\n",
3550 V_VT(pVarIn) & VT_TYPEMASK, deci);
3551 hRet = DISP_E_BADVARTYPE;
3552 }
3553
3554 if (FAILED(hRet))
3555 V_VT(pVarOut) = VT_EMPTY;
3556
3557 TRACE("returning 0x%08lx (%s%s),%f\n", hRet, debugstr_VT(pVarOut),
3558 debugstr_VF(pVarOut), (V_VT(pVarOut) == VT_R4) ? V_R4(pVarOut) :
3559 (V_VT(pVarOut) == VT_R8) ? V_R8(pVarOut) : 0);
3560
3561 return hRet;
3562 }
3563
3564
3565 /**********************************************************************
3566 * VarMod [OLEAUT32.154]
3567 *
3568 * Perform the modulus operation of the right hand variant on the left
3569 *
3570 * PARAMS
3571 * left [I] Left hand variant
3572 * right [I] Right hand variant
3573 * result [O] Destination for converted value
3574 *
3575 * RETURNS
3576 * Success: S_OK. result contains the remainder.
3577 * Failure: An HRESULT error code indicating the error.
3578 *
3579 * NOTE:
3580 * If an error occurs the type of result will be modified but the value will not be.
3581 * Doesn't support arrays or any special flags yet.
3582 */
3583 HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3584 {
3585 BOOL lOk = TRUE;
3586 BOOL rOk = TRUE;
3587 HRESULT rc = E_FAIL;
3588 int resT = 0;
3589 VARIANT lv,rv;
3590
3591 VariantInit(&lv);
3592 VariantInit(&rv);
3593
3594 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
3595 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
3596
3597 /* check for invalid inputs */
3598 lOk = TRUE;
3599 switch (V_VT(left) & VT_TYPEMASK) {
3600 case VT_BOOL :
3601 case VT_I1 :
3602 case VT_I2 :
3603 case VT_I4 :
3604 case VT_I8 :
3605 case VT_INT :
3606 case VT_UI1 :
3607 case VT_UI2 :
3608 case VT_UI4 :
3609 case VT_UI8 :
3610 case VT_UINT :
3611 case VT_R4 :
3612 case VT_R8 :
3613 case VT_CY :
3614 case VT_EMPTY:
3615 case VT_DATE :
3616 case VT_BSTR :
3617 break;
3618 case VT_VARIANT:
3619 case VT_UNKNOWN:
3620 V_VT(result) = VT_EMPTY;
3621 return DISP_E_TYPEMISMATCH;
3622 case VT_DECIMAL:
3623 V_VT(result) = VT_EMPTY;
3624 return E_INVALIDARG;
3625 case VT_ERROR:
3626 return DISP_E_TYPEMISMATCH;
3627 case VT_RECORD:
3628 V_VT(result) = VT_EMPTY;
3629 return DISP_E_TYPEMISMATCH;
3630 case VT_NULL:
3631 break;
3632 default:
3633 V_VT(result) = VT_EMPTY;
3634 return DISP_E_BADVARTYPE;
3635 }
3636
3637
3638 rOk = TRUE;
3639 switch (V_VT(right) & VT_TYPEMASK) {
3640 case VT_BOOL :
3641 case VT_I1 :
3642 case VT_I2 :
3643 case VT_I4 :
3644 case VT_I8 :
3645 if((V_VT(left) == VT_INT) && (V_VT(right) == VT_I8))
3646 {
3647 V_VT(result) = VT_EMPTY;
3648 return DISP_E_TYPEMISMATCH;
3649 }
3650 case VT_INT :
3651 if((V_VT(right) == VT_INT) && (V_VT(left) == VT_I8))
3652 {
3653 V_VT(result) = VT_EMPTY;
3654 return DISP_E_TYPEMISMATCH;
3655 }
3656 case VT_UI1 :
3657 case VT_UI2 :
3658 case VT_UI4 :
3659 case VT_UI8 :
3660 case VT_UINT :
3661 case VT_R4 :
3662 case VT_R8 :
3663 case VT_CY :
3664 if(V_VT(left) == VT_EMPTY)
3665 {
3666 V_VT(result) = VT_I4;
3667 return S_OK;
3668 }
3669 case VT_EMPTY:
3670 case VT_DATE :
3671 case VT_BSTR:
3672 if(V_VT(left) == VT_NULL)
3673 {
3674 V_VT(result) = VT_NULL;
3675 return S_OK;
3676 }
3677 break;
3678
3679 case VT_VOID:
3680 V_VT(result) = VT_EMPTY;
3681 return DISP_E_BADVARTYPE;
3682 case VT_NULL:
3683 if(V_VT(left) == VT_VOID)
3684 {
3685 V_VT(result) = VT_EMPTY;
3686 return DISP_E_BADVARTYPE;
3687 } else if((V_VT(left) == VT_NULL) || (V_VT(left) == VT_EMPTY) || (V_VT(left) == VT_ERROR) ||
3688 lOk)
3689 {
3690 V_VT(result) = VT_NULL;
3691 return S_OK;
3692 } else
3693 {
3694 V_VT(result) = VT_NULL;
3695 return DISP_E_BADVARTYPE;
3696 }
3697 case VT_VARIANT:
3698 case VT_UNKNOWN:
3699 V_VT(result) = VT_EMPTY;
3700 return DISP_E_TYPEMISMATCH;
3701 case VT_DECIMAL:
3702 if(V_VT(left) == VT_ERROR)
3703 {
3704 V_VT(result) = VT_EMPTY;
3705 return DISP_E_TYPEMISMATCH;
3706 } else
3707 {
3708 V_VT(result) = VT_EMPTY;
3709 return E_INVALIDARG;
3710 }
3711 case VT_ERROR:
3712 return DISP_E_TYPEMISMATCH;
3713 case VT_RECORD:
3714 if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)) || !lOk)
3715 {
3716 V_VT(result) = VT_EMPTY;
3717 return DISP_E_BADVARTYPE;
3718 } else
3719 {
3720 V_VT(result) = VT_EMPTY;
3721 return DISP_E_TYPEMISMATCH;
3722 }
3723 default:
3724 V_VT(result) = VT_EMPTY;
3725 return DISP_E_BADVARTYPE;
3726 }
3727
3728 /* determine the result type */
3729 if((V_VT(left) == VT_I8) || (V_VT(right) == VT_I8)) resT = VT_I8;
3730 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
3731 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_UI1)) resT = VT_UI1;
3732 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_I2)) resT = VT_I2;
3733 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
3734 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_UI1)) resT = VT_I2;
3735 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_I2)) resT = VT_I2;
3736 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
3737 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_UI1)) resT = VT_I2;
3738 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_I2)) resT = VT_I2;
3739 else resT = VT_I4; /* most outputs are I4 */
3740
3741 /* convert to I8 for the modulo */
3742 rc = VariantChangeType(&lv, left, 0, VT_I8);
3743 if(FAILED(rc))
3744 {
3745 FIXME("Could not convert left type %d to %d? rc == 0x%lX\n", V_VT(left), VT_I8, rc);
3746 return rc;
3747 }
3748
3749 rc = VariantChangeType(&rv, right, 0, VT_I8);
3750 if(FAILED(rc))
3751 {
3752 FIXME("Could not convert right type %d to %d? rc == 0x%lX\n", V_VT(right), VT_I8, rc);
3753 return rc;
3754 }
3755
3756 /* if right is zero set VT_EMPTY and return divide by zero */
3757 if(V_I8(&rv) == 0)
3758 {
3759 V_VT(result) = VT_EMPTY;
3760 return DISP_E_DIVBYZERO;
3761 }
3762
3763 /* perform the modulo operation */
3764 V_VT(result) = VT_I8;
3765 V_I8(result) = V_I8(&lv) % V_I8(&rv);
3766
3767 TRACE("V_I8(left) == %ld, V_I8(right) == %ld, V_I8(result) == %ld\n", (long)V_I8(&lv), (long)V_I8(&rv), (long)V_I8(result));
3768
3769 /* convert left and right to the destination type */
3770 rc = VariantChangeType(result, result, 0, resT);
3771 if(FAILED(rc))
3772 {
3773 FIXME("Could not convert 0x%x to %d?\n", V_VT(result), resT);
3774 return rc;
3775 }
3776
3777 return S_OK;
3778 }
3779
3780 /**********************************************************************
3781 * VarPow [OLEAUT32.158]
3782 *
3783 */
3784 HRESULT WINAPI VarPow(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3785 {
3786 HRESULT hr;
3787 VARIANT dl,dr;
3788
3789 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), debugstr_VF(left),
3790 right, debugstr_VT(right), debugstr_VF(right), result);
3791
3792 hr = VariantChangeType(&dl,left,0,VT_R8);
3793 if (!SUCCEEDED(hr)) {
3794 ERR("Could not change passed left argument to VT_R8, handle it differently.\n");
3795 return E_FAIL;
3796 }
3797 hr = VariantChangeType(&dr,right,0,VT_R8);
3798 if (!SUCCEEDED(hr)) {
3799 ERR("Could not change passed right argument to VT_R8, handle it differently.\n");
3800 return E_FAIL;
3801 }
3802 V_VT(result) = VT_R8;
3803 V_R8(result) = pow(V_R8(&dl),V_R8(&dr));
3804 return S_OK;
3805 }
Quick hack tree for wine patches julliard doesn't want to commit