?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 6.15.
[wine.git] / dlls / oleaut32 / variant.c
blob40a1170e24703828281c0704b3fae575bb887d05
1 /*
2 * VARIANT
3 *
4 * Copyright 1998 Jean-Claude Cote
5 * Copyright 2003 Jon Griffiths
6 * Copyright 2005 Daniel Remenak
7 * Copyright 2006 Google (Benjamin Arai)
8 *
9 * The algorithm for conversion from Julian days to day/month/year is based on
10 * that devised by Henry Fliegel, as implemented in PostgreSQL, which is
11 * Copyright 1994-7 Regents of the University of California
12 *
13 * This library is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
17 *
18 * This library is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with this library; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 */
27
28 #include <string.h>
29 #include <stdlib.h>
30 #include <stdarg.h>
31
32 #define COBJMACROS
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
35
36 #include "windef.h"
37 #include "winbase.h"
38 #include "winerror.h"
39 #include "variant.h"
40 #include "resource.h"
41 #include "wine/debug.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(variant);
44
45
46 /* Convert a variant from one type to another */
47 static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags,
48 VARIANTARG* ps, VARTYPE vt)
49 {
50 HRESULT res = DISP_E_TYPEMISMATCH;
51 VARTYPE vtFrom = V_TYPE(ps);
52 DWORD dwFlags = 0;
53
54 TRACE("(%s,0x%08x,0x%04x,%s,%s)\n", debugstr_variant(pd), lcid, wFlags,
55 debugstr_variant(ps), debugstr_vt(vt));
56
57 if (vt == VT_BSTR || vtFrom == VT_BSTR)
58 {
59 /* All flags passed to low level function are only used for
60 * changing to or from strings. Map these here.
61 */
62 if (wFlags & VARIANT_LOCALBOOL)
63 dwFlags |= VAR_LOCALBOOL;
64 if (wFlags & VARIANT_CALENDAR_HIJRI)
65 dwFlags |= VAR_CALENDAR_HIJRI;
66 if (wFlags & VARIANT_CALENDAR_THAI)
67 dwFlags |= VAR_CALENDAR_THAI;
68 if (wFlags & VARIANT_CALENDAR_GREGORIAN)
69 dwFlags |= VAR_CALENDAR_GREGORIAN;
70 if (wFlags & VARIANT_NOUSEROVERRIDE)
71 dwFlags |= LOCALE_NOUSEROVERRIDE;
72 if (wFlags & VARIANT_USE_NLS)
73 dwFlags |= LOCALE_USE_NLS;
74 }
75
76 /* Map int/uint to i4/ui4 */
77 if (vt == VT_INT)
78 vt = VT_I4;
79 else if (vt == VT_UINT)
80 vt = VT_UI4;
81
82 if (vtFrom == VT_INT)
83 vtFrom = VT_I4;
84 else if (vtFrom == VT_UINT)
85 vtFrom = VT_UI4;
86
87 if (vt == vtFrom)
88 return VariantCopy(pd, ps);
89
90 if (wFlags & VARIANT_NOVALUEPROP && vtFrom == VT_DISPATCH && vt != VT_UNKNOWN)
91 {
92 /* VARIANT_NOVALUEPROP prevents IDispatch objects from being coerced by
93 * accessing the default object property.
94 */
95 return DISP_E_TYPEMISMATCH;
96 }
97
98 switch (vt)
99 {
100 case VT_EMPTY:
101 if (vtFrom == VT_NULL)
102 return DISP_E_TYPEMISMATCH;
103 /* ... Fall through */
104 case VT_NULL:
105 if (vtFrom <= VT_UINT && vtFrom != (VARTYPE)15 && vtFrom != VT_ERROR)
106 {
107 res = VariantClear( pd );
108 if (vt == VT_NULL && SUCCEEDED(res))
109 V_VT(pd) = VT_NULL;
110 }
111 return res;
112
113 case VT_I1:
114 switch (vtFrom)
115 {
116 case VT_EMPTY: V_I1(pd) = 0; return S_OK;
117 case VT_I2: return VarI1FromI2(V_I2(ps), &V_I1(pd));
118 case VT_I4: return VarI1FromI4(V_I4(ps), &V_I1(pd));
119 case VT_UI1: V_I1(pd) = V_UI1(ps); return S_OK;
120 case VT_UI2: return VarI1FromUI2(V_UI2(ps), &V_I1(pd));
121 case VT_UI4: return VarI1FromUI4(V_UI4(ps), &V_I1(pd));
122 case VT_I8: return VarI1FromI8(V_I8(ps), &V_I1(pd));
123 case VT_UI8: return VarI1FromUI8(V_UI8(ps), &V_I1(pd));
124 case VT_R4: return VarI1FromR4(V_R4(ps), &V_I1(pd));
125 case VT_R8: return VarI1FromR8(V_R8(ps), &V_I1(pd));
126 case VT_DATE: return VarI1FromDate(V_DATE(ps), &V_I1(pd));
127 case VT_BOOL: return VarI1FromBool(V_BOOL(ps), &V_I1(pd));
128 case VT_CY: return VarI1FromCy(V_CY(ps), &V_I1(pd));
129 case VT_DECIMAL: return VarI1FromDec(&V_DECIMAL(ps), &V_I1(pd) );
130 case VT_DISPATCH: return VarI1FromDisp(V_DISPATCH(ps), lcid, &V_I1(pd) );
131 case VT_BSTR: return VarI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_I1(pd) );
132 }
133 break;
134
135 case VT_I2:
136 switch (vtFrom)
137 {
138 case VT_EMPTY: V_I2(pd) = 0; return S_OK;
139 case VT_I1: return VarI2FromI1(V_I1(ps), &V_I2(pd));
140 case VT_I4: return VarI2FromI4(V_I4(ps), &V_I2(pd));
141 case VT_UI1: return VarI2FromUI1(V_UI1(ps), &V_I2(pd));
142 case VT_UI2: V_I2(pd) = V_UI2(ps); return S_OK;
143 case VT_UI4: return VarI2FromUI4(V_UI4(ps), &V_I2(pd));
144 case VT_I8: return VarI2FromI8(V_I8(ps), &V_I2(pd));
145 case VT_UI8: return VarI2FromUI8(V_UI8(ps), &V_I2(pd));
146 case VT_R4: return VarI2FromR4(V_R4(ps), &V_I2(pd));
147 case VT_R8: return VarI2FromR8(V_R8(ps), &V_I2(pd));
148 case VT_DATE: return VarI2FromDate(V_DATE(ps), &V_I2(pd));
149 case VT_BOOL: return VarI2FromBool(V_BOOL(ps), &V_I2(pd));
150 case VT_CY: return VarI2FromCy(V_CY(ps), &V_I2(pd));
151 case VT_DECIMAL: return VarI2FromDec(&V_DECIMAL(ps), &V_I2(pd));
152 case VT_DISPATCH: return VarI2FromDisp(V_DISPATCH(ps), lcid, &V_I2(pd));
153 case VT_BSTR: return VarI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_I2(pd));
154 }
155 break;
156
157 case VT_I4:
158 switch (vtFrom)
159 {
160 case VT_EMPTY: V_I4(pd) = 0; return S_OK;
161 case VT_I1: return VarI4FromI1(V_I1(ps), &V_I4(pd));
162 case VT_I2: return VarI4FromI2(V_I2(ps), &V_I4(pd));
163 case VT_UI1: return VarI4FromUI1(V_UI1(ps), &V_I4(pd));
164 case VT_UI2: return VarI4FromUI2(V_UI2(ps), &V_I4(pd));
165 case VT_UI4: V_I4(pd) = V_UI4(ps); return S_OK;
166 case VT_I8: return VarI4FromI8(V_I8(ps), &V_I4(pd));
167 case VT_UI8: return VarI4FromUI8(V_UI8(ps), &V_I4(pd));
168 case VT_R4: return VarI4FromR4(V_R4(ps), &V_I4(pd));
169 case VT_R8: return VarI4FromR8(V_R8(ps), &V_I4(pd));
170 case VT_DATE: return VarI4FromDate(V_DATE(ps), &V_I4(pd));
171 case VT_BOOL: return VarI4FromBool(V_BOOL(ps), &V_I4(pd));
172 case VT_CY: return VarI4FromCy(V_CY(ps), &V_I4(pd));
173 case VT_DECIMAL: return VarI4FromDec(&V_DECIMAL(ps), &V_I4(pd));
174 case VT_DISPATCH: return VarI4FromDisp(V_DISPATCH(ps), lcid, &V_I4(pd));
175 case VT_BSTR: return VarI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_I4(pd));
176 }
177 break;
178
179 case VT_UI1:
180 switch (vtFrom)
181 {
182 case VT_EMPTY: V_UI1(pd) = 0; return S_OK;
183 case VT_I1: V_UI1(pd) = V_I1(ps); return S_OK;
184 case VT_I2: return VarUI1FromI2(V_I2(ps), &V_UI1(pd));
185 case VT_I4: return VarUI1FromI4(V_I4(ps), &V_UI1(pd));
186 case VT_UI2: return VarUI1FromUI2(V_UI2(ps), &V_UI1(pd));
187 case VT_UI4: return VarUI1FromUI4(V_UI4(ps), &V_UI1(pd));
188 case VT_I8: return VarUI1FromI8(V_I8(ps), &V_UI1(pd));
189 case VT_UI8: return VarUI1FromUI8(V_UI8(ps), &V_UI1(pd));
190 case VT_R4: return VarUI1FromR4(V_R4(ps), &V_UI1(pd));
191 case VT_R8: return VarUI1FromR8(V_R8(ps), &V_UI1(pd));
192 case VT_DATE: return VarUI1FromDate(V_DATE(ps), &V_UI1(pd));
193 case VT_BOOL: return VarUI1FromBool(V_BOOL(ps), &V_UI1(pd));
194 case VT_CY: return VarUI1FromCy(V_CY(ps), &V_UI1(pd));
195 case VT_DECIMAL: return VarUI1FromDec(&V_DECIMAL(ps), &V_UI1(pd));
196 case VT_DISPATCH: return VarUI1FromDisp(V_DISPATCH(ps), lcid, &V_UI1(pd));
197 case VT_BSTR: return VarUI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI1(pd));
198 }
199 break;
200
201 case VT_UI2:
202 switch (vtFrom)
203 {
204 case VT_EMPTY: V_UI2(pd) = 0; return S_OK;
205 case VT_I1: return VarUI2FromI1(V_I1(ps), &V_UI2(pd));
206 case VT_I2: V_UI2(pd) = V_I2(ps); return S_OK;
207 case VT_I4: return VarUI2FromI4(V_I4(ps), &V_UI2(pd));
208 case VT_UI1: return VarUI2FromUI1(V_UI1(ps), &V_UI2(pd));
209 case VT_UI4: return VarUI2FromUI4(V_UI4(ps), &V_UI2(pd));
210 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
211 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
212 case VT_R4: return VarUI2FromR4(V_R4(ps), &V_UI2(pd));
213 case VT_R8: return VarUI2FromR8(V_R8(ps), &V_UI2(pd));
214 case VT_DATE: return VarUI2FromDate(V_DATE(ps), &V_UI2(pd));
215 case VT_BOOL: return VarUI2FromBool(V_BOOL(ps), &V_UI2(pd));
216 case VT_CY: return VarUI2FromCy(V_CY(ps), &V_UI2(pd));
217 case VT_DECIMAL: return VarUI2FromDec(&V_DECIMAL(ps), &V_UI2(pd));
218 case VT_DISPATCH: return VarUI2FromDisp(V_DISPATCH(ps), lcid, &V_UI2(pd));
219 case VT_BSTR: return VarUI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI2(pd));
220 }
221 break;
222
223 case VT_UI4:
224 switch (vtFrom)
225 {
226 case VT_EMPTY: V_UI4(pd) = 0; return S_OK;
227 case VT_I1: return VarUI4FromI1(V_I1(ps), &V_UI4(pd));
228 case VT_I2: return VarUI4FromI2(V_I2(ps), &V_UI4(pd));
229 case VT_I4: V_UI4(pd) = V_I4(ps); return S_OK;
230 case VT_UI1: return VarUI4FromUI1(V_UI1(ps), &V_UI4(pd));
231 case VT_UI2: return VarUI4FromUI2(V_UI2(ps), &V_UI4(pd));
232 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
233 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
234 case VT_R4: return VarUI4FromR4(V_R4(ps), &V_UI4(pd));
235 case VT_R8: return VarUI4FromR8(V_R8(ps), &V_UI4(pd));
236 case VT_DATE: return VarUI4FromDate(V_DATE(ps), &V_UI4(pd));
237 case VT_BOOL: return VarUI4FromBool(V_BOOL(ps), &V_UI4(pd));
238 case VT_CY: return VarUI4FromCy(V_CY(ps), &V_UI4(pd));
239 case VT_DECIMAL: return VarUI4FromDec(&V_DECIMAL(ps), &V_UI4(pd));
240 case VT_DISPATCH: return VarUI4FromDisp(V_DISPATCH(ps), lcid, &V_UI4(pd));
241 case VT_BSTR: return VarUI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI4(pd));
242 }
243 break;
244
245 case VT_UI8:
246 switch (vtFrom)
247 {
248 case VT_EMPTY: V_UI8(pd) = 0; return S_OK;
249 case VT_I4: if (V_I4(ps) < 0) return DISP_E_OVERFLOW; V_UI8(pd) = V_I4(ps); return S_OK;
250 case VT_I1: return VarUI8FromI1(V_I1(ps), &V_UI8(pd));
251 case VT_I2: return VarUI8FromI2(V_I2(ps), &V_UI8(pd));
252 case VT_UI1: return VarUI8FromUI1(V_UI1(ps), &V_UI8(pd));
253 case VT_UI2: return VarUI8FromUI2(V_UI2(ps), &V_UI8(pd));
254 case VT_UI4: return VarUI8FromUI4(V_UI4(ps), &V_UI8(pd));
255 case VT_I8: V_UI8(pd) = V_I8(ps); return S_OK;
256 case VT_R4: return VarUI8FromR4(V_R4(ps), &V_UI8(pd));
257 case VT_R8: return VarUI8FromR8(V_R8(ps), &V_UI8(pd));
258 case VT_DATE: return VarUI8FromDate(V_DATE(ps), &V_UI8(pd));
259 case VT_BOOL: return VarUI8FromBool(V_BOOL(ps), &V_UI8(pd));
260 case VT_CY: return VarUI8FromCy(V_CY(ps), &V_UI8(pd));
261 case VT_DECIMAL: return VarUI8FromDec(&V_DECIMAL(ps), &V_UI8(pd));
262 case VT_DISPATCH: return VarUI8FromDisp(V_DISPATCH(ps), lcid, &V_UI8(pd));
263 case VT_BSTR: return VarUI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI8(pd));
264 }
265 break;
266
267 case VT_I8:
268 switch (vtFrom)
269 {
270 case VT_EMPTY: V_I8(pd) = 0; return S_OK;
271 case VT_I4: V_I8(pd) = V_I4(ps); return S_OK;
272 case VT_I1: return VarI8FromI1(V_I1(ps), &V_I8(pd));
273 case VT_I2: return VarI8FromI2(V_I2(ps), &V_I8(pd));
274 case VT_UI1: return VarI8FromUI1(V_UI1(ps), &V_I8(pd));
275 case VT_UI2: return VarI8FromUI2(V_UI2(ps), &V_I8(pd));
276 case VT_UI4: return VarI8FromUI4(V_UI4(ps), &V_I8(pd));
277 case VT_UI8: V_I8(pd) = V_UI8(ps); return S_OK;
278 case VT_R4: return VarI8FromR4(V_R4(ps), &V_I8(pd));
279 case VT_R8: return VarI8FromR8(V_R8(ps), &V_I8(pd));
280 case VT_DATE: return VarI8FromDate(V_DATE(ps), &V_I8(pd));
281 case VT_BOOL: return VarI8FromBool(V_BOOL(ps), &V_I8(pd));
282 case VT_CY: return VarI8FromCy(V_CY(ps), &V_I8(pd));
283 case VT_DECIMAL: return VarI8FromDec(&V_DECIMAL(ps), &V_I8(pd));
284 case VT_DISPATCH: return VarI8FromDisp(V_DISPATCH(ps), lcid, &V_I8(pd));
285 case VT_BSTR: return VarI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_I8(pd));
286 }
287 break;
288
289 case VT_R4:
290 switch (vtFrom)
291 {
292 case VT_EMPTY: V_R4(pd) = 0.0f; return S_OK;
293 case VT_I1: return VarR4FromI1(V_I1(ps), &V_R4(pd));
294 case VT_I2: return VarR4FromI2(V_I2(ps), &V_R4(pd));
295 case VT_I4: return VarR4FromI4(V_I4(ps), &V_R4(pd));
296 case VT_UI1: return VarR4FromUI1(V_UI1(ps), &V_R4(pd));
297 case VT_UI2: return VarR4FromUI2(V_UI2(ps), &V_R4(pd));
298 case VT_UI4: return VarR4FromUI4(V_UI4(ps), &V_R4(pd));
299 case VT_I8: return VarR4FromI8(V_I8(ps), &V_R4(pd));
300 case VT_UI8: return VarR4FromUI8(V_UI8(ps), &V_R4(pd));
301 case VT_R8: return VarR4FromR8(V_R8(ps), &V_R4(pd));
302 case VT_DATE: return VarR4FromDate(V_DATE(ps), &V_R4(pd));
303 case VT_BOOL: return VarR4FromBool(V_BOOL(ps), &V_R4(pd));
304 case VT_CY: return VarR4FromCy(V_CY(ps), &V_R4(pd));
305 case VT_DECIMAL: return VarR4FromDec(&V_DECIMAL(ps), &V_R4(pd));
306 case VT_DISPATCH: return VarR4FromDisp(V_DISPATCH(ps), lcid, &V_R4(pd));
307 case VT_BSTR: return VarR4FromStr(V_BSTR(ps), lcid, dwFlags, &V_R4(pd));
308 }
309 break;
310
311 case VT_R8:
312 switch (vtFrom)
313 {
314 case VT_EMPTY: V_R8(pd) = 0.0; return S_OK;
315 case VT_I1: return VarR8FromI1(V_I1(ps), &V_R8(pd));
316 case VT_I2: return VarR8FromI2(V_I2(ps), &V_R8(pd));
317 case VT_I4: return VarR8FromI4(V_I4(ps), &V_R8(pd));
318 case VT_UI1: return VarR8FromUI1(V_UI1(ps), &V_R8(pd));
319 case VT_UI2: return VarR8FromUI2(V_UI2(ps), &V_R8(pd));
320 case VT_UI4: return VarR8FromUI4(V_UI4(ps), &V_R8(pd));
321 case VT_I8: return VarR8FromI8(V_I8(ps), &V_R8(pd));
322 case VT_UI8: return VarR8FromUI8(V_UI8(ps), &V_R8(pd));
323 case VT_R4: return VarR8FromR4(V_R4(ps), &V_R8(pd));
324 case VT_DATE: return VarR8FromDate(V_DATE(ps), &V_R8(pd));
325 case VT_BOOL: return VarR8FromBool(V_BOOL(ps), &V_R8(pd));
326 case VT_CY: return VarR8FromCy(V_CY(ps), &V_R8(pd));
327 case VT_DECIMAL: return VarR8FromDec(&V_DECIMAL(ps), &V_R8(pd));
328 case VT_DISPATCH: return VarR8FromDisp(V_DISPATCH(ps), lcid, &V_R8(pd));
329 case VT_BSTR: return VarR8FromStr(V_BSTR(ps), lcid, dwFlags, &V_R8(pd));
330 }
331 break;
332
333 case VT_DATE:
334 switch (vtFrom)
335 {
336 case VT_EMPTY: V_DATE(pd) = 0.0; return S_OK;
337 case VT_I1: return VarDateFromI1(V_I1(ps), &V_DATE(pd));
338 case VT_I2: return VarDateFromI2(V_I2(ps), &V_DATE(pd));
339 case VT_I4: return VarDateFromI4(V_I4(ps), &V_DATE(pd));
340 case VT_UI1: return VarDateFromUI1(V_UI1(ps), &V_DATE(pd));
341 case VT_UI2: return VarDateFromUI2(V_UI2(ps), &V_DATE(pd));
342 case VT_UI4: return VarDateFromUI4(V_UI4(ps), &V_DATE(pd));
343 case VT_I8: return VarDateFromI8(V_I8(ps), &V_DATE(pd));
344 case VT_UI8: return VarDateFromUI8(V_UI8(ps), &V_DATE(pd));
345 case VT_R4: return VarDateFromR4(V_R4(ps), &V_DATE(pd));
346 case VT_R8: return VarDateFromR8(V_R8(ps), &V_DATE(pd));
347 case VT_BOOL: return VarDateFromBool(V_BOOL(ps), &V_DATE(pd));
348 case VT_CY: return VarDateFromCy(V_CY(ps), &V_DATE(pd));
349 case VT_DECIMAL: return VarDateFromDec(&V_DECIMAL(ps), &V_DATE(pd));
350 case VT_DISPATCH: return VarDateFromDisp(V_DISPATCH(ps), lcid, &V_DATE(pd));
351 case VT_BSTR: return VarDateFromStr(V_BSTR(ps), lcid, dwFlags, &V_DATE(pd));
352 }
353 break;
354
355 case VT_BOOL:
356 switch (vtFrom)
357 {
358 case VT_EMPTY: V_BOOL(pd) = 0; return S_OK;
359 case VT_I1: return VarBoolFromI1(V_I1(ps), &V_BOOL(pd));
360 case VT_I2: return VarBoolFromI2(V_I2(ps), &V_BOOL(pd));
361 case VT_I4: return VarBoolFromI4(V_I4(ps), &V_BOOL(pd));
362 case VT_UI1: return VarBoolFromUI1(V_UI1(ps), &V_BOOL(pd));
363 case VT_UI2: return VarBoolFromUI2(V_UI2(ps), &V_BOOL(pd));
364 case VT_UI4: return VarBoolFromUI4(V_UI4(ps), &V_BOOL(pd));
365 case VT_I8: return VarBoolFromI8(V_I8(ps), &V_BOOL(pd));
366 case VT_UI8: return VarBoolFromUI8(V_UI8(ps), &V_BOOL(pd));
367 case VT_R4: return VarBoolFromR4(V_R4(ps), &V_BOOL(pd));
368 case VT_R8: return VarBoolFromR8(V_R8(ps), &V_BOOL(pd));
369 case VT_DATE: return VarBoolFromDate(V_DATE(ps), &V_BOOL(pd));
370 case VT_CY: return VarBoolFromCy(V_CY(ps), &V_BOOL(pd));
371 case VT_DECIMAL: return VarBoolFromDec(&V_DECIMAL(ps), &V_BOOL(pd));
372 case VT_DISPATCH: return VarBoolFromDisp(V_DISPATCH(ps), lcid, &V_BOOL(pd));
373 case VT_BSTR: return VarBoolFromStr(V_BSTR(ps), lcid, dwFlags, &V_BOOL(pd));
374 }
375 break;
376
377 case VT_BSTR:
378 switch (vtFrom)
379 {
380 case VT_EMPTY:
381 V_BSTR(pd) = SysAllocStringLen(NULL, 0);
382 return V_BSTR(pd) ? S_OK : E_OUTOFMEMORY;
383 case VT_BOOL:
384 if (wFlags & (VARIANT_ALPHABOOL|VARIANT_LOCALBOOL))
385 return VarBstrFromBool(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
386 return VarBstrFromI2(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
387 case VT_I1: return VarBstrFromI1(V_I1(ps), lcid, dwFlags, &V_BSTR(pd));
388 case VT_I2: return VarBstrFromI2(V_I2(ps), lcid, dwFlags, &V_BSTR(pd));
389 case VT_I4: return VarBstrFromI4(V_I4(ps), lcid, dwFlags, &V_BSTR(pd));
390 case VT_UI1: return VarBstrFromUI1(V_UI1(ps), lcid, dwFlags, &V_BSTR(pd));
391 case VT_UI2: return VarBstrFromUI2(V_UI2(ps), lcid, dwFlags, &V_BSTR(pd));
392 case VT_UI4: return VarBstrFromUI4(V_UI4(ps), lcid, dwFlags, &V_BSTR(pd));
393 case VT_I8: return VarBstrFromI8(V_I8(ps), lcid, dwFlags, &V_BSTR(pd));
394 case VT_UI8: return VarBstrFromUI8(V_UI8(ps), lcid, dwFlags, &V_BSTR(pd));
395 case VT_R4: return VarBstrFromR4(V_R4(ps), lcid, dwFlags, &V_BSTR(pd));
396 case VT_R8: return VarBstrFromR8(V_R8(ps), lcid, dwFlags, &V_BSTR(pd));
397 case VT_DATE: return VarBstrFromDate(V_DATE(ps), lcid, dwFlags, &V_BSTR(pd));
398 case VT_CY: return VarBstrFromCy(V_CY(ps), lcid, dwFlags, &V_BSTR(pd));
399 case VT_DECIMAL: return VarBstrFromDec(&V_DECIMAL(ps), lcid, dwFlags, &V_BSTR(pd));
400 case VT_DISPATCH: return VarBstrFromDisp(V_DISPATCH(ps), lcid, dwFlags, &V_BSTR(pd));
401 }
402 break;
403
404 case VT_CY:
405 switch (vtFrom)
406 {
407 case VT_EMPTY: V_CY(pd).int64 = 0; return S_OK;
408 case VT_I1: return VarCyFromI1(V_I1(ps), &V_CY(pd));
409 case VT_I2: return VarCyFromI2(V_I2(ps), &V_CY(pd));
410 case VT_I4: return VarCyFromI4(V_I4(ps), &V_CY(pd));
411 case VT_UI1: return VarCyFromUI1(V_UI1(ps), &V_CY(pd));
412 case VT_UI2: return VarCyFromUI2(V_UI2(ps), &V_CY(pd));
413 case VT_UI4: return VarCyFromUI4(V_UI4(ps), &V_CY(pd));
414 case VT_I8: return VarCyFromI8(V_I8(ps), &V_CY(pd));
415 case VT_UI8: return VarCyFromUI8(V_UI8(ps), &V_CY(pd));
416 case VT_R4: return VarCyFromR4(V_R4(ps), &V_CY(pd));
417 case VT_R8: return VarCyFromR8(V_R8(ps), &V_CY(pd));
418 case VT_DATE: return VarCyFromDate(V_DATE(ps), &V_CY(pd));
419 case VT_BOOL: return VarCyFromBool(V_BOOL(ps), &V_CY(pd));
420 case VT_DECIMAL: return VarCyFromDec(&V_DECIMAL(ps), &V_CY(pd));
421 case VT_DISPATCH: return VarCyFromDisp(V_DISPATCH(ps), lcid, &V_CY(pd));
422 case VT_BSTR: return VarCyFromStr(V_BSTR(ps), lcid, dwFlags, &V_CY(pd));
423 }
424 break;
425
426 case VT_DECIMAL:
427 switch (vtFrom)
428 {
429 case VT_EMPTY:
430 case VT_BOOL:
431 DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0);
432 DEC_HI32(&V_DECIMAL(pd)) = 0;
433 DEC_MID32(&V_DECIMAL(pd)) = 0;
434 /* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0.
435 * VT_NULL and VT_EMPTY always give a 0 value.
436 */
437 DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
438 return S_OK;
439 case VT_I1: return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd));
440 case VT_I2: return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd));
441 case VT_I4: return VarDecFromI4(V_I4(ps), &V_DECIMAL(pd));
442 case VT_UI1: return VarDecFromUI1(V_UI1(ps), &V_DECIMAL(pd));
443 case VT_UI2: return VarDecFromUI2(V_UI2(ps), &V_DECIMAL(pd));
444 case VT_UI4: return VarDecFromUI4(V_UI4(ps), &V_DECIMAL(pd));
445 case VT_I8: return VarDecFromI8(V_I8(ps), &V_DECIMAL(pd));
446 case VT_UI8: return VarDecFromUI8(V_UI8(ps), &V_DECIMAL(pd));
447 case VT_R4: return VarDecFromR4(V_R4(ps), &V_DECIMAL(pd));
448 case VT_R8: return VarDecFromR8(V_R8(ps), &V_DECIMAL(pd));
449 case VT_DATE: return VarDecFromDate(V_DATE(ps), &V_DECIMAL(pd));
450 case VT_CY: return VarDecFromCy(V_CY(ps), &V_DECIMAL(pd));
451 case VT_DISPATCH: return VarDecFromDisp(V_DISPATCH(ps), lcid, &V_DECIMAL(pd));
452 case VT_BSTR: return VarDecFromStr(V_BSTR(ps), lcid, dwFlags, &V_DECIMAL(pd));
453 }
454 break;
455
456 case VT_UNKNOWN:
457 switch (vtFrom)
458 {
459 case VT_DISPATCH:
460 if (V_DISPATCH(ps) == NULL)
461 {
462 V_UNKNOWN(pd) = NULL;
463 res = S_OK;
464 }
465 else
466 res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
467 break;
468 }
469 break;
470
471 case VT_DISPATCH:
472 switch (vtFrom)
473 {
474 case VT_UNKNOWN:
475 if (V_UNKNOWN(ps) == NULL)
476 {
477 V_DISPATCH(pd) = NULL;
478 res = S_OK;
479 }
480 else
481 res = IUnknown_QueryInterface(V_UNKNOWN(ps), &IID_IDispatch, (LPVOID*)&V_DISPATCH(pd));
482 break;
483 }
484 break;
485
486 case VT_RECORD:
487 break;
488 }
489 return res;
490 }
491
492 /* Coerce to/from an array */
493 static inline HRESULT VARIANT_CoerceArray(VARIANTARG* pd, VARIANTARG* ps, VARTYPE vt)
494 {
495 if (vt == VT_BSTR && V_VT(ps) == (VT_ARRAY|VT_UI1))
496 return BstrFromVector(V_ARRAY(ps), &V_BSTR(pd));
497
498 if (V_VT(ps) == VT_BSTR && vt == (VT_ARRAY|VT_UI1))
499 return VectorFromBstr(V_BSTR(ps), &V_ARRAY(pd));
500
501 if (V_VT(ps) == vt)
502 return SafeArrayCopy(V_ARRAY(ps), &V_ARRAY(pd));
503
504 return DISP_E_TYPEMISMATCH;
505 }
506
507 static HRESULT VARIANT_FetchDispatchValue(LPVARIANT pvDispatch, LPVARIANT pValue)
508 {
509 HRESULT hres;
510 static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
511
512 if ((V_VT(pvDispatch) & VT_TYPEMASK) == VT_DISPATCH) {
513 if (NULL == V_DISPATCH(pvDispatch)) return DISP_E_TYPEMISMATCH;
514 hres = IDispatch_Invoke(V_DISPATCH(pvDispatch), DISPID_VALUE, &IID_NULL,
515 LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &emptyParams, pValue,
516 NULL, NULL);
517 } else {
518 hres = DISP_E_TYPEMISMATCH;
519 }
520 return hres;
521 }
522
523 /******************************************************************************
524 * Check if a variants type is valid.
525 */
526 static inline HRESULT VARIANT_ValidateType(VARTYPE vt)
527 {
528 VARTYPE vtExtra = vt & VT_EXTRA_TYPE;
529
530 vt &= VT_TYPEMASK;
531
532 if (!(vtExtra & (VT_VECTOR|VT_RESERVED)))
533 {
534 if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID)
535 {
536 if ((vtExtra & (VT_BYREF|VT_ARRAY)) && vt <= VT_NULL)
537 return DISP_E_BADVARTYPE;
538 if (vt != (VARTYPE)15)
539 return S_OK;
540 }
541 }
542 return DISP_E_BADVARTYPE;
543 }
544
545 /******************************************************************************
546 * VariantInit [OLEAUT32.8]
547 *
548 * Initialise a variant.
549 *
550 * PARAMS
551 * pVarg [O] Variant to initialise
552 *
553 * RETURNS
554 * Nothing.
555 *
556 * NOTES
557 * This function simply sets the type of the variant to VT_EMPTY. It does not
558 * free any existing value, use VariantClear() for that.
559 */
560 void WINAPI VariantInit(VARIANTARG* pVarg)
561 {
562 TRACE("(%p)\n", pVarg);
563
564 /* Win8.1 zeroes whole struct. Previous implementations don't set any other fields. */
565 V_VT(pVarg) = VT_EMPTY;
566 }
567
568 HRESULT VARIANT_ClearInd(VARIANTARG *pVarg)
569 {
570 HRESULT hres;
571
572 TRACE("(%s)\n", debugstr_variant(pVarg));
573
574 hres = VARIANT_ValidateType(V_VT(pVarg));
575 if (FAILED(hres))
576 return hres;
577
578 switch (V_VT(pVarg))
579 {
580 case VT_DISPATCH:
581 case VT_UNKNOWN:
582 if (V_UNKNOWN(pVarg))
583 IUnknown_Release(V_UNKNOWN(pVarg));
584 break;
585 case VT_UNKNOWN | VT_BYREF:
586 case VT_DISPATCH | VT_BYREF:
587 if(*V_UNKNOWNREF(pVarg))
588 IUnknown_Release(*V_UNKNOWNREF(pVarg));
589 break;
590 case VT_BSTR:
591 SysFreeString(V_BSTR(pVarg));
592 break;
593 case VT_BSTR | VT_BYREF:
594 SysFreeString(*V_BSTRREF(pVarg));
595 break;
596 case VT_VARIANT | VT_BYREF:
597 VariantClear(V_VARIANTREF(pVarg));
598 break;
599 case VT_RECORD:
600 case VT_RECORD | VT_BYREF:
601 {
602 struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
603 if (pBr->pRecInfo)
604 {
605 IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
606 IRecordInfo_Release(pBr->pRecInfo);
607 }
608 break;
609 }
610 default:
611 if (V_ISARRAY(pVarg) || (V_VT(pVarg) & ~VT_BYREF) == VT_SAFEARRAY)
612 {
613 if (V_ISBYREF(pVarg))
614 {
615 if (*V_ARRAYREF(pVarg))
616 hres = SafeArrayDestroy(*V_ARRAYREF(pVarg));
617 }
618 else if (V_ARRAY(pVarg))
619 hres = SafeArrayDestroy(V_ARRAY(pVarg));
620 }
621 break;
622 }
623
624 V_VT(pVarg) = VT_EMPTY;
625 return hres;
626 }
627
628 /******************************************************************************
629 * VariantClear [OLEAUT32.9]
630 *
631 * Clear a variant.
632 *
633 * PARAMS
634 * pVarg [I/O] Variant to clear
635 *
636 * RETURNS
637 * Success: S_OK. Any previous value in pVarg is freed and its type is set to VT_EMPTY.
638 * Failure: DISP_E_BADVARTYPE, if the variant is not a valid variant type.
639 */
640 HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG* pVarg)
641 {
642 HRESULT hres;
643
644 TRACE("(%s)\n", debugstr_variant(pVarg));
645
646 hres = VARIANT_ValidateType(V_VT(pVarg));
647
648 if (SUCCEEDED(hres))
649 {
650 if (!V_ISBYREF(pVarg))
651 {
652 if (V_ISARRAY(pVarg) || V_VT(pVarg) == VT_SAFEARRAY)
653 {
654 hres = SafeArrayDestroy(V_ARRAY(pVarg));
655 }
656 else if (V_VT(pVarg) == VT_BSTR)
657 {
658 SysFreeString(V_BSTR(pVarg));
659 }
660 else if (V_VT(pVarg) == VT_RECORD)
661 {
662 struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
663 if (pBr->pRecInfo)
664 {
665 IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
666 IRecordInfo_Release(pBr->pRecInfo);
667 }
668 }
669 else if (V_VT(pVarg) == VT_DISPATCH ||
670 V_VT(pVarg) == VT_UNKNOWN)
671 {
672 if (V_UNKNOWN(pVarg))
673 IUnknown_Release(V_UNKNOWN(pVarg));
674 }
675 }
676 V_VT(pVarg) = VT_EMPTY;
677 }
678 return hres;
679 }
680
681 /******************************************************************************
682 * Copy an IRecordInfo object contained in a variant.
683 */
684 static HRESULT VARIANT_CopyIRecordInfo(VARIANT *dest, const VARIANT *src)
685 {
686 struct __tagBRECORD *dest_rec = &V_UNION(dest, brecVal);
687 const struct __tagBRECORD *src_rec = &V_UNION(src, brecVal);
688 HRESULT hr = S_OK;
689 ULONG size;
690
691 if (!src_rec->pRecInfo)
692 {
693 if (src_rec->pvRecord) return E_INVALIDARG;
694 return S_OK;
695 }
696
697 hr = IRecordInfo_GetSize(src_rec->pRecInfo, &size);
698 if (FAILED(hr)) return hr;
699
700 /* This could look cleaner if only RecordCreate() was used, but native doesn't use it.
701 Memory should be allocated in a same way as RecordCreate() does, so RecordDestroy()
702 could free it later. */
703 dest_rec->pvRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
704 if (!dest_rec->pvRecord) return E_OUTOFMEMORY;
705
706 dest_rec->pRecInfo = src_rec->pRecInfo;
707 IRecordInfo_AddRef(src_rec->pRecInfo);
708
709 return IRecordInfo_RecordCopy(src_rec->pRecInfo, src_rec->pvRecord, dest_rec->pvRecord);
710 }
711
712 /******************************************************************************
713 * VariantCopy [OLEAUT32.10]
714 *
715 * Copy a variant.
716 *
717 * PARAMS
718 * pvargDest [O] Destination for copy
719 * pvargSrc [I] Source variant to copy
720 *
721 * RETURNS
722 * Success: S_OK. pvargDest contains a copy of pvargSrc.
723 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid type.
724 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an
725 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(),
726 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc.
727 *
728 * NOTES
729 * - If pvargSrc == pvargDest, this function does nothing, and succeeds if
730 * pvargSrc is valid. Otherwise, pvargDest is always cleared using
731 * VariantClear() before pvargSrc is copied to it. If clearing pvargDest
732 * fails, so does this function.
733 * - VT_CLSID is a valid type type for pvargSrc, but not for pvargDest.
734 * - For by-value non-intrinsic types, a deep copy is made, i.e. The whole value
735 * is copied rather than just any pointers to it.
736 * - For by-value object types the object pointer is copied and the objects
737 * reference count increased using IUnknown_AddRef().
738 * - For all by-reference types, only the referencing pointer is copied.
739 */
740 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc)
741 {
742 HRESULT hres = S_OK;
743
744 TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
745
746 if (V_TYPE(pvargSrc) == VT_CLSID || /* VT_CLSID is a special case */
747 FAILED(VARIANT_ValidateType(V_VT(pvargSrc))))
748 return DISP_E_BADVARTYPE;
749
750 if (pvargSrc != pvargDest &&
751 SUCCEEDED(hres = VariantClear(pvargDest)))
752 {
753 *pvargDest = *pvargSrc; /* Shallow copy the value */
754
755 if (!V_ISBYREF(pvargSrc))
756 {
757 switch (V_VT(pvargSrc))
758 {
759 case VT_BSTR:
760 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)V_BSTR(pvargSrc), SysStringByteLen(V_BSTR(pvargSrc)));
761 if (!V_BSTR(pvargDest))
762 hres = E_OUTOFMEMORY;
763 break;
764 case VT_RECORD:
765 hres = VARIANT_CopyIRecordInfo(pvargDest, pvargSrc);
766 break;
767 case VT_DISPATCH:
768 case VT_UNKNOWN:
769 V_UNKNOWN(pvargDest) = V_UNKNOWN(pvargSrc);
770 if (V_UNKNOWN(pvargSrc))
771 IUnknown_AddRef(V_UNKNOWN(pvargSrc));
772 break;
773 default:
774 if (V_ISARRAY(pvargSrc))
775 hres = SafeArrayCopy(V_ARRAY(pvargSrc), &V_ARRAY(pvargDest));
776 }
777 }
778 }
779 return hres;
780 }
781
782 /* Return the byte size of a variants data */
783 static inline size_t VARIANT_DataSize(const VARIANT* pv)
784 {
785 switch (V_TYPE(pv))
786 {
787 case VT_I1:
788 case VT_UI1: return sizeof(BYTE);
789 case VT_I2:
790 case VT_UI2: return sizeof(SHORT);
791 case VT_INT:
792 case VT_UINT:
793 case VT_I4:
794 case VT_UI4: return sizeof(LONG);
795 case VT_I8:
796 case VT_UI8: return sizeof(LONGLONG);
797 case VT_R4: return sizeof(float);
798 case VT_R8: return sizeof(double);
799 case VT_DATE: return sizeof(DATE);
800 case VT_BOOL: return sizeof(VARIANT_BOOL);
801 case VT_DISPATCH:
802 case VT_UNKNOWN:
803 case VT_BSTR: return sizeof(void*);
804 case VT_CY: return sizeof(CY);
805 case VT_ERROR: return sizeof(SCODE);
806 }
807 TRACE("Shouldn't be called for variant %s!\n", debugstr_variant(pv));
808 return 0;
809 }
810
811 /******************************************************************************
812 * VariantCopyInd [OLEAUT32.11]
813 *
814 * Copy a variant, dereferencing it if it is by-reference.
815 *
816 * PARAMS
817 * pvargDest [O] Destination for copy
818 * pvargSrc [I] Source variant to copy
819 *
820 * RETURNS
821 * Success: S_OK. pvargDest contains a copy of pvargSrc.
822 * Failure: An HRESULT error code indicating the error.
823 *
824 * NOTES
825 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid by-value type.
826 * E_INVALIDARG, if pvargSrc is an invalid by-reference type.
827 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an
828 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(),
829 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc.
830 *
831 * NOTES
832 * - If pvargSrc is by-value, this function behaves exactly as VariantCopy().
833 * - If pvargSrc is by-reference, the value copied to pvargDest is the pointed-to
834 * value.
835 * - if pvargSrc == pvargDest, this function dereferences in place. Otherwise,
836 * pvargDest is always cleared using VariantClear() before pvargSrc is copied
837 * to it. If clearing pvargDest fails, so does this function.
838 */
839 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, const VARIANTARG* pvargSrc)
840 {
841 const VARIANTARG *pSrc = pvargSrc;
842 VARIANTARG vTmp;
843 VARTYPE vt;
844 HRESULT hres = S_OK;
845
846 TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
847
848 if (!V_ISBYREF(pvargSrc))
849 return VariantCopy(pvargDest, pvargSrc);
850
851 /* Argument checking is more lax than VariantCopy()... */
852 vt = V_TYPE(pvargSrc);
853 if (V_ISARRAY(pvargSrc) || (V_VT(pvargSrc) == (VT_RECORD|VT_BYREF)) ||
854 (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
855 !(V_VT(pvargSrc) & (VT_VECTOR|VT_RESERVED))))
856 {
857 /* OK */
858 }
859 else
860 return E_INVALIDARG; /* ...And the return value for invalid types differs too */
861
862 if (pvargSrc == pvargDest)
863 {
864 /* In place copy. Use a shallow copy of pvargSrc & init pvargDest.
865 * This avoids an expensive VariantCopy() call - e.g. SafeArrayCopy().
866 */
867 vTmp = *pvargSrc;
868 pSrc = &vTmp;
869 V_VT(pvargDest) = VT_EMPTY;
870 }
871 else
872 {
873 /* Copy into another variant. Free the variant in pvargDest */
874 if (FAILED(hres = VariantClear(pvargDest)))
875 {
876 TRACE("VariantClear() of destination failed\n");
877 return hres;
878 }
879 }
880
881 if (V_ISARRAY(pSrc))
882 {
883 /* Native doesn't check that *V_ARRAYREF(pSrc) is valid */
884 hres = SafeArrayCopy(*V_ARRAYREF(pSrc), &V_ARRAY(pvargDest));
885 }
886 else if (V_VT(pSrc) == (VT_BSTR|VT_BYREF))
887 {
888 /* Native doesn't check that *V_BSTRREF(pSrc) is valid */
889 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)*V_BSTRREF(pSrc), SysStringByteLen(*V_BSTRREF(pSrc)));
890 }
891 else if (V_VT(pSrc) == (VT_RECORD|VT_BYREF))
892 {
893 hres = VARIANT_CopyIRecordInfo(pvargDest, pvargSrc);
894 }
895 else if (V_VT(pSrc) == (VT_DISPATCH|VT_BYREF) ||
896 V_VT(pSrc) == (VT_UNKNOWN|VT_BYREF))
897 {
898 /* Native doesn't check that *V_UNKNOWNREF(pSrc) is valid */
899 V_UNKNOWN(pvargDest) = *V_UNKNOWNREF(pSrc);
900 if (*V_UNKNOWNREF(pSrc))
901 IUnknown_AddRef(*V_UNKNOWNREF(pSrc));
902 }
903 else if (V_VT(pSrc) == (VT_VARIANT|VT_BYREF))
904 {
905 /* Native doesn't check that *V_VARIANTREF(pSrc) is valid */
906 if (V_VT(V_VARIANTREF(pSrc)) == (VT_VARIANT|VT_BYREF))
907 hres = E_INVALIDARG; /* Don't dereference more than one level */
908 else
909 hres = VariantCopyInd(pvargDest, V_VARIANTREF(pSrc));
910
911 /* Use the dereferenced variants type value, not VT_VARIANT */
912 goto VariantCopyInd_Return;
913 }
914 else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF))
915 {
916 memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)),
917 sizeof(DECIMAL) - sizeof(USHORT));
918 }
919 else
920 {
921 /* Copy the pointed to data into this variant */
922 memcpy(&V_BYREF(pvargDest), V_BYREF(pSrc), VARIANT_DataSize(pSrc));
923 }
924
925 V_VT(pvargDest) = V_VT(pSrc) & ~VT_BYREF;
926
927 VariantCopyInd_Return:
928
929 if (pSrc != pvargSrc)
930 VariantClear(&vTmp);
931
932 TRACE("returning 0x%08x, %s\n", hres, debugstr_variant(pvargDest));
933 return hres;
934 }
935
936 /******************************************************************************
937 * VariantChangeType [OLEAUT32.12]
938 *
939 * Change the type of a variant.
940 *
941 * PARAMS
942 * pvargDest [O] Destination for the converted variant
943 * pvargSrc [O] Source variant to change the type of
944 * wFlags [I] VARIANT_ flags from "oleauto.h"
945 * vt [I] Variant type to change pvargSrc into
946 *
947 * RETURNS
948 * Success: S_OK. pvargDest contains the converted value.
949 * Failure: An HRESULT error code describing the failure.
950 *
951 * NOTES
952 * The LCID used for the conversion is LOCALE_USER_DEFAULT.
953 * See VariantChangeTypeEx.
954 */
955 HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
956 USHORT wFlags, VARTYPE vt)
957 {
958 return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt );
959 }
960
961 /******************************************************************************
962 * VariantChangeTypeEx [OLEAUT32.147]
963 *
964 * Change the type of a variant.
965 *
966 * PARAMS
967 * pvargDest [O] Destination for the converted variant
968 * pvargSrc [O] Source variant to change the type of
969 * lcid [I] LCID for the conversion
970 * wFlags [I] VARIANT_ flags from "oleauto.h"
971 * vt [I] Variant type to change pvargSrc into
972 *
973 * RETURNS
974 * Success: S_OK. pvargDest contains the converted value.
975 * Failure: An HRESULT error code describing the failure.
976 *
977 * NOTES
978 * pvargDest and pvargSrc can point to the same variant to perform an in-place
979 * conversion. If the conversion is successful, pvargSrc will be freed.
980 */
981 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, const VARIANTARG* pvargSrc,
982 LCID lcid, USHORT wFlags, VARTYPE vt)
983 {
984 HRESULT res = S_OK;
985
986 TRACE("(%s,%s,0x%08x,0x%04x,%s)\n", debugstr_variant(pvargDest),
987 debugstr_variant(pvargSrc), lcid, wFlags, debugstr_vt(vt));
988
989 if (vt == VT_CLSID)
990 res = DISP_E_BADVARTYPE;
991 else
992 {
993 res = VARIANT_ValidateType(V_VT(pvargSrc));
994
995 if (SUCCEEDED(res))
996 {
997 res = VARIANT_ValidateType(vt);
998
999 if (SUCCEEDED(res))
1000 {
1001 VARIANTARG vTmp, vSrcDeref;
1002
1003 if(V_ISBYREF(pvargSrc) && !V_BYREF(pvargSrc))
1004 res = DISP_E_TYPEMISMATCH;
1005 else
1006 {
1007 V_VT(&vTmp) = VT_EMPTY;
1008 V_VT(&vSrcDeref) = VT_EMPTY;
1009 VariantClear(&vTmp);
1010 VariantClear(&vSrcDeref);
1011 }
1012
1013 if (SUCCEEDED(res))
1014 {
1015 res = VariantCopyInd(&vSrcDeref, pvargSrc);
1016 if (SUCCEEDED(res))
1017 {
1018 if (V_ISARRAY(&vSrcDeref) || (vt & VT_ARRAY))
1019 res = VARIANT_CoerceArray(&vTmp, &vSrcDeref, vt);
1020 else
1021 res = VARIANT_Coerce(&vTmp, lcid, wFlags, &vSrcDeref, vt);
1022
1023 if (SUCCEEDED(res)) {
1024 V_VT(&vTmp) = vt;
1025 res = VariantCopy(pvargDest, &vTmp);
1026 }
1027 VariantClear(&vTmp);
1028 VariantClear(&vSrcDeref);
1029 }
1030 }
1031 }
1032 }
1033 }
1034
1035 TRACE("returning 0x%08x, %s\n", res, debugstr_variant(pvargDest));
1036 return res;
1037 }
1038
1039 /* Date Conversions */
1040
1041 #define IsLeapYear(y) (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
1042
1043 /* Convert a VT_DATE value to a Julian Date */
1044 static inline int VARIANT_JulianFromDate(int dateIn)
1045 {
1046 int julianDays = dateIn;
1047
1048 julianDays -= DATE_MIN; /* Convert to + days from 1 Jan 100 AD */
1049 julianDays += 1757585; /* Convert to + days from 23 Nov 4713 BC (Julian) */
1050 return julianDays;
1051 }
1052
1053 /* Convert a Julian Date to a VT_DATE value */
1054 static inline int VARIANT_DateFromJulian(int dateIn)
1055 {
1056 int julianDays = dateIn;
1057
1058 julianDays -= 1757585; /* Convert to + days from 1 Jan 100 AD */
1059 julianDays += DATE_MIN; /* Convert to +/- days from 1 Jan 1899 AD */
1060 return julianDays;
1061 }
1062
1063 /* Convert a Julian date to Day/Month/Year - from PostgreSQL */
1064 static inline void VARIANT_DMYFromJulian(int jd, USHORT *year, USHORT *month, USHORT *day)
1065 {
1066 int j, i, l, n;
1067
1068 l = jd + 68569;
1069 n = l * 4 / 146097;
1070 l -= (n * 146097 + 3) / 4;
1071 i = (4000 * (l + 1)) / 1461001;
1072 l += 31 - (i * 1461) / 4;
1073 j = (l * 80) / 2447;
1074 *day = l - (j * 2447) / 80;
1075 l = j / 11;
1076 *month = (j + 2) - (12 * l);
1077 *year = 100 * (n - 49) + i + l;
1078 }
1079
1080 /* Convert Day/Month/Year to a Julian date - from PostgreSQL */
1081 static inline double VARIANT_JulianFromDMY(USHORT year, USHORT month, USHORT day)
1082 {
1083 int m12 = (month - 14) / 12;
1084
1085 return ((1461 * (year + 4800 + m12)) / 4 + (367 * (month - 2 - 12 * m12)) / 12 -
1086 (3 * ((year + 4900 + m12) / 100)) / 4 + day - 32075);
1087 }
1088
1089 /* Macros for accessing DOS format date/time fields */
1090 #define DOS_YEAR(x) (1980 + (x >> 9))
1091 #define DOS_MONTH(x) ((x >> 5) & 0xf)
1092 #define DOS_DAY(x) (x & 0x1f)
1093 #define DOS_HOUR(x) (x >> 11)
1094 #define DOS_MINUTE(x) ((x >> 5) & 0x3f)
1095 #define DOS_SECOND(x) ((x & 0x1f) << 1)
1096 /* Create a DOS format date/time */
1097 #define DOS_DATE(d,m,y) (d | (m << 5) | ((y-1980) << 9))
1098 #define DOS_TIME(h,m,s) ((s >> 1) | (m << 5) | (h << 11))
1099
1100 /* Roll a date forwards or backwards to correct it */
1101 static HRESULT VARIANT_RollUdate(UDATE *lpUd)
1102 {
1103 static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
1104 short iYear, iMonth, iDay, iHour, iMinute, iSecond;
1105
1106 /* interpret values signed */
1107 iYear = lpUd->st.wYear;
1108 iMonth = lpUd->st.wMonth;
1109 iDay = lpUd->st.wDay;
1110 iHour = lpUd->st.wHour;
1111 iMinute = lpUd->st.wMinute;
1112 iSecond = lpUd->st.wSecond;
1113
1114 TRACE("Raw date: %d/%d/%d %d:%d:%d\n", iDay, iMonth,
1115 iYear, iHour, iMinute, iSecond);
1116
1117 if (iYear > 9999 || iYear < -9999)
1118 return E_INVALIDARG; /* Invalid value */
1119 /* Years 0 to 49 are treated as 2000 + year, see also VARIANT_MakeDate() */
1120 if (0 <= iYear && iYear <= 49)
1121 iYear += 2000;
1122 /* Remaining years 50 to 99 are treated as 1900 + year */
1123 else if (50 <= iYear && iYear <= 99)
1124 iYear += 1900;
1125
1126 iMinute += iSecond / 60;
1127 iSecond = iSecond % 60;
1128 iHour += iMinute / 60;
1129 iMinute = iMinute % 60;
1130 iDay += iHour / 24;
1131 iHour = iHour % 24;
1132 iYear += iMonth / 12;
1133 iMonth = iMonth % 12;
1134 if (iMonth<=0) {iMonth+=12; iYear--;}
1135 while (iDay > days[iMonth])
1136 {
1137 if (iMonth == 2 && IsLeapYear(iYear))
1138 iDay -= 29;
1139 else
1140 iDay -= days[iMonth];
1141 iMonth++;
1142 iYear += iMonth / 12;
1143 iMonth = iMonth % 12;
1144 }
1145 while (iDay <= 0)
1146 {
1147 iMonth--;
1148 if (iMonth<=0) {iMonth+=12; iYear--;}
1149 if (iMonth == 2 && IsLeapYear(iYear))
1150 iDay += 29;
1151 else
1152 iDay += days[iMonth];
1153 }
1154
1155 if (iSecond<0){iSecond+=60; iMinute--;}
1156 if (iMinute<0){iMinute+=60; iHour--;}
1157 if (iHour<0) {iHour+=24; iDay--;}
1158 if (iYear<=0) iYear+=2000;
1159
1160 lpUd->st.wYear = iYear;
1161 lpUd->st.wMonth = iMonth;
1162 lpUd->st.wDay = iDay;
1163 lpUd->st.wHour = iHour;
1164 lpUd->st.wMinute = iMinute;
1165 lpUd->st.wSecond = iSecond;
1166
1167 TRACE("Rolled date: %d/%d/%d %d:%d:%d\n", lpUd->st.wDay, lpUd->st.wMonth,
1168 lpUd->st.wYear, lpUd->st.wHour, lpUd->st.wMinute, lpUd->st.wSecond);
1169 return S_OK;
1170 }
1171
1172 /**********************************************************************
1173 * DosDateTimeToVariantTime [OLEAUT32.14]
1174 *
1175 * Convert a Dos format date and time into variant VT_DATE format.
1176 *
1177 * PARAMS
1178 * wDosDate [I] Dos format date
1179 * wDosTime [I] Dos format time
1180 * pDateOut [O] Destination for VT_DATE format
1181 *
1182 * RETURNS
1183 * Success: TRUE. pDateOut contains the converted time.
1184 * Failure: FALSE, if wDosDate or wDosTime are invalid (see notes).
1185 *
1186 * NOTES
1187 * - Dos format dates can only hold dates from 1-Jan-1980 to 31-Dec-2099.
1188 * - Dos format times are accurate to only 2 second precision.
1189 * - The format of a Dos Date is:
1190 *| Bits Values Meaning
1191 *| ---- ------ -------
1192 *| 0-4 1-31 Day of the week. 0 rolls back one day. A value greater than
1193 *| the days in the month rolls forward the extra days.
1194 *| 5-8 1-12 Month of the year. 0 rolls back to December of the previous
1195 *| year. 13-15 are invalid.
1196 *| 9-15 0-119 Year based from 1980 (Max 2099). 120-127 are invalid.
1197 * - The format of a Dos Time is:
1198 *| Bits Values Meaning
1199 *| ---- ------ -------
1200 *| 0-4 0-29 Seconds/2. 30 and 31 are invalid.
1201 *| 5-10 0-59 Minutes. 60-63 are invalid.
1202 *| 11-15 0-23 Hours (24 hour clock). 24-32 are invalid.
1203 */
1204 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime,
1205 double *pDateOut)
1206 {
1207 UDATE ud;
1208
1209 TRACE("(0x%x(%d/%d/%d),0x%x(%d:%d:%d),%p)\n",
1210 wDosDate, DOS_YEAR(wDosDate), DOS_MONTH(wDosDate), DOS_DAY(wDosDate),
1211 wDosTime, DOS_HOUR(wDosTime), DOS_MINUTE(wDosTime), DOS_SECOND(wDosTime),
1212 pDateOut);
1213
1214 ud.st.wYear = DOS_YEAR(wDosDate);
1215 ud.st.wMonth = DOS_MONTH(wDosDate);
1216 if (ud.st.wYear > 2099 || ud.st.wMonth > 12)
1217 return FALSE;
1218 ud.st.wDay = DOS_DAY(wDosDate);
1219 ud.st.wHour = DOS_HOUR(wDosTime);
1220 ud.st.wMinute = DOS_MINUTE(wDosTime);
1221 ud.st.wSecond = DOS_SECOND(wDosTime);
1222 ud.st.wDayOfWeek = ud.st.wMilliseconds = 0;
1223 if (ud.st.wHour > 23 || ud.st.wMinute > 59 || ud.st.wSecond > 59)
1224 return FALSE; /* Invalid values in Dos*/
1225
1226 return VarDateFromUdate(&ud, 0, pDateOut) == S_OK;
1227 }
1228
1229 /**********************************************************************
1230 * VariantTimeToDosDateTime [OLEAUT32.13]
1231 *
1232 * Convert a variant format date into a Dos format date and time.
1233 *
1234 * dateIn [I] VT_DATE time format
1235 * pwDosDate [O] Destination for Dos format date
1236 * pwDosTime [O] Destination for Dos format time
1237 *
1238 * RETURNS
1239 * Success: TRUE. pwDosDate and pwDosTime contains the converted values.
1240 * Failure: FALSE, if dateIn cannot be represented in Dos format.
1241 *
1242 * NOTES
1243 * See DosDateTimeToVariantTime() for Dos format details and bugs.
1244 */
1245 INT WINAPI VariantTimeToDosDateTime(double dateIn, USHORT *pwDosDate, USHORT *pwDosTime)
1246 {
1247 UDATE ud;
1248
1249 TRACE("(%g,%p,%p)\n", dateIn, pwDosDate, pwDosTime);
1250
1251 if (FAILED(VarUdateFromDate(dateIn, 0, &ud)))
1252 return FALSE;
1253
1254 if (ud.st.wYear < 1980 || ud.st.wYear > 2099)
1255 return FALSE;
1256
1257 *pwDosDate = DOS_DATE(ud.st.wDay, ud.st.wMonth, ud.st.wYear);
1258 *pwDosTime = DOS_TIME(ud.st.wHour, ud.st.wMinute, ud.st.wSecond);
1259
1260 TRACE("Returning 0x%x(%d/%d/%d), 0x%x(%d:%d:%d)\n",
1261 *pwDosDate, DOS_YEAR(*pwDosDate), DOS_MONTH(*pwDosDate), DOS_DAY(*pwDosDate),
1262 *pwDosTime, DOS_HOUR(*pwDosTime), DOS_MINUTE(*pwDosTime), DOS_SECOND(*pwDosTime));
1263 return TRUE;
1264 }
1265
1266 /***********************************************************************
1267 * SystemTimeToVariantTime [OLEAUT32.184]
1268 *
1269 * Convert a System format date and time into variant VT_DATE format.
1270 *
1271 * PARAMS
1272 * lpSt [I] System format date and time
1273 * pDateOut [O] Destination for VT_DATE format date
1274 *
1275 * RETURNS
1276 * Success: TRUE. *pDateOut contains the converted value.
1277 * Failure: FALSE, if lpSt cannot be represented in VT_DATE format.
1278 */
1279 INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut)
1280 {
1281 UDATE ud;
1282
1283 TRACE("(%p->%d/%d/%d %d:%d:%d,%p)\n", lpSt, lpSt->wDay, lpSt->wMonth,
1284 lpSt->wYear, lpSt->wHour, lpSt->wMinute, lpSt->wSecond, pDateOut);
1285
1286 if (lpSt->wMonth > 12)
1287 return FALSE;
1288 if (lpSt->wDay > 31)
1289 return FALSE;
1290 if ((short)lpSt->wYear < 0)
1291 return FALSE;
1292
1293 ud.st = *lpSt;
1294 return VarDateFromUdate(&ud, 0, pDateOut) == S_OK;
1295 }
1296
1297 /***********************************************************************
1298 * VariantTimeToSystemTime [OLEAUT32.185]
1299 *
1300 * Convert a variant VT_DATE into a System format date and time.
1301 *
1302 * PARAMS
1303 * datein [I] Variant VT_DATE format date
1304 * lpSt [O] Destination for System format date and time
1305 *
1306 * RETURNS
1307 * Success: TRUE. *lpSt contains the converted value.
1308 * Failure: FALSE, if dateIn is too large or small.
1309 */
1310 INT WINAPI VariantTimeToSystemTime(double dateIn, LPSYSTEMTIME lpSt)
1311 {
1312 UDATE ud;
1313
1314 TRACE("(%g,%p)\n", dateIn, lpSt);
1315
1316 if (FAILED(VarUdateFromDate(dateIn, 0, &ud)))
1317 return FALSE;
1318
1319 *lpSt = ud.st;
1320 return TRUE;
1321 }
1322
1323 /***********************************************************************
1324 * VarDateFromUdateEx [OLEAUT32.319]
1325 *
1326 * Convert an unpacked format date and time to a variant VT_DATE.
1327 *
1328 * PARAMS
1329 * pUdateIn [I] Unpacked format date and time to convert
1330 * lcid [I] Locale identifier for the conversion
1331 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1332 * pDateOut [O] Destination for variant VT_DATE.
1333 *
1334 * RETURNS
1335 * Success: S_OK. *pDateOut contains the converted value.
1336 * Failure: E_INVALIDARG, if pUdateIn cannot be represented in VT_DATE format.
1337 */
1338 HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DATE *pDateOut)
1339 {
1340 UDATE ud;
1341 double dateVal = 0;
1342
1343 TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn,
1344 pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
1345 pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond,
1346 pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek,
1347 pUdateIn->wDayOfYear, lcid, dwFlags, pDateOut);
1348
1349 if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT))
1350 FIXME("lcid possibly not handled, treating as en-us\n");
1351 if (dwFlags & ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
1352 FIXME("unsupported flags: %x\n", dwFlags);
1353
1354 ud = *pUdateIn;
1355
1356 if (dwFlags & VAR_VALIDDATE)
1357 WARN("Ignoring VAR_VALIDDATE\n");
1358
1359 if (FAILED(VARIANT_RollUdate(&ud)))
1360 return E_INVALIDARG;
1361
1362 /* Date */
1363 if (!(dwFlags & VAR_TIMEVALUEONLY))
1364 dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay));
1365
1366 if ((dwFlags & VAR_TIMEVALUEONLY) || !(dwFlags & VAR_DATEVALUEONLY))
1367 {
1368 double dateSign = (dateVal < 0.0) ? -1.0 : 1.0;
1369
1370 /* Time */
1371 dateVal += ud.st.wHour / 24.0 * dateSign;
1372 dateVal += ud.st.wMinute / 1440.0 * dateSign;
1373 dateVal += ud.st.wSecond / 86400.0 * dateSign;
1374 }
1375
1376 TRACE("Returning %g\n", dateVal);
1377 *pDateOut = dateVal;
1378 return S_OK;
1379 }
1380
1381 /***********************************************************************
1382 * VarDateFromUdate [OLEAUT32.330]
1383 *
1384 * Convert an unpacked format date and time to a variant VT_DATE.
1385 *
1386 * PARAMS
1387 * pUdateIn [I] Unpacked format date and time to convert
1388 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1389 * pDateOut [O] Destination for variant VT_DATE.
1390 *
1391 * RETURNS
1392 * Success: S_OK. *pDateOut contains the converted value.
1393 * Failure: E_INVALIDARG, if pUdateIn cannot be represented in VT_DATE format.
1394 *
1395 * NOTES
1396 * This function uses the United States English locale for the conversion. Use
1397 * VarDateFromUdateEx() for alternate locales.
1398 */
1399 HRESULT WINAPI VarDateFromUdate(UDATE *pUdateIn, ULONG dwFlags, DATE *pDateOut)
1400 {
1401 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1402
1403 return VarDateFromUdateEx(pUdateIn, lcid, dwFlags, pDateOut);
1404 }
1405
1406 /***********************************************************************
1407 * VarUdateFromDate [OLEAUT32.331]
1408 *
1409 * Convert a variant VT_DATE into an unpacked format date and time.
1410 *
1411 * PARAMS
1412 * datein [I] Variant VT_DATE format date
1413 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1414 * lpUdate [O] Destination for unpacked format date and time
1415 *
1416 * RETURNS
1417 * Success: S_OK. *lpUdate contains the converted value.
1418 * Failure: E_INVALIDARG, if dateIn is too large or small.
1419 */
1420 HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
1421 {
1422 /* Cumulative totals of days per month */
1423 static const USHORT cumulativeDays[] =
1424 {
1425 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
1426 };
1427 double datePart, timePart;
1428 int julianDays;
1429
1430 TRACE("(%g,0x%08x,%p)\n", dateIn, dwFlags, lpUdate);
1431
1432 if (dateIn <= (DATE_MIN - 1.0) || dateIn >= (DATE_MAX + 1.0))
1433 return E_INVALIDARG;
1434
1435 datePart = dateIn < 0.0 ? ceil(dateIn) : floor(dateIn);
1436 /* Compensate for int truncation (always downwards) */
1437 timePart = fabs(dateIn - datePart) + 0.00000000001;
1438 if (timePart >= 1.0)
1439 timePart -= 0.00000000001;
1440
1441 /* Date */
1442 julianDays = VARIANT_JulianFromDate(dateIn);
1443 VARIANT_DMYFromJulian(julianDays, &lpUdate->st.wYear, &lpUdate->st.wMonth,
1444 &lpUdate->st.wDay);
1445
1446 datePart = (datePart + 1.5) / 7.0;
1447 lpUdate->st.wDayOfWeek = (datePart - floor(datePart)) * 7;
1448 if (lpUdate->st.wDayOfWeek == 0)
1449 lpUdate->st.wDayOfWeek = 5;
1450 else if (lpUdate->st.wDayOfWeek == 1)
1451 lpUdate->st.wDayOfWeek = 6;
1452 else
1453 lpUdate->st.wDayOfWeek -= 2;
1454
1455 if (lpUdate->st.wMonth > 2 && IsLeapYear(lpUdate->st.wYear))
1456 lpUdate->wDayOfYear = 1; /* After February, in a leap year */
1457 else
1458 lpUdate->wDayOfYear = 0;
1459
1460 lpUdate->wDayOfYear += cumulativeDays[lpUdate->st.wMonth];
1461 lpUdate->wDayOfYear += lpUdate->st.wDay;
1462
1463 /* Time */
1464 timePart *= 24.0;
1465 lpUdate->st.wHour = timePart;
1466 timePart -= lpUdate->st.wHour;
1467 timePart *= 60.0;
1468 lpUdate->st.wMinute = timePart;
1469 timePart -= lpUdate->st.wMinute;
1470 timePart *= 60.0;
1471 lpUdate->st.wSecond = timePart;
1472 timePart -= lpUdate->st.wSecond;
1473 lpUdate->st.wMilliseconds = 0;
1474 if (timePart > 0.5)
1475 {
1476 /* Round the milliseconds, adjusting the time/date forward if needed */
1477 if (lpUdate->st.wSecond < 59)
1478 lpUdate->st.wSecond++;
1479 else
1480 {
1481 lpUdate->st.wSecond = 0;
1482 if (lpUdate->st.wMinute < 59)
1483 lpUdate->st.wMinute++;
1484 else
1485 {
1486 lpUdate->st.wMinute = 0;
1487 if (lpUdate->st.wHour < 23)
1488 lpUdate->st.wHour++;
1489 else
1490 {
1491 lpUdate->st.wHour = 0;
1492 /* Roll over a whole day */
1493 if (++lpUdate->st.wDay > 28)
1494 VARIANT_RollUdate(lpUdate);
1495 }
1496 }
1497 }
1498 }
1499 return S_OK;
1500 }
1501
1502 /* The localised characters that make up a valid number */
1503 typedef struct tagVARIANT_NUMBER_CHARS
1504 {
1505 WCHAR cNegativeSymbol;
1506 WCHAR cPositiveSymbol;
1507 WCHAR cDecimalPoint;
1508 WCHAR cDigitSeparator;
1509 DWORD sCurrencyLen;
1510 WCHAR sCurrency[8];
1511 WCHAR cCurrencyDecimalPoint;
1512 WCHAR cCurrencyDigitSeparator;
1513 } VARIANT_NUMBER_CHARS;
1514
1515 #define GET_NUMBER_TEXT(fld,name) \
1516 buff[0] = 0; \
1517 if (!GetLocaleInfoW(lcid, lctype|fld, buff, ARRAY_SIZE(buff))) \
1518 WARN("buffer too small for " #fld "\n"); \
1519 else \
1520 if (buff[0]) lpChars->name = buff[0]; \
1521 TRACE("lcid 0x%x, " #name "=%s\n", lcid, wine_dbgstr_wn(&lpChars->name, 1))
1522
1523 /* Get the valid number characters for an lcid */
1524 static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags)
1525 {
1526 static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',0,1,{'$',0},0,',' };
1527 LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE;
1528 WCHAR buff[4];
1529
1530 memcpy(lpChars, &defaultChars, sizeof(defaultChars));
1531 GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol);
1532 GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol);
1533 GET_NUMBER_TEXT(LOCALE_SDECIMAL, cDecimalPoint);
1534 GET_NUMBER_TEXT(LOCALE_STHOUSAND, cDigitSeparator);
1535 GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint);
1536 GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeparator);
1537
1538 if (!GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, lpChars->sCurrency, ARRAY_SIZE(lpChars->sCurrency)))
1539 {
1540 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1541 WARN("buffer too small for LOCALE_SCURRENCY\n");
1542 *lpChars->sCurrency = 0;
1543 }
1544 if (!*lpChars->sCurrency)
1545 wcscpy(lpChars->sCurrency, L"$");
1546 lpChars->sCurrencyLen = wcslen(lpChars->sCurrency);
1547 TRACE("lcid 0x%x, sCurrency=%u %s\n", lcid, lpChars->sCurrencyLen, wine_dbgstr_w(lpChars->sCurrency));
1548 }
1549
1550 /* Number Parsing States */
1551 #define B_PROCESSING_EXPONENT 0x1
1552 #define B_NEGATIVE_EXPONENT 0x2
1553 #define B_EXPONENT_START 0x4
1554 #define B_INEXACT_ZEROS 0x8
1555 #define B_LEADING_ZERO 0x10
1556 #define B_PROCESSING_HEX 0x20
1557 #define B_PROCESSING_OCT 0x40
1558
1559 static inline BOOL is_digit(WCHAR c)
1560 {
1561 return '0' <= c && c <= '9';
1562 }
1563
1564 /**********************************************************************
1565 * VarParseNumFromStr [OLEAUT32.46]
1566 *
1567 * Parse a string containing a number into a NUMPARSE structure.
1568 *
1569 * PARAMS
1570 * lpszStr [I] String to parse number from
1571 * lcid [I] Locale Id for the conversion
1572 * dwFlags [I] 0, or LOCALE_NOUSEROVERRIDE to use system default number chars
1573 * pNumprs [I/O] Destination for parsed number
1574 * rgbDig [O] Destination for digits read in
1575 *
1576 * RETURNS
1577 * Success: S_OK. pNumprs and rgbDig contain the parsed representation of
1578 * the number.
1579 * Failure: E_INVALIDARG, if any parameter is invalid.
1580 * DISP_E_TYPEMISMATCH, if the string is not a number or is formatted
1581 * incorrectly.
1582 * DISP_E_OVERFLOW, if rgbDig is too small to hold the number.
1583 *
1584 * NOTES
1585 * pNumprs must have the following fields set:
1586 * cDig: Set to the size of rgbDig.
1587 * dwInFlags: Set to the allowable syntax of the number using NUMPRS_ flags
1588 * from "oleauto.h".
1589 *
1590 * FIXME
1591 * - I am unsure if this function should parse non-Arabic (e.g. Thai)
1592 * numerals, so this has not been implemented.
1593 */
1594 HRESULT WINAPI VarParseNumFromStr(const OLECHAR *lpszStr, LCID lcid, ULONG dwFlags,
1595 NUMPARSE *pNumprs, BYTE *rgbDig)
1596 {
1597 VARIANT_NUMBER_CHARS chars;
1598 BYTE rgbTmp[1024];
1599 DWORD dwState = B_EXPONENT_START|B_INEXACT_ZEROS;
1600 int iMaxDigits = ARRAY_SIZE(rgbTmp);
1601 int cchUsed = 0;
1602 OLECHAR cDigitSeparator2;
1603
1604 TRACE("(%s,%d,0x%08x,%p,%p)\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig);
1605
1606 if (!pNumprs || !rgbDig)
1607 return E_INVALIDARG;
1608
1609 if (pNumprs->cDig < iMaxDigits)
1610 iMaxDigits = pNumprs->cDig;
1611
1612 pNumprs->cDig = 0;
1613 pNumprs->dwOutFlags = 0;
1614 pNumprs->cchUsed = 0;
1615 pNumprs->nBaseShift = 0;
1616 pNumprs->nPwr10 = 0;
1617
1618 if (!lpszStr)
1619 return DISP_E_TYPEMISMATCH;
1620
1621 VARIANT_GetLocalisedNumberChars(&chars, lcid, dwFlags);
1622 if (chars.cDigitSeparator == chars.cDecimalPoint)
1623 /* The decimal point completely masks the digit separator */
1624 chars.cDigitSeparator = 0;
1625 /* Setting the thousands separator to a non-breaking space implies regular
1626 * spaces are allowed too. But the converse is not true.
1627 */
1628 cDigitSeparator2 = chars.cDigitSeparator == 0xa0 ? ' ' : 0;
1629
1630 /* First consume all the leading symbols and space from the string */
1631 while (1)
1632 {
1633 if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
1634 (*lpszStr == chars.cDecimalPoint ||
1635 *lpszStr == chars.cCurrencyDecimalPoint))
1636 {
1637 pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
1638 if (*lpszStr == chars.cCurrencyDecimalPoint &&
1639 chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
1640 pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
1641 cchUsed++;
1642 lpszStr++;
1643
1644 /* If we have no digits so far, skip leading zeros */
1645 if (!pNumprs->cDig)
1646 {
1647 while (lpszStr[1] == '0')
1648 {
1649 dwState |= B_LEADING_ZERO;
1650 cchUsed++;
1651 lpszStr++;
1652 pNumprs->nPwr10--;
1653 }
1654 }
1655 break;
1656 }
1657 else if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && iswspace(*lpszStr))
1658 {
1659 pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE;
1660 do
1661 {
1662 cchUsed++;
1663 lpszStr++;
1664 } while (iswspace(*lpszStr));
1665 }
1666 else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
1667 ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
1668 (cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
1669 {
1670 return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
1671 }
1672 else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
1673 chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
1674 {
1675 return DISP_E_TYPEMISMATCH; /* Not allowed before the first digit */
1676 }
1677 else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS &&
1678 *lpszStr == chars.cPositiveSymbol &&
1679 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS))
1680 {
1681 pNumprs->dwOutFlags |= NUMPRS_LEADING_PLUS;
1682 cchUsed++;
1683 lpszStr++;
1684 }
1685 else if (pNumprs->dwInFlags & NUMPRS_LEADING_MINUS &&
1686 *lpszStr == chars.cNegativeSymbol &&
1687 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS))
1688 {
1689 pNumprs->dwOutFlags |= (NUMPRS_LEADING_MINUS|NUMPRS_NEG);
1690 cchUsed++;
1691 lpszStr++;
1692 }
1693 else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
1694 !(pNumprs->dwOutFlags & NUMPRS_CURRENCY) &&
1695 wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
1696 {
1697 pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
1698 cchUsed += chars.sCurrencyLen;
1699 lpszStr += chars.sCurrencyLen;
1700 }
1701 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == '(' &&
1702 !(pNumprs->dwOutFlags & NUMPRS_PARENS))
1703 {
1704 pNumprs->dwOutFlags |= NUMPRS_PARENS;
1705 cchUsed++;
1706 lpszStr++;
1707 }
1708 else
1709 break;
1710 }
1711
1712 if (!(pNumprs->dwOutFlags & (NUMPRS_CURRENCY|NUMPRS_DECIMAL)))
1713 {
1714 if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) &&
1715 pNumprs->dwInFlags & NUMPRS_HEX_OCT)
1716 {
1717 dwState |= B_PROCESSING_HEX;
1718 pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
1719 cchUsed=cchUsed+2;
1720 lpszStr=lpszStr+2;
1721 }
1722 else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) &&
1723 pNumprs->dwInFlags & NUMPRS_HEX_OCT)
1724 {
1725 dwState |= B_PROCESSING_OCT;
1726 pNumprs->dwOutFlags |= NUMPRS_HEX_OCT;
1727 cchUsed=cchUsed+2;
1728 lpszStr=lpszStr+2;
1729 }
1730 }
1731
1732 /* Strip Leading zeros */
1733 while (*lpszStr == '0')
1734 {
1735 dwState |= B_LEADING_ZERO;
1736 cchUsed++;
1737 lpszStr++;
1738 }
1739
1740 while (*lpszStr)
1741 {
1742 if (is_digit(*lpszStr))
1743 {
1744 if (dwState & B_PROCESSING_EXPONENT)
1745 {
1746 int exponentSize = 0;
1747 if (dwState & B_EXPONENT_START)
1748 {
1749 if (!is_digit(*lpszStr))
1750 break; /* No exponent digits - invalid */
1751 while (*lpszStr == '0')
1752 {
1753 /* Skip leading zero's in the exponent */
1754 cchUsed++;
1755 lpszStr++;
1756 }
1757 }
1758
1759 while (is_digit(*lpszStr))
1760 {
1761 exponentSize *= 10;
1762 exponentSize += *lpszStr - '0';
1763 cchUsed++;
1764 lpszStr++;
1765 }
1766 if (dwState & B_NEGATIVE_EXPONENT)
1767 exponentSize = -exponentSize;
1768 /* Add the exponent into the powers of 10 */
1769 pNumprs->nPwr10 += exponentSize;
1770 dwState &= ~(B_PROCESSING_EXPONENT|B_EXPONENT_START);
1771 lpszStr--; /* back up to allow processing of next char */
1772 }
1773 else
1774 {
1775 if ((pNumprs->cDig >= iMaxDigits) && !(dwState & B_PROCESSING_HEX)
1776 && !(dwState & B_PROCESSING_OCT))
1777 {
1778 pNumprs->dwOutFlags |= NUMPRS_INEXACT;
1779
1780 if (*lpszStr != '0')
1781 dwState &= ~B_INEXACT_ZEROS; /* Inexact number with non-trailing zeros */
1782
1783 /* This digit can't be represented, but count it in nPwr10 */
1784 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1785 pNumprs->nPwr10--;
1786 else
1787 pNumprs->nPwr10++;
1788 }
1789 else
1790 {
1791 if ((dwState & B_PROCESSING_OCT) && ((*lpszStr == '8') || (*lpszStr == '9')))
1792 break;
1793
1794 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL)
1795 pNumprs->nPwr10--; /* Count decimal points in nPwr10 */
1796
1797 rgbTmp[pNumprs->cDig] = *lpszStr - '0';
1798 }
1799 pNumprs->cDig++;
1800 cchUsed++;
1801 }
1802 }
1803 else if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
1804 !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
1805 ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
1806 (cDigitSeparator2 && *lpszStr == cDigitSeparator2)))
1807 {
1808 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
1809 cchUsed++;
1810 }
1811 else if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
1812 !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
1813 chars.cCurrencyDigitSeparator && *lpszStr == chars.cCurrencyDigitSeparator)
1814 {
1815 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
1816 cchUsed++;
1817 }
1818 else if (pNumprs->dwInFlags & NUMPRS_DECIMAL &&
1819 (*lpszStr == chars.cDecimalPoint ||
1820 *lpszStr == chars.cCurrencyDecimalPoint) &&
1821 !(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_DECIMAL|NUMPRS_EXPONENT)))
1822 {
1823 pNumprs->dwOutFlags |= NUMPRS_DECIMAL;
1824 if (*lpszStr == chars.cCurrencyDecimalPoint &&
1825 chars.cDecimalPoint != chars.cCurrencyDecimalPoint)
1826 pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
1827 cchUsed++;
1828
1829 /* If we have no digits so far, skip leading zeros */
1830 if (!pNumprs->cDig)
1831 {
1832 while (lpszStr[1] == '0')
1833 {
1834 dwState |= B_LEADING_ZERO;
1835 cchUsed++;
1836 lpszStr++;
1837 pNumprs->nPwr10--;
1838 }
1839 }
1840 }
1841 else if (((*lpszStr >= 'a' && *lpszStr <= 'f') ||
1842 (*lpszStr >= 'A' && *lpszStr <= 'F')) &&
1843 dwState & B_PROCESSING_HEX)
1844 {
1845 if (pNumprs->cDig >= iMaxDigits)
1846 {
1847 return DISP_E_OVERFLOW;
1848 }
1849 else
1850 {
1851 if (*lpszStr >= 'a')
1852 rgbTmp[pNumprs->cDig] = *lpszStr - 'a' + 10;
1853 else
1854 rgbTmp[pNumprs->cDig] = *lpszStr - 'A' + 10;
1855 }
1856 pNumprs->cDig++;
1857 cchUsed++;
1858 }
1859 else if ((*lpszStr == 'e' || *lpszStr == 'E') &&
1860 pNumprs->dwInFlags & NUMPRS_EXPONENT &&
1861 !(pNumprs->dwOutFlags & (NUMPRS_HEX_OCT|NUMPRS_CURRENCY|NUMPRS_EXPONENT)))
1862 {
1863 dwState |= B_PROCESSING_EXPONENT;
1864 pNumprs->dwOutFlags |= NUMPRS_EXPONENT;
1865 cchUsed++;
1866 }
1867 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cPositiveSymbol)
1868 {
1869 cchUsed++; /* Ignore positive exponent */
1870 }
1871 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cNegativeSymbol)
1872 {
1873 dwState |= B_NEGATIVE_EXPONENT;
1874 cchUsed++;
1875 }
1876 else
1877 break; /* Stop at an unrecognised character */
1878
1879 lpszStr++;
1880 }
1881
1882 if (!pNumprs->cDig && dwState & B_LEADING_ZERO)
1883 {
1884 /* Ensure a 0 on its own gets stored */
1885 pNumprs->cDig = 1;
1886 rgbTmp[0] = 0;
1887 }
1888
1889 if (pNumprs->dwOutFlags & NUMPRS_EXPONENT && dwState & B_PROCESSING_EXPONENT)
1890 {
1891 pNumprs->cchUsed = cchUsed;
1892 WARN("didn't completely parse exponent\n");
1893 return DISP_E_TYPEMISMATCH; /* Failed to completely parse the exponent */
1894 }
1895
1896 if (pNumprs->dwOutFlags & NUMPRS_INEXACT)
1897 {
1898 if (dwState & B_INEXACT_ZEROS)
1899 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* All zeros doesn't set NUMPRS_INEXACT */
1900 } else if(pNumprs->dwInFlags & NUMPRS_HEX_OCT)
1901 {
1902 /* copy all of the digits into the output digit buffer */
1903 /* this is exactly what windows does although it also returns */
1904 /* cDig of X and writes X+Y where Y>=0 number of digits to rgbDig */
1905 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE));
1906
1907 if (dwState & B_PROCESSING_HEX) {
1908 /* hex numbers have always the same format */
1909 pNumprs->nPwr10=0;
1910 pNumprs->nBaseShift=4;
1911 } else {
1912 if (dwState & B_PROCESSING_OCT) {
1913 /* oct numbers have always the same format */
1914 pNumprs->nPwr10=0;
1915 pNumprs->nBaseShift=3;
1916 } else {
1917 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1])
1918 {
1919 pNumprs->nPwr10++;
1920 pNumprs->cDig--;
1921 }
1922 }
1923 }
1924 } else
1925 {
1926 /* Remove trailing zeros from the last (whole number or decimal) part */
1927 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1])
1928 {
1929 pNumprs->nPwr10++;
1930 pNumprs->cDig--;
1931 }
1932 }
1933
1934 if (pNumprs->cDig <= iMaxDigits)
1935 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* Ignore stripped zeros for NUMPRS_INEXACT */
1936 else
1937 pNumprs->cDig = iMaxDigits; /* Only return iMaxDigits worth of digits */
1938
1939 /* Copy the digits we processed into rgbDig */
1940 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE));
1941
1942 /* Consume any trailing symbols and space */
1943 while (1)
1944 {
1945 if ((chars.cDigitSeparator && *lpszStr == chars.cDigitSeparator) ||
1946 (cDigitSeparator2 && *lpszStr == cDigitSeparator2))
1947 {
1948 if (pNumprs->dwInFlags & NUMPRS_THOUSANDS &&
1949 !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
1950 {
1951 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS;
1952 cchUsed++;
1953 lpszStr++;
1954 }
1955 else
1956 {
1957 /* Not allowed, even with NUMPRS_TRAILING_WHITE */
1958 break;
1959 }
1960 }
1961 else if (*lpszStr == chars.cCurrencyDigitSeparator)
1962 {
1963 if ((pNumprs->dwInFlags & (NUMPRS_THOUSANDS|NUMPRS_CURRENCY)) == (NUMPRS_THOUSANDS|NUMPRS_CURRENCY) &&
1964 !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT))
1965 {
1966 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS|NUMPRS_CURRENCY;
1967 cchUsed++;
1968 lpszStr++;
1969 }
1970 else
1971 {
1972 /* Not allowed, even with NUMPRS_TRAILING_WHITE */
1973 break;
1974 }
1975 }
1976 else if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && iswspace(*lpszStr))
1977 {
1978 pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE;
1979 do
1980 {
1981 cchUsed++;
1982 lpszStr++;
1983 } while (iswspace(*lpszStr));
1984 }
1985 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_PLUS &&
1986 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS) &&
1987 *lpszStr == chars.cPositiveSymbol)
1988 {
1989 pNumprs->dwOutFlags |= NUMPRS_TRAILING_PLUS;
1990 cchUsed++;
1991 lpszStr++;
1992 }
1993 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_MINUS &&
1994 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS) &&
1995 *lpszStr == chars.cNegativeSymbol)
1996 {
1997 pNumprs->dwOutFlags |= (NUMPRS_TRAILING_MINUS|NUMPRS_NEG);
1998 cchUsed++;
1999 lpszStr++;
2000 }
2001 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == ')' &&
2002 pNumprs->dwOutFlags & NUMPRS_PARENS)
2003 {
2004 cchUsed++;
2005 lpszStr++;
2006 pNumprs->dwOutFlags |= NUMPRS_NEG;
2007 }
2008 else if (pNumprs->dwInFlags & NUMPRS_CURRENCY &&
2009 !(pNumprs->dwOutFlags & NUMPRS_HEX_OCT) &&
2010 wcsncmp(lpszStr, chars.sCurrency, chars.sCurrencyLen) == 0)
2011 {
2012 pNumprs->dwOutFlags |= NUMPRS_CURRENCY;
2013 cchUsed += chars.sCurrencyLen;
2014 lpszStr += chars.sCurrencyLen;
2015 }
2016 else
2017 break;
2018 }
2019
2020 if (pNumprs->dwOutFlags & NUMPRS_PARENS && !(pNumprs->dwOutFlags & NUMPRS_NEG))
2021 {
2022 pNumprs->cchUsed = cchUsed;
2023 return DISP_E_TYPEMISMATCH; /* Opening parenthesis not matched */
2024 }
2025
2026 if (pNumprs->dwInFlags & NUMPRS_USE_ALL && *lpszStr != '\0')
2027 return DISP_E_TYPEMISMATCH; /* Not all chars were consumed */
2028
2029 if (!pNumprs->cDig)
2030 return DISP_E_TYPEMISMATCH; /* No Number found */
2031
2032 pNumprs->cchUsed = cchUsed;
2033 return S_OK;
2034 }
2035
2036 /* VTBIT flags indicating an integer value */
2037 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
2038 /* VTBIT flags indicating a real number value */
2039 #define REAL_VTBITS (VTBIT_R4|VTBIT_R8|VTBIT_CY)
2040
2041 /* Helper macros to check whether bit pattern fits in VARIANT (x is a ULONG64 ) */
2042 #define FITS_AS_I1(x) ((x) >> 8 == 0)
2043 #define FITS_AS_I2(x) ((x) >> 16 == 0)
2044 #define FITS_AS_I4(x) ((x) >> 32 == 0)
2045
2046 /**********************************************************************
2047 * VarNumFromParseNum [OLEAUT32.47]
2048 *
2049 * Convert a NUMPARSE structure into a numeric Variant type.
2050 *
2051 * PARAMS
2052 * pNumprs [I] Source for parsed number. cDig must be set to the size of rgbDig
2053 * rgbDig [I] Source for the numbers digits
2054 * dwVtBits [I] VTBIT_ flags from "oleauto.h" indicating the acceptable dest types
2055 * pVarDst [O] Destination for the converted Variant value.
2056 *
2057 * RETURNS
2058 * Success: S_OK. pVarDst contains the converted value.
2059 * Failure: E_INVALIDARG, if any parameter is invalid.
2060 * DISP_E_OVERFLOW, if the number is too big for the types set in dwVtBits.
2061 *
2062 * NOTES
2063 * - The smallest favoured type present in dwVtBits that can represent the
2064 * number in pNumprs without losing precision is used.
2065 * - Signed types are preferred over unsigned types of the same size.
2066 * - Preferred types in order are: integer, float, double, currency then decimal.
2067 * - Rounding (dropping of decimal points) occurs without error. See VarI8FromR8()
2068 * for details of the rounding method.
2069 * - pVarDst is not cleared before the result is stored in it.
2070 * - WinXP and Win2003 support VTBIT_I8, VTBIT_UI8 but that's buggy (by
2071 * design?): If some other VTBIT's for integers are specified together
2072 * with VTBIT_I8 and the number will fit only in a VT_I8 Windows will "cast"
2073 * the number to the smallest requested integer truncating this way the
2074 * number. Wine doesn't implement this "feature" (yet?).
2075 */
2076 HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig,
2077 ULONG dwVtBits, VARIANT *pVarDst)
2078 {
2079 /* Scale factors and limits for double arithmetic */
2080 static const double dblMultipliers[11] = {
2081 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0,
2082 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0
2083 };
2084 static const double dblMinimums[11] = {
2085 R8_MIN, R8_MIN*10.0, R8_MIN*100.0, R8_MIN*1000.0, R8_MIN*10000.0,
2086 R8_MIN*100000.0, R8_MIN*1000000.0, R8_MIN*10000000.0,
2087 R8_MIN*100000000.0, R8_MIN*1000000000.0, R8_MIN*10000000000.0
2088 };
2089 static const double dblMaximums[11] = {
2090 R8_MAX, R8_MAX/10.0, R8_MAX/100.0, R8_MAX/1000.0, R8_MAX/10000.0,
2091 R8_MAX/100000.0, R8_MAX/1000000.0, R8_MAX/10000000.0,
2092 R8_MAX/100000000.0, R8_MAX/1000000000.0, R8_MAX/10000000000.0
2093 };
2094
2095 int wholeNumberDigits, fractionalDigits, divisor10 = 0, multiplier10 = 0;
2096
2097 TRACE("(%p,%p,0x%x,%p)\n", pNumprs, rgbDig, dwVtBits, pVarDst);
2098
2099 if (pNumprs->nBaseShift)
2100 {
2101 /* nBaseShift indicates a hex or octal number */
2102 ULONG64 ul64 = 0;
2103 LONG64 l64;
2104 int i;
2105
2106 /* Convert the hex or octal number string into a UI64 */
2107 for (i = 0; i < pNumprs->cDig; i++)
2108 {
2109 if (ul64 > ((UI8_MAX>>pNumprs->nBaseShift) - rgbDig[i]))
2110 {
2111 TRACE("Overflow multiplying digits\n");
2112 return DISP_E_OVERFLOW;
2113 }
2114 ul64 = (ul64<<pNumprs->nBaseShift) + rgbDig[i];
2115 }
2116
2117 /* also make a negative representation */
2118 l64=-ul64;
2119
2120 /* Try signed and unsigned types in size order */
2121 if (dwVtBits & VTBIT_I1 && FITS_AS_I1(ul64))
2122 {
2123 V_VT(pVarDst) = VT_I1;
2124 V_I1(pVarDst) = ul64;
2125 return S_OK;
2126 }
2127 else if (dwVtBits & VTBIT_UI1 && FITS_AS_I1(ul64))
2128 {
2129 V_VT(pVarDst) = VT_UI1;
2130 V_UI1(pVarDst) = ul64;
2131 return S_OK;
2132 }
2133 else if (dwVtBits & VTBIT_I2 && FITS_AS_I2(ul64))
2134 {
2135 V_VT(pVarDst) = VT_I2;
2136 V_I2(pVarDst) = ul64;
2137 return S_OK;
2138 }
2139 else if (dwVtBits & VTBIT_UI2 && FITS_AS_I2(ul64))
2140 {
2141 V_VT(pVarDst) = VT_UI2;
2142 V_UI2(pVarDst) = ul64;
2143 return S_OK;
2144 }
2145 else if (dwVtBits & VTBIT_I4 && FITS_AS_I4(ul64))
2146 {
2147 V_VT(pVarDst) = VT_I4;
2148 V_I4(pVarDst) = ul64;
2149 return S_OK;
2150 }
2151 else if (dwVtBits & VTBIT_UI4 && FITS_AS_I4(ul64))
2152 {
2153 V_VT(pVarDst) = VT_UI4;
2154 V_UI4(pVarDst) = ul64;
2155 return S_OK;
2156 }
2157 else if (dwVtBits & VTBIT_I8 && ((ul64 <= I8_MAX)||(l64>=I8_MIN)))
2158 {
2159 V_VT(pVarDst) = VT_I8;
2160 V_I8(pVarDst) = ul64;
2161 return S_OK;
2162 }
2163 else if (dwVtBits & VTBIT_UI8)
2164 {
2165 V_VT(pVarDst) = VT_UI8;
2166 V_UI8(pVarDst) = ul64;
2167 return S_OK;
2168 }
2169 else if ((dwVtBits & VTBIT_DECIMAL) == VTBIT_DECIMAL)
2170 {
2171 V_VT(pVarDst) = VT_DECIMAL;
2172 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
2173 DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
2174 DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
2175 return S_OK;
2176 }
2177 else if (dwVtBits & VTBIT_R4 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN)))
2178 {
2179 V_VT(pVarDst) = VT_R4;
2180 if (ul64 <= I4_MAX)
2181 V_R4(pVarDst) = ul64;
2182 else
2183 V_R4(pVarDst) = l64;
2184 return S_OK;
2185 }
2186 else if (dwVtBits & VTBIT_R8 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN)))
2187 {
2188 V_VT(pVarDst) = VT_R8;
2189 if (ul64 <= I4_MAX)
2190 V_R8(pVarDst) = ul64;
2191 else
2192 V_R8(pVarDst) = l64;
2193 return S_OK;
2194 }
2195
2196 TRACE("Overflow: possible return types: 0x%x, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64));
2197 return DISP_E_OVERFLOW;
2198 }
2199
2200 /* Count the number of relevant fractional and whole digits stored,
2201 * And compute the divisor/multiplier to scale the number by.
2202 */
2203 if (pNumprs->nPwr10 < 0)
2204 {
2205 if (-pNumprs->nPwr10 >= pNumprs->cDig)
2206 {
2207 /* A real number < +/- 1.0 e.g. 0.1024 or 0.01024 */
2208 wholeNumberDigits = 0;
2209 fractionalDigits = pNumprs->cDig;
2210 divisor10 = -pNumprs->nPwr10;
2211 }
2212 else
2213 {
2214 /* An exactly represented real number e.g. 1.024 */
2215 wholeNumberDigits = pNumprs->cDig + pNumprs->nPwr10;
2216 fractionalDigits = pNumprs->cDig - wholeNumberDigits;
2217 divisor10 = pNumprs->cDig - wholeNumberDigits;
2218 }
2219 }
2220 else if (pNumprs->nPwr10 == 0)
2221 {
2222 /* An exactly represented whole number e.g. 1024 */
2223 wholeNumberDigits = pNumprs->cDig;
2224 fractionalDigits = 0;
2225 }
2226 else /* pNumprs->nPwr10 > 0 */
2227 {
2228 /* A whole number followed by nPwr10 0's e.g. 102400 */
2229 wholeNumberDigits = pNumprs->cDig;
2230 fractionalDigits = 0;
2231 multiplier10 = pNumprs->nPwr10;
2232 }
2233
2234 TRACE("cDig %d; nPwr10 %d, whole %d, frac %d mult %d; div %d\n",
2235 pNumprs->cDig, pNumprs->nPwr10, wholeNumberDigits, fractionalDigits,
2236 multiplier10, divisor10);
2237
2238 if (dwVtBits & (INTEGER_VTBITS|VTBIT_DECIMAL) &&
2239 (!fractionalDigits || !(dwVtBits & (REAL_VTBITS|VTBIT_DECIMAL))))
2240 {
2241 /* We have one or more integer output choices, and either:
2242 * 1) An integer input value, or
2243 * 2) A real number input value but no floating output choices.
2244 * Alternately, we have a DECIMAL output available and an integer input.
2245 *
2246 * So, place the integer value into pVarDst, using the smallest type
2247 * possible and preferring signed over unsigned types.
2248 */
2249 BOOL bOverflow = FALSE, bNegative;
2250 ULONG64 ul64 = 0;
2251 int i;
2252
2253 /* Convert the integer part of the number into a UI8 */
2254 for (i = 0; i < wholeNumberDigits; i++)
2255 {
2256 if (ul64 > UI8_MAX / 10 || (ul64 == UI8_MAX / 10 && rgbDig[i] > UI8_MAX % 10))
2257 {
2258 TRACE("Overflow multiplying digits\n");
2259 bOverflow = TRUE;
2260 break;
2261 }
2262 ul64 = ul64 * 10 + rgbDig[i];
2263 }
2264
2265 /* Account for the scale of the number */
2266 if (!bOverflow && multiplier10)
2267 {
2268 for (i = 0; i < multiplier10; i++)
2269 {
2270 if (ul64 > (UI8_MAX / 10))
2271 {
2272 TRACE("Overflow scaling number\n");
2273 bOverflow = TRUE;
2274 break;
2275 }
2276 ul64 = ul64 * 10;
2277 }
2278 }
2279
2280 /* If we have any fractional digits, round the value.
2281 * Note we don't have to do this if divisor10 is < 1,
2282 * because this means the fractional part must be < 0.5
2283 */
2284 if (!bOverflow && fractionalDigits && divisor10 > 0)
2285 {
2286 const BYTE* fracDig = rgbDig + wholeNumberDigits;
2287 BOOL bAdjust = FALSE;
2288
2289 TRACE("first decimal value is %d\n", *fracDig);
2290
2291 if (*fracDig > 5)
2292 bAdjust = TRUE; /* > 0.5 */
2293 else if (*fracDig == 5)
2294 {
2295 for (i = 1; i < fractionalDigits; i++)
2296 {
2297 if (fracDig[i])
2298 {
2299 bAdjust = TRUE; /* > 0.5 */
2300 break;
2301 }
2302 }
2303 /* If exactly 0.5, round only odd values */
2304 if (i == fractionalDigits && (ul64 & 1))
2305 bAdjust = TRUE;
2306 }
2307
2308 if (bAdjust)
2309 {
2310 if (ul64 == UI8_MAX)
2311 {
2312 TRACE("Overflow after rounding\n");
2313 bOverflow = TRUE;
2314 }
2315 ul64++;
2316 }
2317 }
2318
2319 /* Zero is not a negative number */
2320 bNegative = pNumprs->dwOutFlags & NUMPRS_NEG && ul64;
2321
2322 TRACE("Integer value is 0x%s, bNeg %d\n", wine_dbgstr_longlong(ul64), bNegative);
2323
2324 /* For negative integers, try the signed types in size order */
2325 if (!bOverflow && bNegative)
2326 {
2327 if (dwVtBits & (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8))
2328 {
2329 if (dwVtBits & VTBIT_I1 && ul64 <= -I1_MIN)
2330 {
2331 V_VT(pVarDst) = VT_I1;
2332 V_I1(pVarDst) = -ul64;
2333 return S_OK;
2334 }
2335 else if (dwVtBits & VTBIT_I2 && ul64 <= -I2_MIN)
2336 {
2337 V_VT(pVarDst) = VT_I2;
2338 V_I2(pVarDst) = -ul64;
2339 return S_OK;
2340 }
2341 else if (dwVtBits & VTBIT_I4 && ul64 <= -((LONGLONG)I4_MIN))
2342 {
2343 V_VT(pVarDst) = VT_I4;
2344 V_I4(pVarDst) = -ul64;
2345 return S_OK;
2346 }
2347 else if (dwVtBits & VTBIT_I8 && ul64 <= (ULONGLONG)I8_MAX + 1)
2348 {
2349 V_VT(pVarDst) = VT_I8;
2350 V_I8(pVarDst) = -ul64;
2351 return S_OK;
2352 }
2353 else if ((dwVtBits & (REAL_VTBITS|VTBIT_DECIMAL)) == VTBIT_DECIMAL)
2354 {
2355 /* Decimal is only output choice left - fast path */
2356 V_VT(pVarDst) = VT_DECIMAL;
2357 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_NEG,0);
2358 DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
2359 DEC_LO64(&V_DECIMAL(pVarDst)) = -ul64;
2360 return S_OK;
2361 }
2362 }
2363 }
2364 else if (!bOverflow)
2365 {
2366 /* For positive integers, try signed then unsigned types in size order */
2367 if (dwVtBits & VTBIT_I1 && ul64 <= I1_MAX)
2368 {
2369 V_VT(pVarDst) = VT_I1;
2370 V_I1(pVarDst) = ul64;
2371 return S_OK;
2372 }
2373 else if (dwVtBits & VTBIT_UI1 && ul64 <= UI1_MAX)
2374 {
2375 V_VT(pVarDst) = VT_UI1;
2376 V_UI1(pVarDst) = ul64;
2377 return S_OK;
2378 }
2379 else if (dwVtBits & VTBIT_I2 && ul64 <= I2_MAX)
2380 {
2381 V_VT(pVarDst) = VT_I2;
2382 V_I2(pVarDst) = ul64;
2383 return S_OK;
2384 }
2385 else if (dwVtBits & VTBIT_UI2 && ul64 <= UI2_MAX)
2386 {
2387 V_VT(pVarDst) = VT_UI2;
2388 V_UI2(pVarDst) = ul64;
2389 return S_OK;
2390 }
2391 else if (dwVtBits & VTBIT_I4 && ul64 <= I4_MAX)
2392 {
2393 V_VT(pVarDst) = VT_I4;
2394 V_I4(pVarDst) = ul64;
2395 return S_OK;
2396 }
2397 else if (dwVtBits & VTBIT_UI4 && ul64 <= UI4_MAX)
2398 {
2399 V_VT(pVarDst) = VT_UI4;
2400 V_UI4(pVarDst) = ul64;
2401 return S_OK;
2402 }
2403 else if (dwVtBits & VTBIT_I8 && ul64 <= I8_MAX)
2404 {
2405 V_VT(pVarDst) = VT_I8;
2406 V_I8(pVarDst) = ul64;
2407 return S_OK;
2408 }
2409 else if (dwVtBits & VTBIT_UI8)
2410 {
2411 V_VT(pVarDst) = VT_UI8;
2412 V_UI8(pVarDst) = ul64;
2413 return S_OK;
2414 }
2415 else if ((dwVtBits & (REAL_VTBITS|VTBIT_DECIMAL)) == VTBIT_DECIMAL)
2416 {
2417 /* Decimal is only output choice left - fast path */
2418 V_VT(pVarDst) = VT_DECIMAL;
2419 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0);
2420 DEC_HI32(&V_DECIMAL(pVarDst)) = 0;
2421 DEC_LO64(&V_DECIMAL(pVarDst)) = ul64;
2422 return S_OK;
2423 }
2424 }
2425 }
2426
2427 if (dwVtBits & REAL_VTBITS)
2428 {
2429 /* Try to put the number into a float or real */
2430 BOOL bOverflow = FALSE, bNegative = pNumprs->dwOutFlags & NUMPRS_NEG;
2431 double whole = 0.0;
2432 int i;
2433
2434 /* Convert the number into a double */
2435 for (i = 0; i < pNumprs->cDig; i++)
2436 whole = whole * 10.0 + rgbDig[i];
2437
2438 TRACE("Whole double value is %16.16g\n", whole);
2439
2440 /* Account for the scale */
2441 while (multiplier10 > 10)
2442 {
2443 if (whole > dblMaximums[10])
2444 {
2445 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY);
2446 bOverflow = TRUE;
2447 break;
2448 }
2449 whole = whole * dblMultipliers[10];
2450 multiplier10 -= 10;
2451 }
2452 if (multiplier10 && !bOverflow)
2453 {
2454 if (whole > dblMaximums[multiplier10])
2455 {
2456 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY);
2457 bOverflow = TRUE;
2458 }
2459 else
2460 whole = whole * dblMultipliers[multiplier10];
2461 }
2462
2463 if (!bOverflow)
2464 TRACE("Scaled double value is %16.16g\n", whole);
2465
2466 while (divisor10 > 10 && !bOverflow)
2467 {
2468 if (whole < dblMinimums[10] && whole != 0)
2469 {
2470 whole = 0; /* ignore underflow */
2471 divisor10 = 0;
2472 break;
2473 }
2474 whole = whole / dblMultipliers[10];
2475 divisor10 -= 10;
2476 }
2477 if (divisor10 && !bOverflow)
2478 {
2479 if (whole < dblMinimums[divisor10] && whole != 0)
2480 {
2481 whole = 0; /* ignore underflow */
2482 divisor10 = 0;
2483 }
2484 else
2485 whole = whole / dblMultipliers[divisor10];
2486 }
2487 if (!bOverflow)
2488 TRACE("Final double value is %16.16g\n", whole);
2489
2490 if (dwVtBits & VTBIT_R4 &&
2491 ((whole <= R4_MAX && whole >= R4_MIN) || whole == 0.0))
2492 {
2493 TRACE("Set R4 to final value\n");
2494 V_VT(pVarDst) = VT_R4; /* Fits into a float */
2495 V_R4(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole;
2496 return S_OK;
2497 }
2498
2499 if (dwVtBits & VTBIT_R8)
2500 {
2501 TRACE("Set R8 to final value\n");
2502 V_VT(pVarDst) = VT_R8; /* Fits into a double */
2503 V_R8(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole;
2504 return S_OK;
2505 }
2506
2507 if (dwVtBits & VTBIT_CY)
2508 {
2509 if (SUCCEEDED(VarCyFromR8(bNegative ? -whole : whole, &V_CY(pVarDst))))
2510 {
2511 V_VT(pVarDst) = VT_CY; /* Fits into a currency */
2512 TRACE("Set CY to final value\n");
2513 return S_OK;
2514 }
2515 TRACE("Value Overflows CY\n");
2516 }
2517 }
2518
2519 if (dwVtBits & VTBIT_DECIMAL)
2520 {
2521 int i;
2522 ULONG carry;
2523 ULONG64 tmp;
2524 DECIMAL* pDec = &V_DECIMAL(pVarDst);
2525
2526 DECIMAL_SETZERO(*pDec);
2527 DEC_LO32(pDec) = 0;
2528
2529 if (pNumprs->dwOutFlags & NUMPRS_NEG)
2530 DEC_SIGN(pDec) = DECIMAL_NEG;
2531 else
2532 DEC_SIGN(pDec) = DECIMAL_POS;
2533
2534 /* Factor the significant digits */
2535 for (i = 0; i < pNumprs->cDig; i++)
2536 {
2537 tmp = (ULONG64)DEC_LO32(pDec) * 10 + rgbDig[i];
2538 carry = (ULONG)(tmp >> 32);
2539 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
2540 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
2541 carry = (ULONG)(tmp >> 32);
2542 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
2543 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
2544 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
2545
2546 if (tmp >> 32 & UI4_MAX)
2547 {
2548 VarNumFromParseNum_DecOverflow:
2549 TRACE("Overflow\n");
2550 DEC_LO32(pDec) = DEC_MID32(pDec) = DEC_HI32(pDec) = UI4_MAX;
2551 return DISP_E_OVERFLOW;
2552 }
2553 }
2554
2555 /* Account for the scale of the number */
2556 while (multiplier10 > 0)
2557 {
2558 tmp = (ULONG64)DEC_LO32(pDec) * 10;
2559 carry = (ULONG)(tmp >> 32);
2560 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX);
2561 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry;
2562 carry = (ULONG)(tmp >> 32);
2563 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX);
2564 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry;
2565 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX);
2566
2567 if (tmp >> 32 & UI4_MAX)
2568 goto VarNumFromParseNum_DecOverflow;
2569 multiplier10--;
2570 }
2571 DEC_SCALE(pDec) = divisor10;
2572
2573 V_VT(pVarDst) = VT_DECIMAL;
2574 return S_OK;
2575 }
2576 return DISP_E_OVERFLOW; /* No more output choices */
2577 }
2578
2579 /**********************************************************************
2580 * VarCat [OLEAUT32.318]
2581 *
2582 * Concatenates one variant onto another.
2583 *
2584 * PARAMS
2585 * left [I] First variant
2586 * right [I] Second variant
2587 * result [O] Result variant
2588 *
2589 * RETURNS
2590 * Success: S_OK.
2591 * Failure: An HRESULT error code indicating the error.
2592 */
2593 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out)
2594 {
2595 BSTR left_str = NULL, right_str = NULL;
2596 VARTYPE leftvt, rightvt;
2597 HRESULT hres;
2598
2599 TRACE("%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), out);
2600
2601 leftvt = V_VT(left);
2602 rightvt = V_VT(right);
2603
2604 /* when both left and right are NULL the result is NULL */
2605 if (leftvt == VT_NULL && rightvt == VT_NULL)
2606 {
2607 V_VT(out) = VT_NULL;
2608 return S_OK;
2609 }
2610
2611 /* There are many special case for errors and return types */
2612 if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
2613 rightvt == VT_DATE || rightvt == VT_DECIMAL))
2614 hres = DISP_E_TYPEMISMATCH;
2615 else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
2616 leftvt == VT_R4 || leftvt == VT_R8 ||
2617 leftvt == VT_CY || leftvt == VT_BOOL ||
2618 leftvt == VT_BSTR || leftvt == VT_I1 ||
2619 leftvt == VT_UI1 || leftvt == VT_UI2 ||
2620 leftvt == VT_UI4 || leftvt == VT_I8 ||
2621 leftvt == VT_UI8 || leftvt == VT_INT ||
2622 leftvt == VT_UINT || leftvt == VT_EMPTY ||
2623 leftvt == VT_NULL || leftvt == VT_DATE ||
2624 leftvt == VT_DECIMAL || leftvt == VT_DISPATCH)
2625 &&
2626 (rightvt == VT_I2 || rightvt == VT_I4 ||
2627 rightvt == VT_R4 || rightvt == VT_R8 ||
2628 rightvt == VT_CY || rightvt == VT_BOOL ||
2629 rightvt == VT_BSTR || rightvt == VT_I1 ||
2630 rightvt == VT_UI1 || rightvt == VT_UI2 ||
2631 rightvt == VT_UI4 || rightvt == VT_I8 ||
2632 rightvt == VT_UI8 || rightvt == VT_INT ||
2633 rightvt == VT_UINT || rightvt == VT_EMPTY ||
2634 rightvt == VT_NULL || rightvt == VT_DATE ||
2635 rightvt == VT_DECIMAL || rightvt == VT_DISPATCH))
2636 hres = S_OK;
2637 else if (rightvt == VT_ERROR && leftvt < VT_VOID)
2638 hres = DISP_E_TYPEMISMATCH;
2639 else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
2640 rightvt == VT_ERROR || rightvt == VT_DECIMAL))
2641 hres = DISP_E_TYPEMISMATCH;
2642 else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
2643 rightvt == VT_DECIMAL)
2644 hres = DISP_E_BADVARTYPE;
2645 else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
2646 hres = DISP_E_TYPEMISMATCH;
2647 else if (leftvt == VT_VARIANT)
2648 hres = DISP_E_TYPEMISMATCH;
2649 else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
2650 leftvt == VT_NULL || leftvt == VT_I2 ||
2651 leftvt == VT_I4 || leftvt == VT_R4 ||
2652 leftvt == VT_R8 || leftvt == VT_CY ||
2653 leftvt == VT_DATE || leftvt == VT_BSTR ||
2654 leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
2655 leftvt == VT_I1 || leftvt == VT_UI1 ||
2656 leftvt == VT_UI2 || leftvt == VT_UI4 ||
2657 leftvt == VT_I8 || leftvt == VT_UI8 ||
2658 leftvt == VT_INT || leftvt == VT_UINT))
2659 hres = DISP_E_TYPEMISMATCH;
2660 else
2661 hres = DISP_E_BADVARTYPE;
2662
2663 /* if result type is not S_OK, then no need to go further */
2664 if (hres != S_OK)
2665 {
2666 V_VT(out) = VT_EMPTY;
2667 return hres;
2668 }
2669
2670 if (leftvt == VT_BSTR)
2671 left_str = V_BSTR(left);
2672 else
2673 {
2674 VARIANT converted, *tmp = left;
2675
2676 VariantInit(&converted);
2677 if(leftvt == VT_DISPATCH)
2678 {
2679 hres = VARIANT_FetchDispatchValue(left, &converted);
2680 if(FAILED(hres))
2681 goto failed;
2682
2683 tmp = &converted;
2684 }
2685
2686 hres = VariantChangeTypeEx(&converted, tmp, 0, VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, VT_BSTR);
2687 if (SUCCEEDED(hres))
2688 left_str = V_BSTR(&converted);
2689 else if (hres != DISP_E_TYPEMISMATCH)
2690 {
2691 VariantClear(&converted);
2692 goto failed;
2693 }
2694 }
2695
2696 if (rightvt == VT_BSTR)
2697 right_str = V_BSTR(right);
2698 else
2699 {
2700 VARIANT converted, *tmp = right;
2701
2702 VariantInit(&converted);
2703 if(rightvt == VT_DISPATCH)
2704 {
2705 hres = VARIANT_FetchDispatchValue(right, &converted);
2706 if(FAILED(hres))
2707 goto failed;
2708
2709 tmp = &converted;
2710 }
2711
2712 hres = VariantChangeTypeEx(&converted, tmp, 0, VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, VT_BSTR);
2713 if (SUCCEEDED(hres))
2714 right_str = V_BSTR(&converted);
2715 else if (hres != DISP_E_TYPEMISMATCH)
2716 {
2717 VariantClear(&converted);
2718 goto failed;
2719 }
2720 }
2721
2722
2723 V_VT(out) = VT_BSTR;
2724 hres = VarBstrCat(left_str, right_str, &V_BSTR(out));
2725
2726 failed:
2727 if(V_VT(left) != VT_BSTR)
2728 SysFreeString(left_str);
2729 if(V_VT(right) != VT_BSTR)
2730 SysFreeString(right_str);
2731 return hres;
2732 }
2733
2734
2735 /* Wrapper around VariantChangeTypeEx() which permits changing a
2736 variant with VT_RESERVED flag set. Needed by VarCmp. */
2737 static HRESULT _VarChangeTypeExWrap (VARIANTARG* pvargDest,
2738 VARIANTARG* pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
2739 {
2740 VARIANTARG vtmpsrc = *pvargSrc;
2741
2742 V_VT(&vtmpsrc) &= ~VT_RESERVED;
2743 return VariantChangeTypeEx(pvargDest,&vtmpsrc,lcid,wFlags,vt);
2744 }
2745
2746 /**********************************************************************
2747 * VarCmp [OLEAUT32.176]
2748 *
2749 * Compare two variants.
2750 *
2751 * PARAMS
2752 * left [I] First variant
2753 * right [I] Second variant
2754 * lcid [I] LCID (locale identifier) for the comparison
2755 * flags [I] Flags to be used in the comparison:
2756 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS,
2757 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA
2758 *
2759 * RETURNS
2760 * VARCMP_LT: left variant is less than right variant.
2761 * VARCMP_EQ: input variants are equal.
2762 * VARCMP_GT: left variant is greater than right variant.
2763 * VARCMP_NULL: either one of the input variants is NULL.
2764 * Failure: An HRESULT error code indicating the error.
2765 *
2766 * NOTES
2767 * Native VarCmp up to and including WinXP doesn't like I1, UI2, VT_UI4,
2768 * UI8 and UINT as input variants. INT is accepted only as left variant.
2769 *
2770 * If both input variants are ERROR then VARCMP_EQ will be returned, else
2771 * an ERROR variant will trigger an error.
2772 *
2773 * Both input variants can have VT_RESERVED flag set which is ignored
2774 * unless one and only one of the variants is a BSTR and the other one
2775 * is not an EMPTY variant. All four VT_RESERVED combinations have a
2776 * different meaning:
2777 * - BSTR and other: BSTR is always greater than the other variant.
2778 * - BSTR|VT_RESERVED and other: a string comparison is performed.
2779 * - BSTR and other|VT_RESERVED: If the BSTR is a number a numeric
2780 * comparison will take place else the BSTR is always greater.
2781 * - BSTR|VT_RESERVED and other|VT_RESERVED: It seems that the other
2782 * variant is ignored and the return value depends only on the sign
2783 * of the BSTR if it is a number else the BSTR is always greater. A
2784 * positive BSTR is greater, a negative one is smaller than the other
2785 * variant.
2786 *
2787 * SEE
2788 * VarBstrCmp for the lcid and flags usage.
2789 */
2790 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
2791 {
2792 VARTYPE lvt, rvt, vt;
2793 VARIANT rv,lv;
2794 DWORD xmask;
2795 HRESULT rc;
2796
2797 TRACE("(%s,%s,0x%08x,0x%08x)\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
2798
2799 lvt = V_VT(left) & VT_TYPEMASK;
2800 rvt = V_VT(right) & VT_TYPEMASK;
2801 xmask = (1 << lvt) | (1 << rvt);
2802
2803 /* If we have any flag set except VT_RESERVED bail out.
2804 Same for the left input variant type > VT_INT and for the
2805 right input variant type > VT_I8. Yes, VT_INT is only supported
2806 as left variant. Go figure */
2807 if (((V_VT(left) | V_VT(right)) & ~VT_TYPEMASK & ~VT_RESERVED) ||
2808 lvt > VT_INT || rvt > VT_I8) {
2809 return DISP_E_BADVARTYPE;
2810 }
2811
2812 /* Don't ask me why but native VarCmp cannot handle: VT_I1, VT_UI2, VT_UI4,
2813 VT_UINT and VT_UI8. Tested with DCOM98, Win2k, WinXP */
2814 if (rvt == VT_INT || xmask & (VTBIT_I1 | VTBIT_UI2 | VTBIT_UI4 | VTBIT_UI8 |
2815 VTBIT_DISPATCH | VTBIT_VARIANT | VTBIT_UNKNOWN | VTBIT_15))
2816 return DISP_E_TYPEMISMATCH;
2817
2818 /* If both variants are VT_ERROR return VARCMP_EQ */
2819 if (xmask == VTBIT_ERROR)
2820 return VARCMP_EQ;
2821 else if (xmask & VTBIT_ERROR)
2822 return DISP_E_TYPEMISMATCH;
2823
2824 if (xmask & VTBIT_NULL)
2825 return VARCMP_NULL;
2826
2827 VariantInit(&lv);
2828 VariantInit(&rv);
2829
2830 /* Two BSTRs, ignore VT_RESERVED */
2831 if (xmask == VTBIT_BSTR)
2832 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
2833
2834 /* A BSTR and another variant; we have to take care of VT_RESERVED */
2835 if (xmask & VTBIT_BSTR) {
2836 VARIANT *bstrv, *nonbv;
2837 VARTYPE nonbvt;
2838 int swap = 0;
2839
2840 /* Swap the variants so the BSTR is always on the left */
2841 if (lvt == VT_BSTR) {
2842 bstrv = left;
2843 nonbv = right;
2844 nonbvt = rvt;
2845 } else {
2846 swap = 1;
2847 bstrv = right;
2848 nonbv = left;
2849 nonbvt = lvt;
2850 }
2851
2852 /* BSTR and EMPTY: ignore VT_RESERVED */
2853 if (nonbvt == VT_EMPTY)
2854 rc = (!V_BSTR(bstrv) || !*V_BSTR(bstrv)) ? VARCMP_EQ : VARCMP_GT;
2855 else {
2856 VARTYPE breserv = V_VT(bstrv) & ~VT_TYPEMASK;
2857 VARTYPE nreserv = V_VT(nonbv) & ~VT_TYPEMASK;
2858
2859 if (!breserv && !nreserv)
2860 /* No VT_RESERVED set ==> BSTR always greater */
2861 rc = VARCMP_GT;
2862 else if (breserv && !nreserv) {
2863 /* BSTR has VT_RESERVED set. Do a string comparison */
2864 rc = VariantChangeTypeEx(&rv,nonbv,lcid,0,VT_BSTR);
2865 if (FAILED(rc))
2866 return rc;
2867 rc = VarBstrCmp(V_BSTR(bstrv), V_BSTR(&rv), lcid, flags);
2868 VariantClear(&rv);
2869 } else if (V_BSTR(bstrv) && *V_BSTR(bstrv)) {
2870 /* Non NULL nor empty BSTR */
2871 /* If the BSTR is not a number the BSTR is greater */
2872 rc = _VarChangeTypeExWrap(&lv,bstrv,lcid,0,VT_R8);
2873 if (FAILED(rc))
2874 rc = VARCMP_GT;
2875 else if (breserv && nreserv)
2876 /* FIXME: This is strange: with both VT_RESERVED set it
2877 looks like the result depends only on the sign of
2878 the BSTR number */
2879 rc = (V_R8(&lv) >= 0) ? VARCMP_GT : VARCMP_LT;
2880 else
2881 /* Numeric comparison, will be handled below.
2882 VARCMP_NULL used only to break out. */
2883 rc = VARCMP_NULL;
2884 VariantClear(&lv);
2885 VariantClear(&rv);
2886 } else
2887 /* Empty or NULL BSTR */
2888 rc = VARCMP_GT;
2889 }
2890 /* Fixup the return code if we swapped left and right */
2891 if (swap) {
2892 if (rc == VARCMP_GT)
2893 rc = VARCMP_LT;
2894 else if (rc == VARCMP_LT)
2895 rc = VARCMP_GT;
2896 }
2897 if (rc != VARCMP_NULL)
2898 return rc;
2899 }
2900
2901 if (xmask & VTBIT_DECIMAL)
2902 vt = VT_DECIMAL;
2903 else if (xmask & VTBIT_BSTR)
2904 vt = VT_R8;
2905 else if (xmask & VTBIT_R4)
2906 vt = VT_R4;
2907 else if (xmask & (VTBIT_R8 | VTBIT_DATE))
2908 vt = VT_R8;
2909 else if (xmask & VTBIT_CY)
2910 vt = VT_CY;
2911 else
2912 /* default to I8 */
2913 vt = VT_I8;
2914
2915 /* Coerce the variants */
2916 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
2917 if (rc == DISP_E_OVERFLOW && vt != VT_R8) {
2918 /* Overflow, change to R8 */
2919 vt = VT_R8;
2920 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
2921 }
2922 if (FAILED(rc))
2923 return rc;
2924 rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt);
2925 if (rc == DISP_E_OVERFLOW && vt != VT_R8) {
2926 /* Overflow, change to R8 */
2927 vt = VT_R8;
2928 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
2929 if (FAILED(rc))
2930 return rc;
2931 rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt);
2932 }
2933 if (FAILED(rc))
2934 return rc;
2935
2936 #define _VARCMP(a,b) \
2937 (((a) == (b)) ? VARCMP_EQ : (((a) < (b)) ? VARCMP_LT : VARCMP_GT))
2938
2939 switch (vt) {
2940 case VT_CY:
2941 return VarCyCmp(V_CY(&lv), V_CY(&rv));
2942 case VT_DECIMAL:
2943 return VarDecCmp(&V_DECIMAL(&lv), &V_DECIMAL(&rv));
2944 case VT_I8:
2945 return _VARCMP(V_I8(&lv), V_I8(&rv));
2946 case VT_R4:
2947 return _VARCMP(V_R4(&lv), V_R4(&rv));
2948 case VT_R8:
2949 return _VARCMP(V_R8(&lv), V_R8(&rv));
2950 default:
2951 /* We should never get here */
2952 return E_FAIL;
2953 }
2954 #undef _VARCMP
2955 }
2956
2957 /**********************************************************************
2958 * VarAnd [OLEAUT32.142]
2959 *
2960 * Computes the logical AND of two variants.
2961 *
2962 * PARAMS
2963 * left [I] First variant
2964 * right [I] Second variant
2965 * result [O] Result variant
2966 *
2967 * RETURNS
2968 * Success: S_OK.
2969 * Failure: An HRESULT error code indicating the error.
2970 */
2971 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
2972 {
2973 HRESULT hres = S_OK;
2974 VARTYPE resvt = VT_EMPTY;
2975 VARTYPE leftvt,rightvt;
2976 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
2977 VARIANT varLeft, varRight;
2978 VARIANT tempLeft, tempRight;
2979
2980 VariantInit(&varLeft);
2981 VariantInit(&varRight);
2982 VariantInit(&tempLeft);
2983 VariantInit(&tempRight);
2984
2985 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
2986
2987 /* Handle VT_DISPATCH by storing and taking address of returned value */
2988 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
2989 {
2990 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
2991 if (FAILED(hres)) goto VarAnd_Exit;
2992 left = &tempLeft;
2993 }
2994 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
2995 {
2996 hres = VARIANT_FetchDispatchValue(right, &tempRight);
2997 if (FAILED(hres)) goto VarAnd_Exit;
2998 right = &tempRight;
2999 }
3000
3001 leftvt = V_VT(left)&VT_TYPEMASK;
3002 rightvt = V_VT(right)&VT_TYPEMASK;
3003 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
3004 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
3005
3006 if (leftExtraFlags != rightExtraFlags)
3007 {
3008 hres = DISP_E_BADVARTYPE;
3009 goto VarAnd_Exit;
3010 }
3011 ExtraFlags = leftExtraFlags;
3012
3013 /* Native VarAnd always returns an error when using extra
3014 * flags or if the variant combination is I8 and INT.
3015 */
3016 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
3017 (leftvt == VT_INT && rightvt == VT_I8) ||
3018 ExtraFlags != 0)
3019 {
3020 hres = DISP_E_BADVARTYPE;
3021 goto VarAnd_Exit;
3022 }
3023
3024 /* Determine return type */
3025 else if (leftvt == VT_I8 || rightvt == VT_I8)
3026 resvt = VT_I8;
3027 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
3028 leftvt == VT_UINT || rightvt == VT_UINT ||
3029 leftvt == VT_INT || rightvt == VT_INT ||
3030 leftvt == VT_R4 || rightvt == VT_R4 ||
3031 leftvt == VT_R8 || rightvt == VT_R8 ||
3032 leftvt == VT_CY || rightvt == VT_CY ||
3033 leftvt == VT_DATE || rightvt == VT_DATE ||
3034 leftvt == VT_I1 || rightvt == VT_I1 ||
3035 leftvt == VT_UI2 || rightvt == VT_UI2 ||
3036 leftvt == VT_UI4 || rightvt == VT_UI4 ||
3037 leftvt == VT_UI8 || rightvt == VT_UI8 ||
3038 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
3039 resvt = VT_I4;
3040 else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
3041 leftvt == VT_I2 || rightvt == VT_I2 ||
3042 leftvt == VT_EMPTY || rightvt == VT_EMPTY)
3043 if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
3044 (leftvt == VT_UI1 && rightvt == VT_NULL) ||
3045 (leftvt == VT_UI1 && rightvt == VT_UI1))
3046 resvt = VT_UI1;
3047 else
3048 resvt = VT_I2;
3049 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
3050 (leftvt == VT_BSTR && rightvt == VT_BSTR))
3051 resvt = VT_BOOL;
3052 else if (leftvt == VT_NULL || rightvt == VT_NULL ||
3053 leftvt == VT_BSTR || rightvt == VT_BSTR)
3054 resvt = VT_NULL;
3055 else
3056 {
3057 hres = DISP_E_BADVARTYPE;
3058 goto VarAnd_Exit;
3059 }
3060
3061 if (leftvt == VT_NULL || rightvt == VT_NULL)
3062 {
3063 /*
3064 * Special cases for when left variant is VT_NULL
3065 * (VT_NULL & 0 = VT_NULL, VT_NULL & value = value)
3066 */
3067 if (leftvt == VT_NULL)
3068 {
3069 VARIANT_BOOL b;
3070 switch(rightvt)
3071 {
3072 case VT_I1: if (V_I1(right)) resvt = VT_NULL; break;
3073 case VT_UI1: if (V_UI1(right)) resvt = VT_NULL; break;
3074 case VT_I2: if (V_I2(right)) resvt = VT_NULL; break;
3075 case VT_UI2: if (V_UI2(right)) resvt = VT_NULL; break;
3076 case VT_I4: if (V_I4(right)) resvt = VT_NULL; break;
3077 case VT_UI4: if (V_UI4(right)) resvt = VT_NULL; break;
3078 case VT_I8: if (V_I8(right)) resvt = VT_NULL; break;
3079 case VT_UI8: if (V_UI8(right)) resvt = VT_NULL; break;
3080 case VT_INT: if (V_INT(right)) resvt = VT_NULL; break;
3081 case VT_UINT: if (V_UINT(right)) resvt = VT_NULL; break;
3082 case VT_BOOL: if (V_BOOL(right)) resvt = VT_NULL; break;
3083 case VT_R4: if (V_R4(right)) resvt = VT_NULL; break;
3084 case VT_R8: if (V_R8(right)) resvt = VT_NULL; break;
3085 case VT_CY:
3086 if(V_CY(right).int64)
3087 resvt = VT_NULL;
3088 break;
3089 case VT_DECIMAL:
3090 if (DEC_HI32(&V_DECIMAL(right)) ||
3091 DEC_LO64(&V_DECIMAL(right)))
3092 resvt = VT_NULL;
3093 break;
3094 case VT_BSTR:
3095 hres = VarBoolFromStr(V_BSTR(right),
3096 LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b);
3097 if (FAILED(hres))
3098 return hres;
3099 else if (b)
3100 V_VT(result) = VT_NULL;
3101 else
3102 {
3103 V_VT(result) = VT_BOOL;
3104 V_BOOL(result) = b;
3105 }
3106 goto VarAnd_Exit;
3107 }
3108 }
3109 V_VT(result) = resvt;
3110 goto VarAnd_Exit;
3111 }
3112
3113 hres = VariantCopy(&varLeft, left);
3114 if (FAILED(hres)) goto VarAnd_Exit;
3115
3116 hres = VariantCopy(&varRight, right);
3117 if (FAILED(hres)) goto VarAnd_Exit;
3118
3119 if (resvt == VT_I4 && V_VT(&varLeft) == VT_UI4)
3120 V_VT(&varLeft) = VT_I4; /* Don't overflow */
3121 else
3122 {
3123 double d;
3124
3125 if (V_VT(&varLeft) == VT_BSTR &&
3126 FAILED(VarR8FromStr(V_BSTR(&varLeft),
3127 LOCALE_USER_DEFAULT, 0, &d)))
3128 hres = VariantChangeType(&varLeft,&varLeft,
3129 VARIANT_LOCALBOOL, VT_BOOL);
3130 if (SUCCEEDED(hres) && V_VT(&varLeft) != resvt)
3131 hres = VariantChangeType(&varLeft,&varLeft,0,resvt);
3132 if (FAILED(hres)) goto VarAnd_Exit;
3133 }
3134
3135 if (resvt == VT_I4 && V_VT(&varRight) == VT_UI4)
3136 V_VT(&varRight) = VT_I4; /* Don't overflow */
3137 else
3138 {
3139 double d;
3140
3141 if (V_VT(&varRight) == VT_BSTR &&
3142 FAILED(VarR8FromStr(V_BSTR(&varRight),
3143 LOCALE_USER_DEFAULT, 0, &d)))
3144 hres = VariantChangeType(&varRight, &varRight,
3145 VARIANT_LOCALBOOL, VT_BOOL);
3146 if (SUCCEEDED(hres) && V_VT(&varRight) != resvt)
3147 hres = VariantChangeType(&varRight, &varRight, 0, resvt);
3148 if (FAILED(hres)) goto VarAnd_Exit;
3149 }
3150
3151 V_VT(result) = resvt;
3152 switch(resvt)
3153 {
3154 case VT_I8:
3155 V_I8(result) = V_I8(&varLeft) & V_I8(&varRight);
3156 break;
3157 case VT_I4:
3158 V_I4(result) = V_I4(&varLeft) & V_I4(&varRight);
3159 break;
3160 case VT_I2:
3161 V_I2(result) = V_I2(&varLeft) & V_I2(&varRight);
3162 break;
3163 case VT_UI1:
3164 V_UI1(result) = V_UI1(&varLeft) & V_UI1(&varRight);
3165 break;
3166 case VT_BOOL:
3167 V_BOOL(result) = V_BOOL(&varLeft) & V_BOOL(&varRight);
3168 break;
3169 default:
3170 FIXME("Couldn't bitwise AND variant types %d,%d\n",
3171 leftvt,rightvt);
3172 }
3173
3174 VarAnd_Exit:
3175 VariantClear(&varLeft);
3176 VariantClear(&varRight);
3177 VariantClear(&tempLeft);
3178 VariantClear(&tempRight);
3179
3180 return hres;
3181 }
3182
3183 /**********************************************************************
3184 * VarAdd [OLEAUT32.141]
3185 *
3186 * Add two variants.
3187 *
3188 * PARAMS
3189 * left [I] First variant
3190 * right [I] Second variant
3191 * result [O] Result variant
3192 *
3193 * RETURNS
3194 * Success: S_OK.
3195 * Failure: An HRESULT error code indicating the error.
3196 *
3197 * NOTES
3198 * Native VarAdd up to and including WinXP doesn't like I1, UI2, UI4,
3199 * UI8, INT and UINT as input variants.
3200 *
3201 * Native VarAdd doesn't check for NULL in/out pointers and crashes. We do the
3202 * same here.
3203 *
3204 * FIXME
3205 * Overflow checking for R8 (double) overflow. Return DISP_E_OVERFLOW in that
3206 * case.
3207 */
3208 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3209 {
3210 HRESULT hres;
3211 VARTYPE lvt, rvt, resvt, tvt;
3212 VARIANT lv, rv, tv;
3213 VARIANT tempLeft, tempRight;
3214 double r8res;
3215
3216 /* Variant priority for coercion. Sorted from lowest to highest.
3217 VT_ERROR shows an invalid input variant type. */
3218 enum coerceprio { vt_EMPTY, vt_UI1, vt_I2, vt_I4, vt_I8, vt_BSTR,vt_R4,
3219 vt_R8, vt_CY, vt_DATE, vt_DECIMAL, vt_DISPATCH, vt_NULL,
3220 vt_ERROR };
3221 /* Mapping from priority to variant type. Keep in sync with coerceprio! */
3222 static const VARTYPE prio2vt[] = { VT_EMPTY, VT_UI1, VT_I2, VT_I4, VT_I8, VT_BSTR, VT_R4,
3223 VT_R8, VT_CY, VT_DATE, VT_DECIMAL, VT_DISPATCH,
3224 VT_NULL, VT_ERROR };
3225
3226 /* Mapping for coercion from input variant to priority of result variant. */
3227 static const VARTYPE coerce[] = {
3228 /* VT_EMPTY, VT_NULL, VT_I2, VT_I4, VT_R4 */
3229 vt_EMPTY, vt_NULL, vt_I2, vt_I4, vt_R4,
3230 /* VT_R8, VT_CY, VT_DATE, VT_BSTR, VT_DISPATCH */
3231 vt_R8, vt_CY, vt_DATE, vt_BSTR, vt_DISPATCH,
3232 /* VT_ERROR, VT_BOOL, VT_VARIANT, VT_UNKNOWN, VT_DECIMAL */
3233 vt_ERROR, vt_I2, vt_ERROR, vt_ERROR, vt_DECIMAL,
3234 /* 15, VT_I1, VT_UI1, VT_UI2, VT_UI4 VT_I8 */
3235 vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8
3236 };
3237
3238 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
3239
3240 VariantInit(&lv);
3241 VariantInit(&rv);
3242 VariantInit(&tv);
3243 VariantInit(&tempLeft);
3244 VariantInit(&tempRight);
3245
3246 /* Handle VT_DISPATCH by storing and taking address of returned value */
3247 if ((V_VT(left) & VT_TYPEMASK) != VT_NULL && (V_VT(right) & VT_TYPEMASK) != VT_NULL)
3248 {
3249 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
3250 {
3251 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
3252 if (FAILED(hres)) goto end;
3253 left = &tempLeft;
3254 }
3255 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
3256 {
3257 hres = VARIANT_FetchDispatchValue(right, &tempRight);
3258 if (FAILED(hres)) goto end;
3259 right = &tempRight;
3260 }
3261 }
3262
3263 lvt = V_VT(left)&VT_TYPEMASK;
3264 rvt = V_VT(right)&VT_TYPEMASK;
3265
3266 /* If we have any flag set (VT_ARRAY, VT_VECTOR, etc.) bail out.
3267 Same for any input variant type > VT_I8 */
3268 if (V_VT(left) & ~VT_TYPEMASK || V_VT(right) & ~VT_TYPEMASK ||
3269 lvt > VT_I8 || rvt > VT_I8) {
3270 hres = DISP_E_BADVARTYPE;
3271 goto end;
3272 }
3273
3274 /* Determine the variant type to coerce to. */
3275 if (coerce[lvt] > coerce[rvt]) {
3276 resvt = prio2vt[coerce[lvt]];
3277 tvt = prio2vt[coerce[rvt]];
3278 } else {
3279 resvt = prio2vt[coerce[rvt]];
3280 tvt = prio2vt[coerce[lvt]];
3281 }
3282
3283 /* Special cases where the result variant type is defined by both
3284 input variants and not only that with the highest priority */
3285 if (resvt == VT_BSTR) {
3286 if (tvt == VT_EMPTY || tvt == VT_BSTR)
3287 resvt = VT_BSTR;
3288 else
3289 resvt = VT_R8;
3290 }
3291 if (resvt == VT_R4 && (tvt == VT_BSTR || tvt == VT_I8 || tvt == VT_I4))
3292 resvt = VT_R8;
3293
3294 /* For overflow detection use the biggest compatible type for the
3295 addition */
3296 switch (resvt) {
3297 case VT_ERROR:
3298 hres = DISP_E_BADVARTYPE;
3299 goto end;
3300 case VT_NULL:
3301 hres = S_OK;
3302 V_VT(result) = VT_NULL;
3303 goto end;
3304 case VT_DISPATCH:
3305 FIXME("cannot handle variant type VT_DISPATCH\n");
3306 hres = DISP_E_TYPEMISMATCH;
3307 goto end;
3308 case VT_EMPTY:
3309 resvt = VT_I2;
3310 /* Fall through */
3311 case VT_UI1:
3312 case VT_I2:
3313 case VT_I4:
3314 case VT_I8:
3315 tvt = VT_I8;
3316 break;
3317 case VT_DATE:
3318 case VT_R4:
3319 tvt = VT_R8;
3320 break;
3321 default:
3322 tvt = resvt;
3323 }
3324
3325 /* Now coerce the variants */
3326 hres = VariantChangeType(&lv, left, 0, tvt);
3327 if (FAILED(hres))
3328 goto end;
3329 hres = VariantChangeType(&rv, right, 0, tvt);
3330 if (FAILED(hres))
3331 goto end;
3332
3333 /* Do the math */
3334 hres = S_OK;
3335 V_VT(result) = resvt;
3336 switch (tvt) {
3337 case VT_DECIMAL:
3338 hres = VarDecAdd(&V_DECIMAL(&lv), &V_DECIMAL(&rv),
3339 &V_DECIMAL(result));
3340 goto end;
3341 case VT_CY:
3342 hres = VarCyAdd(V_CY(&lv), V_CY(&rv), &V_CY(result));
3343 goto end;
3344 case VT_BSTR:
3345 /* We do not add those, we concatenate them. */
3346 hres = VarBstrCat(V_BSTR(&lv), V_BSTR(&rv), &V_BSTR(result));
3347 goto end;
3348 case VT_I8:
3349 /* Overflow detection */
3350 r8res = (double)V_I8(&lv) + (double)V_I8(&rv);
3351 if (r8res > (double)I8_MAX || r8res < (double)I8_MIN) {
3352 V_VT(result) = VT_R8;
3353 V_R8(result) = r8res;
3354 goto end;
3355 } else {
3356 V_VT(&tv) = tvt;
3357 V_I8(&tv) = V_I8(&lv) + V_I8(&rv);
3358 }
3359 break;
3360 case VT_R8:
3361 V_VT(&tv) = tvt;
3362 /* FIXME: overflow detection */
3363 V_R8(&tv) = V_R8(&lv) + V_R8(&rv);
3364 break;
3365 default:
3366 ERR("We shouldn't get here! tvt = %d!\n", tvt);
3367 break;
3368 }
3369 if (resvt != tvt) {
3370 if ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) {
3371 /* Overflow! Change to the vartype with the next higher priority.
3372 With one exception: I4 ==> R8 even if it would fit in I8 */
3373 if (resvt == VT_I4)
3374 resvt = VT_R8;
3375 else
3376 resvt = prio2vt[coerce[resvt] + 1];
3377 hres = VariantChangeType(result, &tv, 0, resvt);
3378 }
3379 } else
3380 hres = VariantCopy(result, &tv);
3381
3382 end:
3383 if (hres != S_OK) {
3384 V_VT(result) = VT_EMPTY;
3385 V_I4(result) = 0; /* No V_EMPTY */
3386 }
3387 VariantClear(&lv);
3388 VariantClear(&rv);
3389 VariantClear(&tv);
3390 VariantClear(&tempLeft);
3391 VariantClear(&tempRight);
3392 TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
3393 return hres;
3394 }
3395
3396 /**********************************************************************
3397 * VarMul [OLEAUT32.156]
3398 *
3399 * Multiply two variants.
3400 *
3401 * PARAMS
3402 * left [I] First variant
3403 * right [I] Second variant
3404 * result [O] Result variant
3405 *
3406 * RETURNS
3407 * Success: S_OK.
3408 * Failure: An HRESULT error code indicating the error.
3409 *
3410 * NOTES
3411 * Native VarMul up to and including WinXP doesn't like I1, UI2, UI4,
3412 * UI8, INT and UINT as input variants. But it can multiply apples with oranges.
3413 *
3414 * Native VarMul doesn't check for NULL in/out pointers and crashes. We do the
3415 * same here.
3416 *
3417 * FIXME
3418 * Overflow checking for R8 (double) overflow. Return DISP_E_OVERFLOW in that
3419 * case.
3420 */
3421 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3422 {
3423 HRESULT hres;
3424 VARTYPE lvt, rvt, resvt, tvt;
3425 VARIANT lv, rv, tv;
3426 VARIANT tempLeft, tempRight;
3427 double r8res;
3428
3429 /* Variant priority for coercion. Sorted from lowest to highest.
3430 VT_ERROR shows an invalid input variant type. */
3431 enum coerceprio { vt_UI1 = 0, vt_I2, vt_I4, vt_I8, vt_CY, vt_R4, vt_R8,
3432 vt_DECIMAL, vt_NULL, vt_ERROR };
3433 /* Mapping from priority to variant type. Keep in sync with coerceprio! */
3434 static const VARTYPE prio2vt[] = { VT_UI1, VT_I2, VT_I4, VT_I8, VT_CY, VT_R4, VT_R8,
3435 VT_DECIMAL, VT_NULL, VT_ERROR };
3436
3437 /* Mapping for coercion from input variant to priority of result variant. */
3438 static const VARTYPE coerce[] = {
3439 /* VT_EMPTY, VT_NULL, VT_I2, VT_I4, VT_R4 */
3440 vt_UI1, vt_NULL, vt_I2, vt_I4, vt_R4,
3441 /* VT_R8, VT_CY, VT_DATE, VT_BSTR, VT_DISPATCH */
3442 vt_R8, vt_CY, vt_R8, vt_R8, vt_ERROR,
3443 /* VT_ERROR, VT_BOOL, VT_VARIANT, VT_UNKNOWN, VT_DECIMAL */
3444 vt_ERROR, vt_I2, vt_ERROR, vt_ERROR, vt_DECIMAL,
3445 /* 15, VT_I1, VT_UI1, VT_UI2, VT_UI4 VT_I8 */
3446 vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8
3447 };
3448
3449 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
3450
3451 VariantInit(&lv);
3452 VariantInit(&rv);
3453 VariantInit(&tv);
3454 VariantInit(&tempLeft);
3455 VariantInit(&tempRight);
3456
3457 /* Handle VT_DISPATCH by storing and taking address of returned value */
3458 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
3459 {
3460 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
3461 if (FAILED(hres)) goto end;
3462 left = &tempLeft;
3463 }
3464 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
3465 {
3466 hres = VARIANT_FetchDispatchValue(right, &tempRight);
3467 if (FAILED(hres)) goto end;
3468 right = &tempRight;
3469 }
3470
3471 lvt = V_VT(left)&VT_TYPEMASK;
3472 rvt = V_VT(right)&VT_TYPEMASK;
3473
3474 /* If we have any flag set (VT_ARRAY, VT_VECTOR, etc.) bail out.
3475 Same for any input variant type > VT_I8 */
3476 if (V_VT(left) & ~VT_TYPEMASK || V_VT(right) & ~VT_TYPEMASK ||
3477 lvt > VT_I8 || rvt > VT_I8) {
3478 hres = DISP_E_BADVARTYPE;
3479 goto end;
3480 }
3481
3482 /* Determine the variant type to coerce to. */
3483 if (coerce[lvt] > coerce[rvt]) {
3484 resvt = prio2vt[coerce[lvt]];
3485 tvt = prio2vt[coerce[rvt]];
3486 } else {
3487 resvt = prio2vt[coerce[rvt]];
3488 tvt = prio2vt[coerce[lvt]];
3489 }
3490
3491 /* Special cases where the result variant type is defined by both
3492 input variants and not only that with the highest priority */
3493 if (resvt == VT_R4 && (tvt == VT_CY || tvt == VT_I8 || tvt == VT_I4))
3494 resvt = VT_R8;
3495 if (lvt == VT_EMPTY && rvt == VT_EMPTY)
3496 resvt = VT_I2;
3497
3498 /* For overflow detection use the biggest compatible type for the
3499 multiplication */
3500 switch (resvt) {
3501 case VT_ERROR:
3502 hres = DISP_E_BADVARTYPE;
3503 goto end;
3504 case VT_NULL:
3505 hres = S_OK;
3506 V_VT(result) = VT_NULL;
3507 goto end;
3508 case VT_UI1:
3509 case VT_I2:
3510 case VT_I4:
3511 case VT_I8:
3512 tvt = VT_I8;
3513 break;
3514 case VT_R4:
3515 tvt = VT_R8;
3516 break;
3517 default:
3518 tvt = resvt;
3519 }
3520
3521 /* Now coerce the variants */
3522 hres = VariantChangeType(&lv, left, 0, tvt);
3523 if (FAILED(hres))
3524 goto end;
3525 hres = VariantChangeType(&rv, right, 0, tvt);
3526 if (FAILED(hres))
3527 goto end;
3528
3529 /* Do the math */
3530 hres = S_OK;
3531 V_VT(&tv) = tvt;
3532 V_VT(result) = resvt;
3533 switch (tvt) {
3534 case VT_DECIMAL:
3535 hres = VarDecMul(&V_DECIMAL(&lv), &V_DECIMAL(&rv),
3536 &V_DECIMAL(result));
3537 goto end;
3538 case VT_CY:
3539 hres = VarCyMul(V_CY(&lv), V_CY(&rv), &V_CY(result));
3540 goto end;
3541 case VT_I8:
3542 /* Overflow detection */
3543 r8res = (double)V_I8(&lv) * (double)V_I8(&rv);
3544 if (r8res > (double)I8_MAX || r8res < (double)I8_MIN) {
3545 V_VT(result) = VT_R8;
3546 V_R8(result) = r8res;
3547 goto end;
3548 } else
3549 V_I8(&tv) = V_I8(&lv) * V_I8(&rv);
3550 break;
3551 case VT_R8:
3552 /* FIXME: overflow detection */
3553 V_R8(&tv) = V_R8(&lv) * V_R8(&rv);
3554 break;
3555 default:
3556 ERR("We shouldn't get here! tvt = %d!\n", tvt);
3557 break;
3558 }
3559 if (resvt != tvt) {
3560 while ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) {
3561 /* Overflow! Change to the vartype with the next higher priority.
3562 With one exception: I4 ==> R8 even if it would fit in I8 */
3563 if (resvt == VT_I4)
3564 resvt = VT_R8;
3565 else
3566 resvt = prio2vt[coerce[resvt] + 1];
3567 }
3568 } else
3569 hres = VariantCopy(result, &tv);
3570
3571 end:
3572 if (hres != S_OK) {
3573 V_VT(result) = VT_EMPTY;
3574 V_I4(result) = 0; /* No V_EMPTY */
3575 }
3576 VariantClear(&lv);
3577 VariantClear(&rv);
3578 VariantClear(&tv);
3579 VariantClear(&tempLeft);
3580 VariantClear(&tempRight);
3581 TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
3582 return hres;
3583 }
3584
3585 /**********************************************************************
3586 * VarDiv [OLEAUT32.143]
3587 *
3588 * Divides one variant with another.
3589 *
3590 * PARAMS
3591 * left [I] First variant
3592 * right [I] Second variant
3593 * result [O] Result variant
3594 *
3595 * RETURNS
3596 * Success: S_OK.
3597 * Failure: An HRESULT error code indicating the error.
3598 */
3599 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3600 {
3601 HRESULT hres = S_OK;
3602 VARTYPE resvt = VT_EMPTY;
3603 VARTYPE leftvt,rightvt;
3604 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
3605 VARIANT lv,rv;
3606 VARIANT tempLeft, tempRight;
3607
3608 VariantInit(&tempLeft);
3609 VariantInit(&tempRight);
3610 VariantInit(&lv);
3611 VariantInit(&rv);
3612
3613 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
3614
3615 /* Handle VT_DISPATCH by storing and taking address of returned value */
3616 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
3617 {
3618 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
3619 if (FAILED(hres)) goto end;
3620 left = &tempLeft;
3621 }
3622 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
3623 {
3624 hres = VARIANT_FetchDispatchValue(right, &tempRight);
3625 if (FAILED(hres)) goto end;
3626 right = &tempRight;
3627 }
3628
3629 leftvt = V_VT(left)&VT_TYPEMASK;
3630 rightvt = V_VT(right)&VT_TYPEMASK;
3631 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
3632 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
3633
3634 if (leftExtraFlags != rightExtraFlags)
3635 {
3636 hres = DISP_E_BADVARTYPE;
3637 goto end;
3638 }
3639 ExtraFlags = leftExtraFlags;
3640
3641 /* Native VarDiv always returns an error when using extra flags */
3642 if (ExtraFlags != 0)
3643 {
3644 hres = DISP_E_BADVARTYPE;
3645 goto end;
3646 }
3647
3648 /* Determine return type */
3649 if (rightvt != VT_EMPTY)
3650 {
3651 if (leftvt == VT_NULL || rightvt == VT_NULL)
3652 {
3653 V_VT(result) = VT_NULL;
3654 hres = S_OK;
3655 goto end;
3656 }
3657 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
3658 resvt = VT_DECIMAL;
3659 else if (leftvt == VT_I8 || rightvt == VT_I8 ||
3660 leftvt == VT_CY || rightvt == VT_CY ||
3661 leftvt == VT_DATE || rightvt == VT_DATE ||
3662 leftvt == VT_I4 || rightvt == VT_I4 ||
3663 leftvt == VT_BSTR || rightvt == VT_BSTR ||
3664 leftvt == VT_I2 || rightvt == VT_I2 ||
3665 leftvt == VT_BOOL || rightvt == VT_BOOL ||
3666 leftvt == VT_R8 || rightvt == VT_R8 ||
3667 leftvt == VT_UI1 || rightvt == VT_UI1)
3668 {
3669 if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
3670 (leftvt == VT_R4 && rightvt == VT_UI1))
3671 resvt = VT_R4;
3672 else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
3673 rightvt == VT_I2)) || (rightvt == VT_R4 &&
3674 (leftvt == VT_BOOL || leftvt == VT_I2)))
3675 resvt = VT_R4;
3676 else
3677 resvt = VT_R8;
3678 }
3679 else if (leftvt == VT_R4 || rightvt == VT_R4)
3680 resvt = VT_R4;
3681 }
3682 else if (leftvt == VT_NULL)
3683 {
3684 V_VT(result) = VT_NULL;
3685 hres = S_OK;
3686 goto end;
3687 }
3688 else
3689 {
3690 hres = DISP_E_BADVARTYPE;
3691 goto end;
3692 }
3693
3694 /* coerce to the result type */
3695 hres = VariantChangeType(&lv, left, 0, resvt);
3696 if (hres != S_OK) goto end;
3697
3698 hres = VariantChangeType(&rv, right, 0, resvt);
3699 if (hres != S_OK) goto end;
3700
3701 /* do the math */
3702 V_VT(result) = resvt;
3703 switch (resvt)
3704 {
3705 case VT_R4:
3706 if (V_R4(&lv) == 0.0 && V_R4(&rv) == 0.0)
3707 {
3708 hres = DISP_E_OVERFLOW;
3709 V_VT(result) = VT_EMPTY;
3710 }
3711 else if (V_R4(&rv) == 0.0)
3712 {
3713 hres = DISP_E_DIVBYZERO;
3714 V_VT(result) = VT_EMPTY;
3715 }
3716 else
3717 V_R4(result) = V_R4(&lv) / V_R4(&rv);
3718 break;
3719 case VT_R8:
3720 if (V_R8(&lv) == 0.0 && V_R8(&rv) == 0.0)
3721 {
3722 hres = DISP_E_OVERFLOW;
3723 V_VT(result) = VT_EMPTY;
3724 }
3725 else if (V_R8(&rv) == 0.0)
3726 {
3727 hres = DISP_E_DIVBYZERO;
3728 V_VT(result) = VT_EMPTY;
3729 }
3730 else
3731 V_R8(result) = V_R8(&lv) / V_R8(&rv);
3732 break;
3733 case VT_DECIMAL:
3734 hres = VarDecDiv(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result)));
3735 break;
3736 }
3737
3738 end:
3739 VariantClear(&lv);
3740 VariantClear(&rv);
3741 VariantClear(&tempLeft);
3742 VariantClear(&tempRight);
3743 TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
3744 return hres;
3745 }
3746
3747 /**********************************************************************
3748 * VarSub [OLEAUT32.159]
3749 *
3750 * Subtract two variants.
3751 *
3752 * PARAMS
3753 * left [I] First variant
3754 * right [I] Second variant
3755 * result [O] Result variant
3756 *
3757 * RETURNS
3758 * Success: S_OK.
3759 * Failure: An HRESULT error code indicating the error.
3760 */
3761 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result)
3762 {
3763 HRESULT hres = S_OK;
3764 VARTYPE resvt = VT_EMPTY;
3765 VARTYPE leftvt,rightvt;
3766 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
3767 VARIANT lv,rv;
3768 VARIANT tempLeft, tempRight;
3769
3770 VariantInit(&lv);
3771 VariantInit(&rv);
3772 VariantInit(&tempLeft);
3773 VariantInit(&tempRight);
3774
3775 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
3776
3777 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH &&
3778 (V_VT(left)&(~VT_TYPEMASK)) == 0 &&
3779 (V_VT(right) & VT_TYPEMASK) != VT_NULL)
3780 {
3781 if (NULL == V_DISPATCH(left)) {
3782 if ((V_VT(right) & VT_TYPEMASK) >= VT_INT_PTR)
3783 hres = DISP_E_BADVARTYPE;
3784 else if ((V_VT(right) & VT_TYPEMASK) >= VT_UI8 &&
3785 (V_VT(right) & VT_TYPEMASK) < VT_RECORD)
3786 hres = DISP_E_BADVARTYPE;
3787 else switch (V_VT(right) & VT_TYPEMASK)
3788 {
3789 case VT_VARIANT:
3790 case VT_UNKNOWN:
3791 case 15:
3792 case VT_I1:
3793 case VT_UI2:
3794 case VT_UI4:
3795 hres = DISP_E_BADVARTYPE;
3796 }
3797 if (FAILED(hres)) goto end;
3798 }
3799 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
3800 if (FAILED(hres)) goto end;
3801 left = &tempLeft;
3802 }
3803 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH &&
3804 (V_VT(right)&(~VT_TYPEMASK)) == 0 &&
3805 (V_VT(left) & VT_TYPEMASK) != VT_NULL)
3806 {
3807 if (NULL == V_DISPATCH(right))
3808 {
3809 if ((V_VT(left) & VT_TYPEMASK) >= VT_INT_PTR)
3810 hres = DISP_E_BADVARTYPE;
3811 else if ((V_VT(left) & VT_TYPEMASK) >= VT_UI8 &&
3812 (V_VT(left) & VT_TYPEMASK) < VT_RECORD)
3813 hres = DISP_E_BADVARTYPE;
3814 else switch (V_VT(left) & VT_TYPEMASK)
3815 {
3816 case VT_VARIANT:
3817 case VT_UNKNOWN:
3818 case 15:
3819 case VT_I1:
3820 case VT_UI2:
3821 case VT_UI4:
3822 hres = DISP_E_BADVARTYPE;
3823 }
3824 if (FAILED(hres)) goto end;
3825 }
3826 hres = VARIANT_FetchDispatchValue(right, &tempRight);
3827 if (FAILED(hres)) goto end;
3828 right = &tempRight;
3829 }
3830
3831 leftvt = V_VT(left)&VT_TYPEMASK;
3832 rightvt = V_VT(right)&VT_TYPEMASK;
3833 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
3834 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
3835
3836 if (leftExtraFlags != rightExtraFlags)
3837 {
3838 hres = DISP_E_BADVARTYPE;
3839 goto end;
3840 }
3841 ExtraFlags = leftExtraFlags;
3842
3843 /* determine return type and return code */
3844 /* All extra flags produce errors */
3845 if (ExtraFlags == (VT_VECTOR|VT_BYREF|VT_RESERVED) ||
3846 ExtraFlags == (VT_VECTOR|VT_RESERVED) ||
3847 ExtraFlags == (VT_VECTOR|VT_BYREF) ||
3848 ExtraFlags == (VT_BYREF|VT_RESERVED) ||
3849 ExtraFlags == VT_VECTOR ||
3850 ExtraFlags == VT_BYREF ||
3851 ExtraFlags == VT_RESERVED)
3852 {
3853 hres = DISP_E_BADVARTYPE;
3854 goto end;
3855 }
3856 else if (ExtraFlags >= VT_ARRAY)
3857 {
3858 hres = DISP_E_TYPEMISMATCH;
3859 goto end;
3860 }
3861 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4,
3862 VT_INT, VT_UINT and VT_UI8. Tested with WinXP */
3863 else if (leftvt == VT_CLSID || rightvt == VT_CLSID ||
3864 leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
3865 leftvt == VT_I1 || rightvt == VT_I1 ||
3866 leftvt == VT_UI2 || rightvt == VT_UI2 ||
3867 leftvt == VT_UI4 || rightvt == VT_UI4 ||
3868 leftvt == VT_UI8 || rightvt == VT_UI8 ||
3869 leftvt == VT_INT || rightvt == VT_INT ||
3870 leftvt == VT_UINT || rightvt == VT_UINT ||
3871 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN ||
3872 leftvt == VT_RECORD || rightvt == VT_RECORD)
3873 {
3874 if (leftvt == VT_RECORD && rightvt == VT_I8)
3875 hres = DISP_E_TYPEMISMATCH;
3876 else if (leftvt < VT_UI1 && rightvt == VT_RECORD)
3877 hres = DISP_E_TYPEMISMATCH;
3878 else if (leftvt >= VT_UI1 && rightvt == VT_RECORD)
3879 hres = DISP_E_TYPEMISMATCH;
3880 else if (leftvt == VT_RECORD && rightvt <= VT_UI1)
3881 hres = DISP_E_TYPEMISMATCH;
3882 else if (leftvt == VT_RECORD && rightvt > VT_UI1)
3883 hres = DISP_E_BADVARTYPE;
3884 else
3885 hres = DISP_E_BADVARTYPE;
3886 goto end;
3887 }
3888 /* The following flags/types are invalid for left variant */
3889 else if (!((leftvt <= VT_LPWSTR || leftvt == VT_RECORD ||
3890 leftvt == VT_CLSID) && leftvt != (VARTYPE)15 /* undefined vt */ &&
3891 (leftvt < VT_VOID || leftvt > VT_LPWSTR)))
3892 {
3893 hres = DISP_E_BADVARTYPE;
3894 goto end;
3895 }
3896 /* The following flags/types are invalid for right variant */
3897 else if (!((rightvt <= VT_LPWSTR || rightvt == VT_RECORD ||
3898 rightvt == VT_CLSID) && rightvt != (VARTYPE)15 /* undefined vt */ &&
3899 (rightvt < VT_VOID || rightvt > VT_LPWSTR)))
3900 {
3901 hres = DISP_E_BADVARTYPE;
3902 goto end;
3903 }
3904 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) ||
3905 (leftvt == VT_DISPATCH && rightvt == VT_NULL))
3906 resvt = VT_NULL;
3907 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH ||
3908 leftvt == VT_ERROR || rightvt == VT_ERROR)
3909 {
3910 hres = DISP_E_TYPEMISMATCH;
3911 goto end;
3912 }
3913 else if (leftvt == VT_NULL || rightvt == VT_NULL)
3914 resvt = VT_NULL;
3915 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) ||
3916 (leftvt == VT_DATE && rightvt == VT_DATE) ||
3917 (leftvt == VT_BSTR && rightvt == VT_EMPTY) ||
3918 (leftvt == VT_BSTR && rightvt == VT_BSTR))
3919 resvt = VT_R8;
3920 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
3921 resvt = VT_DECIMAL;
3922 else if (leftvt == VT_DATE || rightvt == VT_DATE)
3923 resvt = VT_DATE;
3924 else if (leftvt == VT_CY || rightvt == VT_CY)
3925 resvt = VT_CY;
3926 else if (leftvt == VT_R8 || rightvt == VT_R8)
3927 resvt = VT_R8;
3928 else if (leftvt == VT_BSTR || rightvt == VT_BSTR)
3929 resvt = VT_R8;
3930 else if (leftvt == VT_R4 || rightvt == VT_R4)
3931 {
3932 if (leftvt == VT_I4 || rightvt == VT_I4 ||
3933 leftvt == VT_I8 || rightvt == VT_I8)
3934 resvt = VT_R8;
3935 else
3936 resvt = VT_R4;
3937 }
3938 else if (leftvt == VT_I8 || rightvt == VT_I8)
3939 resvt = VT_I8;
3940 else if (leftvt == VT_I4 || rightvt == VT_I4)
3941 resvt = VT_I4;
3942 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
3943 leftvt == VT_BOOL || rightvt == VT_BOOL ||
3944 (leftvt == VT_EMPTY && rightvt == VT_EMPTY))
3945 resvt = VT_I2;
3946 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
3947 resvt = VT_UI1;
3948 else
3949 {
3950 hres = DISP_E_TYPEMISMATCH;
3951 goto end;
3952 }
3953
3954 /* coerce to the result type */
3955 if (leftvt == VT_BSTR && rightvt == VT_DATE)
3956 hres = VariantChangeType(&lv, left, 0, VT_R8);
3957 else
3958 hres = VariantChangeType(&lv, left, 0, resvt);
3959 if (hres != S_OK) goto end;
3960 if (leftvt == VT_DATE && rightvt == VT_BSTR)
3961 hres = VariantChangeType(&rv, right, 0, VT_R8);
3962 else
3963 hres = VariantChangeType(&rv, right, 0, resvt);
3964 if (hres != S_OK) goto end;
3965
3966 /* do the math */
3967 V_VT(result) = resvt;
3968 switch (resvt)
3969 {
3970 case VT_NULL:
3971 break;
3972 case VT_DATE:
3973 V_DATE(result) = V_DATE(&lv) - V_DATE(&rv);
3974 break;
3975 case VT_CY:
3976 hres = VarCySub(V_CY(&lv), V_CY(&rv), &(V_CY(result)));
3977 break;
3978 case VT_R4:
3979 V_R4(result) = V_R4(&lv) - V_R4(&rv);
3980 break;
3981 case VT_I8:
3982 V_I8(result) = V_I8(&lv) - V_I8(&rv);
3983 break;
3984 case VT_I4:
3985 V_I4(result) = V_I4(&lv) - V_I4(&rv);
3986 break;
3987 case VT_I2:
3988 V_I2(result) = V_I2(&lv) - V_I2(&rv);
3989 break;
3990 case VT_UI1:
3991 V_UI1(result) = V_UI2(&lv) - V_UI1(&rv);
3992 break;
3993 case VT_R8:
3994 V_R8(result) = V_R8(&lv) - V_R8(&rv);
3995 break;
3996 case VT_DECIMAL:
3997 hres = VarDecSub(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result)));
3998 break;
3999 }
4000
4001 end:
4002 VariantClear(&lv);
4003 VariantClear(&rv);
4004 VariantClear(&tempLeft);
4005 VariantClear(&tempRight);
4006 TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
4007 return hres;
4008 }
4009
4010
4011 /**********************************************************************
4012 * VarOr [OLEAUT32.157]
4013 *
4014 * Perform a logical or (OR) operation on two variants.
4015 *
4016 * PARAMS
4017 * pVarLeft [I] First variant
4018 * pVarRight [I] Variant to OR with pVarLeft
4019 * pVarOut [O] Destination for OR result
4020 *
4021 * RETURNS
4022 * Success: S_OK. pVarOut contains the result of the operation with its type
4023 * taken from the table listed under VarXor().
4024 * Failure: An HRESULT error code indicating the error.
4025 *
4026 * NOTES
4027 * See the Notes section of VarXor() for further information.
4028 */
4029 HRESULT WINAPI VarOr(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
4030 {
4031 VARTYPE vt = VT_I4;
4032 VARIANT varLeft, varRight, varStr;
4033 HRESULT hRet;
4034 VARIANT tempLeft, tempRight;
4035
4036 VariantInit(&tempLeft);
4037 VariantInit(&tempRight);
4038 VariantInit(&varLeft);
4039 VariantInit(&varRight);
4040 VariantInit(&varStr);
4041
4042 TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
4043
4044 /* Handle VT_DISPATCH by storing and taking address of returned value */
4045 if ((V_VT(pVarLeft) & VT_TYPEMASK) == VT_DISPATCH)
4046 {
4047 hRet = VARIANT_FetchDispatchValue(pVarLeft, &tempLeft);
4048 if (FAILED(hRet)) goto VarOr_Exit;
4049 pVarLeft = &tempLeft;
4050 }
4051 if ((V_VT(pVarRight) & VT_TYPEMASK) == VT_DISPATCH)
4052 {
4053 hRet = VARIANT_FetchDispatchValue(pVarRight, &tempRight);
4054 if (FAILED(hRet)) goto VarOr_Exit;
4055 pVarRight = &tempRight;
4056 }
4057
4058 if (V_EXTRA_TYPE(pVarLeft) || V_EXTRA_TYPE(pVarRight) ||
4059 V_VT(pVarLeft) == VT_UNKNOWN || V_VT(pVarRight) == VT_UNKNOWN ||
4060 V_VT(pVarLeft) == VT_DISPATCH || V_VT(pVarRight) == VT_DISPATCH ||
4061 V_VT(pVarLeft) == VT_RECORD || V_VT(pVarRight) == VT_RECORD)
4062 {
4063 hRet = DISP_E_BADVARTYPE;
4064 goto VarOr_Exit;
4065 }
4066
4067 V_VT(&varLeft) = V_VT(&varRight) = V_VT(&varStr) = VT_EMPTY;
4068
4069 if (V_VT(pVarLeft) == VT_NULL || V_VT(pVarRight) == VT_NULL)
4070 {
4071 /* NULL OR Zero is NULL, NULL OR value is value */
4072 if (V_VT(pVarLeft) == VT_NULL)
4073 pVarLeft = pVarRight; /* point to the non-NULL var */
4074
4075 V_VT(pVarOut) = VT_NULL;
4076 V_I4(pVarOut) = 0;
4077
4078 switch (V_VT(pVarLeft))
4079 {
4080 case VT_DATE: case VT_R8:
4081 if (V_R8(pVarLeft))
4082 goto VarOr_AsEmpty;
4083 hRet = S_OK;
4084 goto VarOr_Exit;
4085 case VT_BOOL:
4086 if (V_BOOL(pVarLeft))
4087 *pVarOut = *pVarLeft;
4088 hRet = S_OK;
4089 goto VarOr_Exit;
4090 case VT_I2: case VT_UI2:
4091 if (V_I2(pVarLeft))
4092 goto VarOr_AsEmpty;
4093 hRet = S_OK;
4094 goto VarOr_Exit;
4095 case VT_I1:
4096 if (V_I1(pVarLeft))
4097 goto VarOr_AsEmpty;
4098 hRet = S_OK;
4099 goto VarOr_Exit;
4100 case VT_UI1:
4101 if (V_UI1(pVarLeft))
4102 *pVarOut = *pVarLeft;
4103 hRet = S_OK;
4104 goto VarOr_Exit;
4105 case VT_R4:
4106 if (V_R4(pVarLeft))
4107 goto VarOr_AsEmpty;
4108 hRet = S_OK;
4109 goto VarOr_Exit;
4110 case VT_I4: case VT_UI4: case VT_INT: case VT_UINT:
4111 if (V_I4(pVarLeft))
4112 goto VarOr_AsEmpty;
4113 hRet = S_OK;
4114 goto VarOr_Exit;
4115 case VT_CY:
4116 if (V_CY(pVarLeft).int64)
4117 goto VarOr_AsEmpty;
4118 hRet = S_OK;
4119 goto VarOr_Exit;
4120 case VT_I8: case VT_UI8:
4121 if (V_I8(pVarLeft))
4122 goto VarOr_AsEmpty;
4123 hRet = S_OK;
4124 goto VarOr_Exit;
4125 case VT_DECIMAL:
4126 if (DEC_HI32(&V_DECIMAL(pVarLeft)) || DEC_LO64(&V_DECIMAL(pVarLeft)))
4127 goto VarOr_AsEmpty;
4128 hRet = S_OK;
4129 goto VarOr_Exit;
4130 case VT_BSTR:
4131 {
4132 VARIANT_BOOL b;
4133
4134 if (!V_BSTR(pVarLeft))
4135 {
4136 hRet = DISP_E_BADVARTYPE;
4137 goto VarOr_Exit;
4138 }
4139
4140 hRet = VarBoolFromStr(V_BSTR(pVarLeft), LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b);
4141 if (SUCCEEDED(hRet) && b)
4142 {
4143 V_VT(pVarOut) = VT_BOOL;
4144 V_BOOL(pVarOut) = b;
4145 }
4146 goto VarOr_Exit;
4147 }
4148 case VT_NULL: case VT_EMPTY:
4149 V_VT(pVarOut) = VT_NULL;
4150 hRet = S_OK;
4151 goto VarOr_Exit;
4152 default:
4153 hRet = DISP_E_BADVARTYPE;
4154 goto VarOr_Exit;
4155 }
4156 }
4157
4158 if (V_VT(pVarLeft) == VT_EMPTY || V_VT(pVarRight) == VT_EMPTY)
4159 {
4160 if (V_VT(pVarLeft) == VT_EMPTY)
4161 pVarLeft = pVarRight; /* point to the non-EMPTY var */
4162
4163 VarOr_AsEmpty:
4164 /* Since one argument is empty (0), OR'ing it with the other simply
4165 * gives the others value (as 0|x => x). So just convert the other
4166 * argument to the required result type.
4167 */
4168 switch (V_VT(pVarLeft))
4169 {
4170 case VT_BSTR:
4171 if (!V_BSTR(pVarLeft))
4172 {
4173 hRet = DISP_E_BADVARTYPE;
4174 goto VarOr_Exit;
4175 }
4176
4177 hRet = VariantCopy(&varStr, pVarLeft);
4178 if (FAILED(hRet))
4179 goto VarOr_Exit;
4180 pVarLeft = &varStr;
4181 hRet = VariantChangeType(pVarLeft, pVarLeft, 0, VT_BOOL);
4182 if (FAILED(hRet))
4183 goto VarOr_Exit;
4184 /* Fall Through ... */
4185 case VT_EMPTY: case VT_UI1: case VT_BOOL: case VT_I2:
4186 V_VT(pVarOut) = VT_I2;
4187 break;
4188 case VT_DATE: case VT_CY: case VT_DECIMAL: case VT_R4: case VT_R8:
4189 case VT_I1: case VT_UI2: case VT_I4: case VT_UI4:
4190 case VT_INT: case VT_UINT: case VT_UI8:
4191 V_VT(pVarOut) = VT_I4;
4192 break;
4193 case VT_I8:
4194 V_VT(pVarOut) = VT_I8;
4195 break;
4196 default:
4197 hRet = DISP_E_BADVARTYPE;
4198 goto VarOr_Exit;
4199 }
4200 hRet = VariantCopy(&varLeft, pVarLeft);
4201 if (FAILED(hRet))
4202 goto VarOr_Exit;
4203 pVarLeft = &varLeft;
4204 hRet = VariantChangeType(pVarOut, pVarLeft, 0, V_VT(pVarOut));
4205 goto VarOr_Exit;
4206 }
4207
4208 if (V_VT(pVarLeft) == VT_BOOL && V_VT(pVarRight) == VT_BOOL)
4209 {
4210 V_VT(pVarOut) = VT_BOOL;
4211 V_BOOL(pVarOut) = V_BOOL(pVarLeft) | V_BOOL(pVarRight);
4212 hRet = S_OK;
4213 goto VarOr_Exit;
4214 }
4215
4216 if (V_VT(pVarLeft) == VT_UI1 && V_VT(pVarRight) == VT_UI1)
4217 {
4218 V_VT(pVarOut) = VT_UI1;
4219 V_UI1(pVarOut) = V_UI1(pVarLeft) | V_UI1(pVarRight);
4220 hRet = S_OK;
4221 goto VarOr_Exit;
4222 }
4223
4224 if (V_VT(pVarLeft) == VT_BSTR)
4225 {
4226 hRet = VariantCopy(&varStr, pVarLeft);
4227 if (FAILED(hRet))
4228 goto VarOr_Exit;
4229 pVarLeft = &varStr;
4230 hRet = VariantChangeType(pVarLeft, pVarLeft, 0, VT_BOOL);
4231 if (FAILED(hRet))
4232 goto VarOr_Exit;
4233 }
4234
4235 if (V_VT(pVarLeft) == VT_BOOL &&
4236 (V_VT(pVarRight) == VT_BOOL || V_VT(pVarRight) == VT_BSTR))
4237 {
4238 vt = VT_BOOL;
4239 }
4240 else if ((V_VT(pVarLeft) == VT_BOOL || V_VT(pVarLeft) == VT_UI1 ||
4241 V_VT(pVarLeft) == VT_I2 || V_VT(pVarLeft) == VT_BSTR) &&
4242 (V_VT(pVarRight) == VT_BOOL || V_VT(pVarRight) == VT_UI1 ||
4243 V_VT(pVarRight) == VT_I2 || V_VT(pVarRight) == VT_BSTR))
4244 {
4245 vt = VT_I2;
4246 }
4247 else if (V_VT(pVarLeft) == VT_I8 || V_VT(pVarRight) == VT_I8)
4248 {
4249 if (V_VT(pVarLeft) == VT_INT || V_VT(pVarRight) == VT_INT)
4250 {
4251 hRet = DISP_E_TYPEMISMATCH;
4252 goto VarOr_Exit;
4253 }
4254 vt = VT_I8;
4255 }
4256
4257 hRet = VariantCopy(&varLeft, pVarLeft);
4258 if (FAILED(hRet))
4259 goto VarOr_Exit;
4260
4261 hRet = VariantCopy(&varRight, pVarRight);
4262 if (FAILED(hRet))
4263 goto VarOr_Exit;
4264
4265 if (vt == VT_I4 && V_VT(&varLeft) == VT_UI4)
4266 V_VT(&varLeft) = VT_I4; /* Don't overflow */
4267 else
4268 {
4269 double d;
4270
4271 if (V_VT(&varLeft) == VT_BSTR &&
4272 FAILED(VarR8FromStr(V_BSTR(&varLeft), LOCALE_USER_DEFAULT, 0, &d)))
4273 hRet = VariantChangeType(&varLeft, &varLeft, VARIANT_LOCALBOOL, VT_BOOL);
4274 if (SUCCEEDED(hRet) && V_VT(&varLeft) != vt)
4275 hRet = VariantChangeType(&varLeft, &varLeft, 0, vt);
4276 if (FAILED(hRet))
4277 goto VarOr_Exit;
4278 }
4279
4280 if (vt == VT_I4 && V_VT(&varRight) == VT_UI4)
4281 V_VT(&varRight) = VT_I4; /* Don't overflow */
4282 else
4283 {
4284 double d;
4285
4286 if (V_VT(&varRight) == VT_BSTR &&
4287 FAILED(VarR8FromStr(V_BSTR(&varRight), LOCALE_USER_DEFAULT, 0, &d)))
4288 hRet = VariantChangeType(&varRight, &varRight, VARIANT_LOCALBOOL, VT_BOOL);
4289 if (SUCCEEDED(hRet) && V_VT(&varRight) != vt)
4290 hRet = VariantChangeType(&varRight, &varRight, 0, vt);
4291 if (FAILED(hRet))
4292 goto VarOr_Exit;
4293 }
4294
4295 V_VT(pVarOut) = vt;
4296 if (vt == VT_I8)
4297 {
4298 V_I8(pVarOut) = V_I8(&varLeft) | V_I8(&varRight);
4299 }
4300 else if (vt == VT_I4)
4301 {
4302 V_I4(pVarOut) = V_I4(&varLeft) | V_I4(&varRight);
4303 }
4304 else
4305 {
4306 V_I2(pVarOut) = V_I2(&varLeft) | V_I2(&varRight);
4307 }
4308
4309 VarOr_Exit:
4310 VariantClear(&varStr);
4311 VariantClear(&varLeft);
4312 VariantClear(&varRight);
4313 VariantClear(&tempLeft);
4314 VariantClear(&tempRight);
4315 return hRet;
4316 }
4317
4318 /**********************************************************************
4319 * VarAbs [OLEAUT32.168]
4320 *
4321 * Convert a variant to its absolute value.
4322 *
4323 * PARAMS
4324 * pVarIn [I] Source variant
4325 * pVarOut [O] Destination for converted value
4326 *
4327 * RETURNS
4328 * Success: S_OK. pVarOut contains the absolute value of pVarIn.
4329 * Failure: An HRESULT error code indicating the error.
4330 *
4331 * NOTES
4332 * - This function does not process by-reference variants.
4333 * - The type of the value stored in pVarOut depends on the type of pVarIn,
4334 * according to the following table:
4335 *| Input Type Output Type
4336 *| ---------- -----------
4337 *| VT_BOOL VT_I2
4338 *| VT_BSTR VT_R8
4339 *| (All others) Unchanged
4340 */
4341 HRESULT WINAPI VarAbs(LPVARIANT pVarIn, LPVARIANT pVarOut)
4342 {
4343 VARIANT varIn;
4344 HRESULT hRet = S_OK;
4345 VARIANT temp;
4346
4347 VariantInit(&temp);
4348
4349 TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
4350
4351 /* Handle VT_DISPATCH by storing and taking address of returned value */
4352 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
4353 {
4354 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
4355 if (FAILED(hRet)) goto VarAbs_Exit;
4356 pVarIn = &temp;
4357 }
4358
4359 if (V_ISARRAY(pVarIn) || V_VT(pVarIn) == VT_UNKNOWN ||
4360 V_VT(pVarIn) == VT_DISPATCH || V_VT(pVarIn) == VT_RECORD ||
4361 V_VT(pVarIn) == VT_ERROR)
4362 {
4363 hRet = DISP_E_TYPEMISMATCH;
4364 goto VarAbs_Exit;
4365 }
4366 *pVarOut = *pVarIn; /* Shallow copy the value, and invert it if needed */
4367
4368 #define ABS_CASE(typ,min) \
4369 case VT_##typ: if (V_##typ(pVarIn) == min) hRet = DISP_E_OVERFLOW; \
4370 else if (V_##typ(pVarIn) < 0) V_##typ(pVarOut) = -V_##typ(pVarIn); \
4371 break
4372
4373 switch (V_VT(pVarIn))
4374 {
4375 ABS_CASE(I1,I1_MIN);
4376 case VT_BOOL:
4377 V_VT(pVarOut) = VT_I2;
4378 /* BOOL->I2, Fall through ... */
4379 ABS_CASE(I2,I2_MIN);
4380 case VT_INT:
4381 ABS_CASE(I4,I4_MIN);
4382 ABS_CASE(I8,I8_MIN);
4383 ABS_CASE(R4,R4_MIN);
4384 case VT_BSTR:
4385 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
4386 if (FAILED(hRet))
4387 break;
4388 V_VT(pVarOut) = VT_R8;
4389 pVarIn = &varIn;
4390 /* Fall through ... */
4391 case VT_DATE:
4392 ABS_CASE(R8,R8_MIN);
4393 case VT_CY:
4394 hRet = VarCyAbs(V_CY(pVarIn), & V_CY(pVarOut));
4395 break;
4396 case VT_DECIMAL:
4397 DEC_SIGN(&V_DECIMAL(pVarOut)) &= ~DECIMAL_NEG;
4398 break;
4399 case VT_UI1:
4400 case VT_UI2:
4401 case VT_UINT:
4402 case VT_UI4:
4403 case VT_UI8:
4404 /* No-Op */
4405 break;
4406 case VT_EMPTY:
4407 V_VT(pVarOut) = VT_I2;
4408 case VT_NULL:
4409 V_I2(pVarOut) = 0;
4410 break;
4411 default:
4412 hRet = DISP_E_BADVARTYPE;
4413 }
4414
4415 VarAbs_Exit:
4416 VariantClear(&temp);
4417 return hRet;
4418 }
4419
4420 /**********************************************************************
4421 * VarFix [OLEAUT32.169]
4422 *
4423 * Truncate a variants value to a whole number.
4424 *
4425 * PARAMS
4426 * pVarIn [I] Source variant
4427 * pVarOut [O] Destination for converted value
4428 *
4429 * RETURNS
4430 * Success: S_OK. pVarOut contains the converted value.
4431 * Failure: An HRESULT error code indicating the error.
4432 *
4433 * NOTES
4434 * - The type of the value stored in pVarOut depends on the type of pVarIn,
4435 * according to the following table:
4436 *| Input Type Output Type
4437 *| ---------- -----------
4438 *| VT_BOOL VT_I2
4439 *| VT_EMPTY VT_I2
4440 *| VT_BSTR VT_R8
4441 *| All Others Unchanged
4442 * - The difference between this function and VarInt() is that VarInt() rounds
4443 * negative numbers away from 0, while this function rounds them towards zero.
4444 */
4445 HRESULT WINAPI VarFix(LPVARIANT pVarIn, LPVARIANT pVarOut)
4446 {
4447 HRESULT hRet = S_OK;
4448 VARIANT temp;
4449
4450 VariantInit(&temp);
4451
4452 TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
4453
4454 /* Handle VT_DISPATCH by storing and taking address of returned value */
4455 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
4456 {
4457 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
4458 if (FAILED(hRet)) goto VarFix_Exit;
4459 pVarIn = &temp;
4460 }
4461 V_VT(pVarOut) = V_VT(pVarIn);
4462
4463 switch (V_VT(pVarIn))
4464 {
4465 case VT_UI1:
4466 V_UI1(pVarOut) = V_UI1(pVarIn);
4467 break;
4468 case VT_BOOL:
4469 V_VT(pVarOut) = VT_I2;
4470 /* Fall through */
4471 case VT_I2:
4472 V_I2(pVarOut) = V_I2(pVarIn);
4473 break;
4474 case VT_I4:
4475 V_I4(pVarOut) = V_I4(pVarIn);
4476 break;
4477 case VT_I8:
4478 V_I8(pVarOut) = V_I8(pVarIn);
4479 break;
4480 case VT_R4:
4481 if (V_R4(pVarIn) < 0.0f)
4482 V_R4(pVarOut) = (float)ceil(V_R4(pVarIn));
4483 else
4484 V_R4(pVarOut) = (float)floor(V_R4(pVarIn));
4485 break;
4486 case VT_BSTR:
4487 V_VT(pVarOut) = VT_R8;
4488 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
4489 pVarIn = pVarOut;
4490 /* Fall through */
4491 case VT_DATE:
4492 case VT_R8:
4493 if (V_R8(pVarIn) < 0.0)
4494 V_R8(pVarOut) = ceil(V_R8(pVarIn));
4495 else
4496 V_R8(pVarOut) = floor(V_R8(pVarIn));
4497 break;
4498 case VT_CY:
4499 hRet = VarCyFix(V_CY(pVarIn), &V_CY(pVarOut));
4500 break;
4501 case VT_DECIMAL:
4502 hRet = VarDecFix(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
4503 break;
4504 case VT_EMPTY:
4505 V_VT(pVarOut) = VT_I2;
4506 V_I2(pVarOut) = 0;
4507 break;
4508 case VT_NULL:
4509 /* No-Op */
4510 break;
4511 default:
4512 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
4513 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
4514 hRet = DISP_E_BADVARTYPE;
4515 else
4516 hRet = DISP_E_TYPEMISMATCH;
4517 }
4518 VarFix_Exit:
4519 if (FAILED(hRet))
4520 V_VT(pVarOut) = VT_EMPTY;
4521 VariantClear(&temp);
4522
4523 return hRet;
4524 }
4525
4526 /**********************************************************************
4527 * VarInt [OLEAUT32.172]
4528 *
4529 * Truncate a variants value to a whole number.
4530 *
4531 * PARAMS
4532 * pVarIn [I] Source variant
4533 * pVarOut [O] Destination for converted value
4534 *
4535 * RETURNS
4536 * Success: S_OK. pVarOut contains the converted value.
4537 * Failure: An HRESULT error code indicating the error.
4538 *
4539 * NOTES
4540 * - The type of the value stored in pVarOut depends on the type of pVarIn,
4541 * according to the following table:
4542 *| Input Type Output Type
4543 *| ---------- -----------
4544 *| VT_BOOL VT_I2
4545 *| VT_EMPTY VT_I2
4546 *| VT_BSTR VT_R8
4547 *| All Others Unchanged
4548 * - The difference between this function and VarFix() is that VarFix() rounds
4549 * negative numbers towards 0, while this function rounds them away from zero.
4550 */
4551 HRESULT WINAPI VarInt(LPVARIANT pVarIn, LPVARIANT pVarOut)
4552 {
4553 HRESULT hRet = S_OK;
4554 VARIANT temp;
4555
4556 VariantInit(&temp);
4557
4558 TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
4559
4560 /* Handle VT_DISPATCH by storing and taking address of returned value */
4561 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
4562 {
4563 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
4564 if (FAILED(hRet)) goto VarInt_Exit;
4565 pVarIn = &temp;
4566 }
4567 V_VT(pVarOut) = V_VT(pVarIn);
4568
4569 switch (V_VT(pVarIn))
4570 {
4571 case VT_R4:
4572 V_R4(pVarOut) = (float)floor(V_R4(pVarIn));
4573 break;
4574 case VT_BSTR:
4575 V_VT(pVarOut) = VT_R8;
4576 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
4577 pVarIn = pVarOut;
4578 /* Fall through */
4579 case VT_DATE:
4580 case VT_R8:
4581 V_R8(pVarOut) = floor(V_R8(pVarIn));
4582 break;
4583 case VT_CY:
4584 hRet = VarCyInt(V_CY(pVarIn), &V_CY(pVarOut));
4585 break;
4586 case VT_DECIMAL:
4587 hRet = VarDecInt(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
4588 break;
4589 default:
4590 hRet = VarFix(pVarIn, pVarOut);
4591 }
4592 VarInt_Exit:
4593 VariantClear(&temp);
4594
4595 return hRet;
4596 }
4597
4598 /**********************************************************************
4599 * VarXor [OLEAUT32.167]
4600 *
4601 * Perform a logical exclusive-or (XOR) operation on two variants.
4602 *
4603 * PARAMS
4604 * pVarLeft [I] First variant
4605 * pVarRight [I] Variant to XOR with pVarLeft
4606 * pVarOut [O] Destination for XOR result
4607 *
4608 * RETURNS
4609 * Success: S_OK. pVarOut contains the result of the operation with its type
4610 * taken from the table below).
4611 * Failure: An HRESULT error code indicating the error.
4612 *
4613 * NOTES
4614 * - Neither pVarLeft or pVarRight are modified by this function.
4615 * - This function does not process by-reference variants.
4616 * - Input types of VT_BSTR may be numeric strings or boolean text.
4617 * - The type of result stored in pVarOut depends on the types of pVarLeft
4618 * and pVarRight, and will be one of VT_UI1, VT_I2, VT_I4, VT_I8, VT_BOOL,
4619 * or VT_NULL if the function succeeds.
4620 * - Type promotion is inconsistent and as a result certain combinations of
4621 * values will return DISP_E_OVERFLOW even when they could be represented.
4622 * This matches the behaviour of native oleaut32.
4623 */
4624 HRESULT WINAPI VarXor(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
4625 {
4626 VARTYPE vt;
4627 VARIANT varLeft, varRight;
4628 VARIANT tempLeft, tempRight;
4629 double d;
4630 HRESULT hRet;
4631
4632 TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
4633
4634 if (V_EXTRA_TYPE(pVarLeft) || V_EXTRA_TYPE(pVarRight) ||
4635 V_VT(pVarLeft) > VT_UINT || V_VT(pVarRight) > VT_UINT ||
4636 V_VT(pVarLeft) == VT_VARIANT || V_VT(pVarRight) == VT_VARIANT ||
4637 V_VT(pVarLeft) == VT_UNKNOWN || V_VT(pVarRight) == VT_UNKNOWN ||
4638 V_VT(pVarLeft) == (VARTYPE)15 || V_VT(pVarRight) == (VARTYPE)15 ||
4639 V_VT(pVarLeft) == VT_ERROR || V_VT(pVarRight) == VT_ERROR)
4640 return DISP_E_BADVARTYPE;
4641
4642 if (V_VT(pVarLeft) == VT_NULL || V_VT(pVarRight) == VT_NULL)
4643 {
4644 /* NULL XOR anything valid is NULL */
4645 V_VT(pVarOut) = VT_NULL;
4646 return S_OK;
4647 }
4648
4649 VariantInit(&tempLeft);
4650 VariantInit(&tempRight);
4651
4652 /* Handle VT_DISPATCH by storing and taking address of returned value */
4653 if ((V_VT(pVarLeft) & VT_TYPEMASK) == VT_DISPATCH)
4654 {
4655 hRet = VARIANT_FetchDispatchValue(pVarLeft, &tempLeft);
4656 if (FAILED(hRet)) goto VarXor_Exit;
4657 pVarLeft = &tempLeft;
4658 }
4659 if ((V_VT(pVarRight) & VT_TYPEMASK) == VT_DISPATCH)
4660 {
4661 hRet = VARIANT_FetchDispatchValue(pVarRight, &tempRight);
4662 if (FAILED(hRet)) goto VarXor_Exit;
4663 pVarRight = &tempRight;
4664 }
4665
4666 /* Copy our inputs so we don't disturb anything */
4667 V_VT(&varLeft) = V_VT(&varRight) = VT_EMPTY;
4668
4669 hRet = VariantCopy(&varLeft, pVarLeft);
4670 if (FAILED(hRet))
4671 goto VarXor_Exit;
4672
4673 hRet = VariantCopy(&varRight, pVarRight);
4674 if (FAILED(hRet))
4675 goto VarXor_Exit;
4676
4677 /* Try any strings first as numbers, then as VT_BOOL */
4678 if (V_VT(&varLeft) == VT_BSTR)
4679 {
4680 hRet = VarR8FromStr(V_BSTR(&varLeft), LOCALE_USER_DEFAULT, 0, &d);
4681 hRet = VariantChangeType(&varLeft, &varLeft, VARIANT_LOCALBOOL,
4682 FAILED(hRet) ? VT_BOOL : VT_I4);
4683 if (FAILED(hRet))
4684 goto VarXor_Exit;
4685 }
4686
4687 if (V_VT(&varRight) == VT_BSTR)
4688 {
4689 hRet = VarR8FromStr(V_BSTR(&varRight), LOCALE_USER_DEFAULT, 0, &d);
4690 hRet = VariantChangeType(&varRight, &varRight, VARIANT_LOCALBOOL,
4691 FAILED(hRet) ? VT_BOOL : VT_I4);
4692 if (FAILED(hRet))
4693 goto VarXor_Exit;
4694 }
4695
4696 /* Determine the result type */
4697 if (V_VT(&varLeft) == VT_I8 || V_VT(&varRight) == VT_I8)
4698 {
4699 if (V_VT(pVarLeft) == VT_INT || V_VT(pVarRight) == VT_INT)
4700 {
4701 hRet = DISP_E_TYPEMISMATCH;
4702 goto VarXor_Exit;
4703 }
4704 vt = VT_I8;
4705 }
4706 else
4707 {
4708 switch ((V_VT(&varLeft) << 16) | V_VT(&varRight))
4709 {
4710 case (VT_BOOL << 16) | VT_BOOL:
4711 vt = VT_BOOL;
4712 break;
4713 case (VT_UI1 << 16) | VT_UI1:
4714 vt = VT_UI1;
4715 break;
4716 case (VT_EMPTY << 16) | VT_EMPTY:
4717 case (VT_EMPTY << 16) | VT_UI1:
4718 case (VT_EMPTY << 16) | VT_I2:
4719 case (VT_EMPTY << 16) | VT_BOOL:
4720 case (VT_UI1 << 16) | VT_EMPTY:
4721 case (VT_UI1 << 16) | VT_I2:
4722 case (VT_UI1 << 16) | VT_BOOL:
4723 case (VT_I2 << 16) | VT_EMPTY:
4724 case (VT_I2 << 16) | VT_UI1:
4725 case (VT_I2 << 16) | VT_I2:
4726 case (VT_I2 << 16) | VT_BOOL:
4727 case (VT_BOOL << 16) | VT_EMPTY:
4728 case (VT_BOOL << 16) | VT_UI1:
4729 case (VT_BOOL << 16) | VT_I2:
4730 vt = VT_I2;
4731 break;
4732 default:
4733 vt = VT_I4;
4734 break;
4735 }
4736 }
4737
4738 /* VT_UI4 does not overflow */
4739 if (vt != VT_I8)
4740 {
4741 if (V_VT(&varLeft) == VT_UI4)
4742 V_VT(&varLeft) = VT_I4;
4743 if (V_VT(&varRight) == VT_UI4)
4744 V_VT(&varRight) = VT_I4;
4745 }
4746
4747 /* Convert our input copies to the result type */
4748 if (V_VT(&varLeft) != vt)
4749 hRet = VariantChangeType(&varLeft, &varLeft, 0, vt);
4750 if (FAILED(hRet))
4751 goto VarXor_Exit;
4752
4753 if (V_VT(&varRight) != vt)
4754 hRet = VariantChangeType(&varRight, &varRight, 0, vt);
4755 if (FAILED(hRet))
4756 goto VarXor_Exit;
4757
4758 V_VT(pVarOut) = vt;
4759
4760 /* Calculate the result */
4761 switch (vt)
4762 {
4763 case VT_I8:
4764 V_I8(pVarOut) = V_I8(&varLeft) ^ V_I8(&varRight);
4765 break;
4766 case VT_I4:
4767 V_I4(pVarOut) = V_I4(&varLeft) ^ V_I4(&varRight);
4768 break;
4769 case VT_BOOL:
4770 case VT_I2:
4771 V_I2(pVarOut) = V_I2(&varLeft) ^ V_I2(&varRight);
4772 break;
4773 case VT_UI1:
4774 V_UI1(pVarOut) = V_UI1(&varLeft) ^ V_UI1(&varRight);
4775 break;
4776 }
4777
4778 VarXor_Exit:
4779 VariantClear(&varLeft);
4780 VariantClear(&varRight);
4781 VariantClear(&tempLeft);
4782 VariantClear(&tempRight);
4783 return hRet;
4784 }
4785
4786 /**********************************************************************
4787 * VarEqv [OLEAUT32.172]
4788 *
4789 * Determine if two variants contain the same value.
4790 *
4791 * PARAMS
4792 * pVarLeft [I] First variant to compare
4793 * pVarRight [I] Variant to compare to pVarLeft
4794 * pVarOut [O] Destination for comparison result
4795 *
4796 * RETURNS
4797 * Success: S_OK. pVarOut contains the result of the comparison (VARIANT_TRUE
4798 * if equivalent or non-zero otherwise.
4799 * Failure: An HRESULT error code indicating the error.
4800 *
4801 * NOTES
4802 * - This function simply calls VarXor() on pVarLeft and pVarRight and inverts
4803 * the result.
4804 */
4805 HRESULT WINAPI VarEqv(LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
4806 {
4807 HRESULT hRet;
4808
4809 TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
4810
4811 hRet = VarXor(pVarLeft, pVarRight, pVarOut);
4812 if (SUCCEEDED(hRet))
4813 {
4814 if (V_VT(pVarOut) == VT_I8)
4815 V_I8(pVarOut) = ~V_I8(pVarOut);
4816 else
4817 V_UI4(pVarOut) = ~V_UI4(pVarOut);
4818 }
4819 return hRet;
4820 }
4821
4822 /**********************************************************************
4823 * VarNeg [OLEAUT32.173]
4824 *
4825 * Negate the value of a variant.
4826 *
4827 * PARAMS
4828 * pVarIn [I] Source variant
4829 * pVarOut [O] Destination for converted value
4830 *
4831 * RETURNS
4832 * Success: S_OK. pVarOut contains the converted value.
4833 * Failure: An HRESULT error code indicating the error.
4834 *
4835 * NOTES
4836 * - The type of the value stored in pVarOut depends on the type of pVarIn,
4837 * according to the following table:
4838 *| Input Type Output Type
4839 *| ---------- -----------
4840 *| VT_EMPTY VT_I2
4841 *| VT_UI1 VT_I2
4842 *| VT_BOOL VT_I2
4843 *| VT_BSTR VT_R8
4844 *| All Others Unchanged (unless promoted)
4845 * - Where the negated value of a variant does not fit in its base type, the type
4846 * is promoted according to the following table:
4847 *| Input Type Promoted To
4848 *| ---------- -----------
4849 *| VT_I2 VT_I4
4850 *| VT_I4 VT_R8
4851 *| VT_I8 VT_R8
4852 * - The native version of this function returns DISP_E_BADVARTYPE for valid
4853 * variant types that cannot be negated, and returns DISP_E_TYPEMISMATCH
4854 * for types which are not valid. Since this is in contravention of the
4855 * meaning of those error codes and unlikely to be relied on by applications,
4856 * this implementation returns errors consistent with the other high level
4857 * variant math functions.
4858 */
4859 HRESULT WINAPI VarNeg(LPVARIANT pVarIn, LPVARIANT pVarOut)
4860 {
4861 HRESULT hRet = S_OK;
4862 VARIANT temp;
4863
4864 VariantInit(&temp);
4865
4866 TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
4867
4868 /* Handle VT_DISPATCH by storing and taking address of returned value */
4869 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
4870 {
4871 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
4872 if (FAILED(hRet)) goto VarNeg_Exit;
4873 pVarIn = &temp;
4874 }
4875 V_VT(pVarOut) = V_VT(pVarIn);
4876
4877 switch (V_VT(pVarIn))
4878 {
4879 case VT_UI1:
4880 V_VT(pVarOut) = VT_I2;
4881 V_I2(pVarOut) = -V_UI1(pVarIn);
4882 break;
4883 case VT_BOOL:
4884 V_VT(pVarOut) = VT_I2;
4885 /* Fall through */
4886 case VT_I2:
4887 if (V_I2(pVarIn) == I2_MIN)
4888 {
4889 V_VT(pVarOut) = VT_I4;
4890 V_I4(pVarOut) = -(int)V_I2(pVarIn);
4891 }
4892 else
4893 V_I2(pVarOut) = -V_I2(pVarIn);
4894 break;
4895 case VT_I4:
4896 if (V_I4(pVarIn) == I4_MIN)
4897 {
4898 V_VT(pVarOut) = VT_R8;
4899 V_R8(pVarOut) = -(double)V_I4(pVarIn);
4900 }
4901 else
4902 V_I4(pVarOut) = -V_I4(pVarIn);
4903 break;
4904 case VT_I8:
4905 if (V_I8(pVarIn) == I8_MIN)
4906 {
4907 V_VT(pVarOut) = VT_R8;
4908 hRet = VarR8FromI8(V_I8(pVarIn), &V_R8(pVarOut));
4909 V_R8(pVarOut) *= -1.0;
4910 }
4911 else
4912 V_I8(pVarOut) = -V_I8(pVarIn);
4913 break;
4914 case VT_R4:
4915 V_R4(pVarOut) = -V_R4(pVarIn);
4916 break;
4917 case VT_DATE:
4918 case VT_R8:
4919 V_R8(pVarOut) = -V_R8(pVarIn);
4920 break;
4921 case VT_CY:
4922 hRet = VarCyNeg(V_CY(pVarIn), &V_CY(pVarOut));
4923 break;
4924 case VT_DECIMAL:
4925 hRet = VarDecNeg(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
4926 break;
4927 case VT_BSTR:
4928 V_VT(pVarOut) = VT_R8;
4929 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
4930 V_R8(pVarOut) = -V_R8(pVarOut);
4931 break;
4932 case VT_EMPTY:
4933 V_VT(pVarOut) = VT_I2;
4934 V_I2(pVarOut) = 0;
4935 break;
4936 case VT_NULL:
4937 /* No-Op */
4938 break;
4939 default:
4940 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
4941 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
4942 hRet = DISP_E_BADVARTYPE;
4943 else
4944 hRet = DISP_E_TYPEMISMATCH;
4945 }
4946 VarNeg_Exit:
4947 if (FAILED(hRet))
4948 V_VT(pVarOut) = VT_EMPTY;
4949 VariantClear(&temp);
4950
4951 return hRet;
4952 }
4953
4954 /**********************************************************************
4955 * VarNot [OLEAUT32.174]
4956 *
4957 * Perform a not operation on a variant.
4958 *
4959 * PARAMS
4960 * pVarIn [I] Source variant
4961 * pVarOut [O] Destination for converted value
4962 *
4963 * RETURNS
4964 * Success: S_OK. pVarOut contains the converted value.
4965 * Failure: An HRESULT error code indicating the error.
4966 *
4967 * NOTES
4968 * - Strictly speaking, this function performs a bitwise ones complement
4969 * on the variants value (after possibly converting to VT_I4, see below).
4970 * This only behaves like a boolean not operation if the value in
4971 * pVarIn is either VARIANT_TRUE or VARIANT_FALSE and the type is signed.
4972 * - To perform a genuine not operation, convert the variant to a VT_BOOL
4973 * before calling this function.
4974 * - This function does not process by-reference variants.
4975 * - The type of the value stored in pVarOut depends on the type of pVarIn,
4976 * according to the following table:
4977 *| Input Type Output Type
4978 *| ---------- -----------
4979 *| VT_EMPTY VT_I2
4980 *| VT_R4 VT_I4
4981 *| VT_R8 VT_I4
4982 *| VT_BSTR VT_I4
4983 *| VT_DECIMAL VT_I4
4984 *| VT_CY VT_I4
4985 *| (All others) Unchanged
4986 */
4987 HRESULT WINAPI VarNot(LPVARIANT pVarIn, LPVARIANT pVarOut)
4988 {
4989 VARIANT varIn;
4990 HRESULT hRet = S_OK;
4991 VARIANT temp;
4992
4993 VariantInit(&temp);
4994
4995 TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
4996
4997 /* Handle VT_DISPATCH by storing and taking address of returned value */
4998 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
4999 {
5000 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
5001 if (FAILED(hRet)) goto VarNot_Exit;
5002 pVarIn = &temp;
5003 }
5004
5005 if (V_VT(pVarIn) == VT_BSTR)
5006 {
5007 V_VT(&varIn) = VT_R8;
5008 hRet = VarR8FromStr( V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn) );
5009 if (FAILED(hRet))
5010 {
5011 V_VT(&varIn) = VT_BOOL;
5012 hRet = VarBoolFromStr( V_BSTR(pVarIn), LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &V_BOOL(&varIn) );
5013 }
5014 if (FAILED(hRet)) goto VarNot_Exit;
5015 pVarIn = &varIn;
5016 }
5017
5018 V_VT(pVarOut) = V_VT(pVarIn);
5019
5020 switch (V_VT(pVarIn))
5021 {
5022 case VT_I1:
5023 V_I4(pVarOut) = ~V_I1(pVarIn);
5024 V_VT(pVarOut) = VT_I4;
5025 break;
5026 case VT_UI1: V_UI1(pVarOut) = ~V_UI1(pVarIn); break;
5027 case VT_BOOL:
5028 case VT_I2: V_I2(pVarOut) = ~V_I2(pVarIn); break;
5029 case VT_UI2:
5030 V_I4(pVarOut) = ~V_UI2(pVarIn);
5031 V_VT(pVarOut) = VT_I4;
5032 break;
5033 case VT_DECIMAL:
5034 hRet = VarI4FromDec(&V_DECIMAL(pVarIn), &V_I4(&varIn));
5035 if (FAILED(hRet))
5036 break;
5037 pVarIn = &varIn;
5038 /* Fall through ... */
5039 case VT_INT:
5040 V_VT(pVarOut) = VT_I4;
5041 /* Fall through ... */
5042 case VT_I4: V_I4(pVarOut) = ~V_I4(pVarIn); break;
5043 case VT_UINT:
5044 case VT_UI4:
5045 V_I4(pVarOut) = ~V_UI4(pVarIn);
5046 V_VT(pVarOut) = VT_I4;
5047 break;
5048 case VT_I8: V_I8(pVarOut) = ~V_I8(pVarIn); break;
5049 case VT_UI8:
5050 V_I4(pVarOut) = ~V_UI8(pVarIn);
5051 V_VT(pVarOut) = VT_I4;
5052 break;
5053 case VT_R4:
5054 hRet = VarI4FromR4(V_R4(pVarIn), &V_I4(pVarOut));
5055 V_I4(pVarOut) = ~V_I4(pVarOut);
5056 V_VT(pVarOut) = VT_I4;
5057 break;
5058 case VT_DATE:
5059 case VT_R8:
5060 hRet = VarI4FromR8(V_R8(pVarIn), &V_I4(pVarOut));
5061 V_I4(pVarOut) = ~V_I4(pVarOut);
5062 V_VT(pVarOut) = VT_I4;
5063 break;
5064 case VT_CY:
5065 hRet = VarI4FromCy(V_CY(pVarIn), &V_I4(pVarOut));
5066 V_I4(pVarOut) = ~V_I4(pVarOut);
5067 V_VT(pVarOut) = VT_I4;
5068 break;
5069 case VT_EMPTY:
5070 V_I2(pVarOut) = ~0;
5071 V_VT(pVarOut) = VT_I2;
5072 break;
5073 case VT_NULL:
5074 /* No-Op */
5075 break;
5076 default:
5077 if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
5078 FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
5079 hRet = DISP_E_BADVARTYPE;
5080 else
5081 hRet = DISP_E_TYPEMISMATCH;
5082 }
5083 VarNot_Exit:
5084 if (FAILED(hRet))
5085 V_VT(pVarOut) = VT_EMPTY;
5086 VariantClear(&temp);
5087
5088 return hRet;
5089 }
5090
5091 /**********************************************************************
5092 * VarRound [OLEAUT32.175]
5093 *
5094 * Perform a round operation on a variant.
5095 *
5096 * PARAMS
5097 * pVarIn [I] Source variant
5098 * deci [I] Number of decimals to round to
5099 * pVarOut [O] Destination for converted value
5100 *
5101 * RETURNS
5102 * Success: S_OK. pVarOut contains the converted value.
5103 * Failure: An HRESULT error code indicating the error.
5104 *
5105 * NOTES
5106 * - Floating point values are rounded to the desired number of decimals.
5107 * - Some integer types are just copied to the return variable.
5108 * - Some other integer types are not handled and fail.
5109 */
5110 HRESULT WINAPI VarRound(LPVARIANT pVarIn, int deci, LPVARIANT pVarOut)
5111 {
5112 VARIANT varIn;
5113 HRESULT hRet = S_OK;
5114 float factor;
5115 VARIANT temp;
5116
5117 VariantInit(&temp);
5118
5119 TRACE("(%s,%d)\n", debugstr_variant(pVarIn), deci);
5120
5121 /* Handle VT_DISPATCH by storing and taking address of returned value */
5122 if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
5123 {
5124 hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
5125 if (FAILED(hRet)) goto VarRound_Exit;
5126 pVarIn = &temp;
5127 }
5128
5129 switch (V_VT(pVarIn))
5130 {
5131 /* cases that fail on windows */
5132 case VT_I1:
5133 case VT_I8:
5134 case VT_UI2:
5135 case VT_UI4:
5136 hRet = DISP_E_BADVARTYPE;
5137 break;
5138
5139 /* cases just copying in to out */
5140 case VT_UI1:
5141 V_VT(pVarOut) = V_VT(pVarIn);
5142 V_UI1(pVarOut) = V_UI1(pVarIn);
5143 break;
5144 case VT_I2:
5145 V_VT(pVarOut) = V_VT(pVarIn);
5146 V_I2(pVarOut) = V_I2(pVarIn);
5147 break;
5148 case VT_I4:
5149 V_VT(pVarOut) = V_VT(pVarIn);
5150 V_I4(pVarOut) = V_I4(pVarIn);
5151 break;
5152 case VT_NULL:
5153 V_VT(pVarOut) = V_VT(pVarIn);
5154 /* value unchanged */
5155 break;
5156
5157 /* cases that change type */
5158 case VT_EMPTY:
5159 V_VT(pVarOut) = VT_I2;
5160 V_I2(pVarOut) = 0;
5161 break;
5162 case VT_BOOL:
5163 V_VT(pVarOut) = VT_I2;
5164 V_I2(pVarOut) = V_BOOL(pVarIn);
5165 break;
5166 case VT_BSTR:
5167 hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
5168 if (FAILED(hRet))
5169 break;
5170 V_VT(&varIn)=VT_R8;
5171 pVarIn = &varIn;
5172 /* Fall through ... */
5173
5174 /* cases we need to do math */
5175 case VT_R8:
5176 if (V_R8(pVarIn)>0) {
5177 V_R8(pVarOut)=floor(V_R8(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
5178 } else {
5179 V_R8(pVarOut)=ceil(V_R8(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
5180 }
5181 V_VT(pVarOut) = V_VT(pVarIn);
5182 break;
5183 case VT_R4:
5184 if (V_R4(pVarIn)>0) {
5185 V_R4(pVarOut)=floor(V_R4(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
5186 } else {
5187 V_R4(pVarOut)=ceil(V_R4(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
5188 }
5189 V_VT(pVarOut) = V_VT(pVarIn);
5190 break;
5191 case VT_DATE:
5192 if (V_DATE(pVarIn)>0) {
5193 V_DATE(pVarOut)=floor(V_DATE(pVarIn)*pow(10, deci)+0.5)/pow(10, deci);
5194 } else {
5195 V_DATE(pVarOut)=ceil(V_DATE(pVarIn)*pow(10, deci)-0.5)/pow(10, deci);
5196 }
5197 V_VT(pVarOut) = V_VT(pVarIn);
5198 break;
5199 case VT_CY:
5200 if (deci>3)
5201 factor=1;
5202 else
5203 factor=pow(10, 4-deci);
5204
5205 if (V_CY(pVarIn).int64>0) {
5206 V_CY(pVarOut).int64=floor(V_CY(pVarIn).int64/factor)*factor;
5207 } else {
5208 V_CY(pVarOut).int64=ceil(V_CY(pVarIn).int64/factor)*factor;
5209 }
5210 V_VT(pVarOut) = V_VT(pVarIn);
5211 break;
5212 case VT_DECIMAL:
5213 {
5214 double dbl;
5215
5216 hRet = VarR8FromDec(&V_DECIMAL(pVarIn), &dbl);
5217 if (FAILED(hRet))
5218 break;
5219
5220 if (dbl>0.0f)
5221 dbl = floor(dbl*pow(10,deci)+0.5);
5222 else
5223 dbl = ceil(dbl*pow(10,deci)-0.5);
5224
5225 V_VT(pVarOut)=VT_DECIMAL;
5226 hRet = VarDecFromR8(dbl, &V_DECIMAL(pVarOut));
5227 break;
5228 }
5229 /* cases we don't know yet */
5230 default:
5231 FIXME("unimplemented part, V_VT(pVarIn) == 0x%X, deci == %d\n",
5232 V_VT(pVarIn) & VT_TYPEMASK, deci);
5233 hRet = DISP_E_BADVARTYPE;
5234 }
5235 VarRound_Exit:
5236 if (FAILED(hRet))
5237 V_VT(pVarOut) = VT_EMPTY;
5238 VariantClear(&temp);
5239
5240 TRACE("returning 0x%08x %s\n", hRet, debugstr_variant(pVarOut));
5241 return hRet;
5242 }
5243
5244 /**********************************************************************
5245 * VarIdiv [OLEAUT32.153]
5246 *
5247 * Converts input variants to integers and divides them.
5248 *
5249 * PARAMS
5250 * left [I] Left hand variant
5251 * right [I] Right hand variant
5252 * result [O] Destination for quotient
5253 *
5254 * RETURNS
5255 * Success: S_OK. result contains the quotient.
5256 * Failure: An HRESULT error code indicating the error.
5257 *
5258 * NOTES
5259 * If either expression is null, null is returned, as per MSDN
5260 */
5261 HRESULT WINAPI VarIdiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5262 {
5263 HRESULT hres = S_OK;
5264 VARTYPE resvt = VT_EMPTY;
5265 VARTYPE leftvt,rightvt;
5266 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
5267 VARIANT lv,rv;
5268 VARIANT tempLeft, tempRight;
5269
5270 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
5271
5272 VariantInit(&lv);
5273 VariantInit(&rv);
5274 VariantInit(&tempLeft);
5275 VariantInit(&tempRight);
5276
5277 leftvt = V_VT(left)&VT_TYPEMASK;
5278 rightvt = V_VT(right)&VT_TYPEMASK;
5279 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
5280 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
5281
5282 if (leftExtraFlags != rightExtraFlags)
5283 {
5284 hres = DISP_E_BADVARTYPE;
5285 goto end;
5286 }
5287 ExtraFlags = leftExtraFlags;
5288
5289 /* Native VarIdiv always returns an error when using extra
5290 * flags or if the variant combination is I8 and INT.
5291 */
5292 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5293 (leftvt == VT_INT && rightvt == VT_I8) ||
5294 (rightvt == VT_EMPTY && leftvt != VT_NULL) ||
5295 ExtraFlags != 0)
5296 {
5297 hres = DISP_E_BADVARTYPE;
5298 goto end;
5299 }
5300
5301 /* Determine variant type */
5302 else if (leftvt == VT_NULL || rightvt == VT_NULL)
5303 {
5304 V_VT(result) = VT_NULL;
5305 hres = S_OK;
5306 goto end;
5307 }
5308 else if (leftvt == VT_I8 || rightvt == VT_I8)
5309 resvt = VT_I8;
5310 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5311 leftvt == VT_INT || rightvt == VT_INT ||
5312 leftvt == VT_UINT || rightvt == VT_UINT ||
5313 leftvt == VT_UI8 || rightvt == VT_UI8 ||
5314 leftvt == VT_UI4 || rightvt == VT_UI4 ||
5315 leftvt == VT_UI2 || rightvt == VT_UI2 ||
5316 leftvt == VT_I1 || rightvt == VT_I1 ||
5317 leftvt == VT_BSTR || rightvt == VT_BSTR ||
5318 leftvt == VT_DATE || rightvt == VT_DATE ||
5319 leftvt == VT_CY || rightvt == VT_CY ||
5320 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
5321 leftvt == VT_R8 || rightvt == VT_R8 ||
5322 leftvt == VT_R4 || rightvt == VT_R4)
5323 resvt = VT_I4;
5324 else if (leftvt == VT_I2 || rightvt == VT_I2 ||
5325 leftvt == VT_BOOL || rightvt == VT_BOOL ||
5326 leftvt == VT_EMPTY)
5327 resvt = VT_I2;
5328 else if (leftvt == VT_UI1 || rightvt == VT_UI1)
5329 resvt = VT_UI1;
5330 else
5331 {
5332 hres = DISP_E_BADVARTYPE;
5333 goto end;
5334 }
5335
5336 /* coerce to the result type */
5337 hres = VariantChangeType(&lv, left, 0, resvt);
5338 if (hres != S_OK) goto end;
5339 hres = VariantChangeType(&rv, right, 0, resvt);
5340 if (hres != S_OK) goto end;
5341
5342 /* do the math */
5343 V_VT(result) = resvt;
5344 switch (resvt)
5345 {
5346 case VT_UI1:
5347 if (V_UI1(&rv) == 0)
5348 {
5349 hres = DISP_E_DIVBYZERO;
5350 V_VT(result) = VT_EMPTY;
5351 }
5352 else
5353 V_UI1(result) = V_UI1(&lv) / V_UI1(&rv);
5354 break;
5355 case VT_I2:
5356 if (V_I2(&rv) == 0)
5357 {
5358 hres = DISP_E_DIVBYZERO;
5359 V_VT(result) = VT_EMPTY;
5360 }
5361 else
5362 V_I2(result) = V_I2(&lv) / V_I2(&rv);
5363 break;
5364 case VT_I4:
5365 if (V_I4(&rv) == 0)
5366 {
5367 hres = DISP_E_DIVBYZERO;
5368 V_VT(result) = VT_EMPTY;
5369 }
5370 else
5371 V_I4(result) = V_I4(&lv) / V_I4(&rv);
5372 break;
5373 case VT_I8:
5374 if (V_I8(&rv) == 0)
5375 {
5376 hres = DISP_E_DIVBYZERO;
5377 V_VT(result) = VT_EMPTY;
5378 }
5379 else
5380 V_I8(result) = V_I8(&lv) / V_I8(&rv);
5381 break;
5382 default:
5383 FIXME("Couldn't integer divide variant types %d,%d\n",
5384 leftvt,rightvt);
5385 }
5386
5387 end:
5388 VariantClear(&lv);
5389 VariantClear(&rv);
5390 VariantClear(&tempLeft);
5391 VariantClear(&tempRight);
5392
5393 return hres;
5394 }
5395
5396
5397 /**********************************************************************
5398 * VarMod [OLEAUT32.155]
5399 *
5400 * Perform the modulus operation of the right hand variant on the left
5401 *
5402 * PARAMS
5403 * left [I] Left hand variant
5404 * right [I] Right hand variant
5405 * result [O] Destination for converted value
5406 *
5407 * RETURNS
5408 * Success: S_OK. result contains the remainder.
5409 * Failure: An HRESULT error code indicating the error.
5410 *
5411 * NOTE:
5412 * If an error occurs the type of result will be modified but the value will not be.
5413 * Doesn't support arrays or any special flags yet.
5414 */
5415 HRESULT WINAPI VarMod(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5416 {
5417 BOOL lOk = TRUE;
5418 HRESULT rc = E_FAIL;
5419 int resT = 0;
5420 VARIANT lv,rv;
5421 VARIANT tempLeft, tempRight;
5422
5423 VariantInit(&tempLeft);
5424 VariantInit(&tempRight);
5425 VariantInit(&lv);
5426 VariantInit(&rv);
5427
5428 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
5429
5430 /* Handle VT_DISPATCH by storing and taking address of returned value */
5431 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
5432 {
5433 rc = VARIANT_FetchDispatchValue(left, &tempLeft);
5434 if (FAILED(rc)) goto end;
5435 left = &tempLeft;
5436 }
5437 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
5438 {
5439 rc = VARIANT_FetchDispatchValue(right, &tempRight);
5440 if (FAILED(rc)) goto end;
5441 right = &tempRight;
5442 }
5443
5444 /* check for invalid inputs */
5445 lOk = TRUE;
5446 switch (V_VT(left) & VT_TYPEMASK) {
5447 case VT_BOOL :
5448 case VT_I1 :
5449 case VT_I2 :
5450 case VT_I4 :
5451 case VT_I8 :
5452 case VT_INT :
5453 case VT_UI1 :
5454 case VT_UI2 :
5455 case VT_UI4 :
5456 case VT_UI8 :
5457 case VT_UINT :
5458 case VT_R4 :
5459 case VT_R8 :
5460 case VT_CY :
5461 case VT_EMPTY:
5462 case VT_DATE :
5463 case VT_BSTR :
5464 case VT_DECIMAL:
5465 break;
5466 case VT_VARIANT:
5467 case VT_UNKNOWN:
5468 V_VT(result) = VT_EMPTY;
5469 rc = DISP_E_TYPEMISMATCH;
5470 goto end;
5471 case VT_ERROR:
5472 rc = DISP_E_TYPEMISMATCH;
5473 goto end;
5474 case VT_RECORD:
5475 V_VT(result) = VT_EMPTY;
5476 rc = DISP_E_TYPEMISMATCH;
5477 goto end;
5478 case VT_NULL:
5479 break;
5480 default:
5481 V_VT(result) = VT_EMPTY;
5482 rc = DISP_E_BADVARTYPE;
5483 goto end;
5484 }
5485
5486
5487 switch (V_VT(right) & VT_TYPEMASK) {
5488 case VT_BOOL :
5489 case VT_I1 :
5490 case VT_I2 :
5491 case VT_I4 :
5492 case VT_I8 :
5493 if((V_VT(left) == VT_INT) && (V_VT(right) == VT_I8))
5494 {
5495 V_VT(result) = VT_EMPTY;
5496 rc = DISP_E_TYPEMISMATCH;
5497 goto end;
5498 }
5499 case VT_INT :
5500 if((V_VT(right) == VT_INT) && (V_VT(left) == VT_I8))
5501 {
5502 V_VT(result) = VT_EMPTY;
5503 rc = DISP_E_TYPEMISMATCH;
5504 goto end;
5505 }
5506 case VT_UI1 :
5507 case VT_UI2 :
5508 case VT_UI4 :
5509 case VT_UI8 :
5510 case VT_UINT :
5511 case VT_R4 :
5512 case VT_R8 :
5513 case VT_CY :
5514 if(V_VT(left) == VT_EMPTY)
5515 {
5516 V_VT(result) = VT_I4;
5517 rc = S_OK;
5518 goto end;
5519 }
5520 case VT_EMPTY:
5521 case VT_DATE :
5522 case VT_DECIMAL:
5523 if(V_VT(left) == VT_ERROR)
5524 {
5525 V_VT(result) = VT_EMPTY;
5526 rc = DISP_E_TYPEMISMATCH;
5527 goto end;
5528 }
5529 case VT_BSTR:
5530 if(V_VT(left) == VT_NULL)
5531 {
5532 V_VT(result) = VT_NULL;
5533 rc = S_OK;
5534 goto end;
5535 }
5536 break;
5537
5538 case VT_VOID:
5539 V_VT(result) = VT_EMPTY;
5540 rc = DISP_E_BADVARTYPE;
5541 goto end;
5542 case VT_NULL:
5543 if(V_VT(left) == VT_VOID)
5544 {
5545 V_VT(result) = VT_EMPTY;
5546 rc = DISP_E_BADVARTYPE;
5547 } else if((V_VT(left) == VT_NULL) || (V_VT(left) == VT_EMPTY) || (V_VT(left) == VT_ERROR) ||
5548 lOk)
5549 {
5550 V_VT(result) = VT_NULL;
5551 rc = S_OK;
5552 } else
5553 {
5554 V_VT(result) = VT_NULL;
5555 rc = DISP_E_BADVARTYPE;
5556 }
5557 goto end;
5558 case VT_VARIANT:
5559 case VT_UNKNOWN:
5560 V_VT(result) = VT_EMPTY;
5561 rc = DISP_E_TYPEMISMATCH;
5562 goto end;
5563 case VT_ERROR:
5564 rc = DISP_E_TYPEMISMATCH;
5565 goto end;
5566 case VT_RECORD:
5567 if((V_VT(left) == 15) || ((V_VT(left) >= 24) && (V_VT(left) <= 35)) || !lOk)
5568 {
5569 V_VT(result) = VT_EMPTY;
5570 rc = DISP_E_BADVARTYPE;
5571 } else
5572 {
5573 V_VT(result) = VT_EMPTY;
5574 rc = DISP_E_TYPEMISMATCH;
5575 }
5576 goto end;
5577 default:
5578 V_VT(result) = VT_EMPTY;
5579 rc = DISP_E_BADVARTYPE;
5580 goto end;
5581 }
5582
5583 /* determine the result type */
5584 if((V_VT(left) == VT_I8) || (V_VT(right) == VT_I8)) resT = VT_I8;
5585 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
5586 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_UI1)) resT = VT_UI1;
5587 else if((V_VT(left) == VT_UI1) && (V_VT(right) == VT_I2)) resT = VT_I2;
5588 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
5589 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_UI1)) resT = VT_I2;
5590 else if((V_VT(left) == VT_I2) && (V_VT(right) == VT_I2)) resT = VT_I2;
5591 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_BOOL)) resT = VT_I2;
5592 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_UI1)) resT = VT_I2;
5593 else if((V_VT(left) == VT_BOOL) && (V_VT(right) == VT_I2)) resT = VT_I2;
5594 else resT = VT_I4; /* most outputs are I4 */
5595
5596 /* convert to I8 for the modulo */
5597 rc = VariantChangeType(&lv, left, 0, VT_I8);
5598 if(FAILED(rc))
5599 {
5600 FIXME("Could not convert left type %d to %d? rc == 0x%X\n", V_VT(left), VT_I8, rc);
5601 goto end;
5602 }
5603
5604 rc = VariantChangeType(&rv, right, 0, VT_I8);
5605 if(FAILED(rc))
5606 {
5607 FIXME("Could not convert right type %d to %d? rc == 0x%X\n", V_VT(right), VT_I8, rc);
5608 goto end;
5609 }
5610
5611 /* if right is zero set VT_EMPTY and return divide by zero */
5612 if(V_I8(&rv) == 0)
5613 {
5614 V_VT(result) = VT_EMPTY;
5615 rc = DISP_E_DIVBYZERO;
5616 goto end;
5617 }
5618
5619 /* perform the modulo operation */
5620 V_VT(result) = VT_I8;
5621 V_I8(result) = V_I8(&lv) % V_I8(&rv);
5622
5623 TRACE("V_I8(left) == %s, V_I8(right) == %s, V_I8(result) == %s\n",
5624 wine_dbgstr_longlong(V_I8(&lv)), wine_dbgstr_longlong(V_I8(&rv)),
5625 wine_dbgstr_longlong(V_I8(result)));
5626
5627 /* convert left and right to the destination type */
5628 rc = VariantChangeType(result, result, 0, resT);
5629 if(FAILED(rc))
5630 {
5631 FIXME("Could not convert 0x%x to %d?\n", V_VT(result), resT);
5632 /* fall to end of function */
5633 }
5634
5635 end:
5636 VariantClear(&lv);
5637 VariantClear(&rv);
5638 VariantClear(&tempLeft);
5639 VariantClear(&tempRight);
5640 return rc;
5641 }
5642
5643 /**********************************************************************
5644 * VarPow [OLEAUT32.158]
5645 *
5646 * Computes the power of one variant to another variant.
5647 *
5648 * PARAMS
5649 * left [I] First variant
5650 * right [I] Second variant
5651 * result [O] Result variant
5652 *
5653 * RETURNS
5654 * Success: S_OK.
5655 * Failure: An HRESULT error code indicating the error.
5656 */
5657 HRESULT WINAPI VarPow(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5658 {
5659 HRESULT hr = S_OK;
5660 VARIANT dl,dr;
5661 VARTYPE resvt = VT_EMPTY;
5662 VARTYPE leftvt,rightvt;
5663 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
5664 VARIANT tempLeft, tempRight;
5665
5666 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
5667
5668 VariantInit(&dl);
5669 VariantInit(&dr);
5670 VariantInit(&tempLeft);
5671 VariantInit(&tempRight);
5672
5673 /* Handle VT_DISPATCH by storing and taking address of returned value */
5674 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
5675 {
5676 hr = VARIANT_FetchDispatchValue(left, &tempLeft);
5677 if (FAILED(hr)) goto end;
5678 left = &tempLeft;
5679 }
5680 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
5681 {
5682 hr = VARIANT_FetchDispatchValue(right, &tempRight);
5683 if (FAILED(hr)) goto end;
5684 right = &tempRight;
5685 }
5686
5687 leftvt = V_VT(left)&VT_TYPEMASK;
5688 rightvt = V_VT(right)&VT_TYPEMASK;
5689 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
5690 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
5691
5692 if (leftExtraFlags != rightExtraFlags)
5693 {
5694 hr = DISP_E_BADVARTYPE;
5695 goto end;
5696 }
5697 ExtraFlags = leftExtraFlags;
5698
5699 /* Native VarPow always returns an error when using extra flags */
5700 if (ExtraFlags != 0)
5701 {
5702 hr = DISP_E_BADVARTYPE;
5703 goto end;
5704 }
5705
5706 /* Determine return type */
5707 else if (leftvt == VT_NULL || rightvt == VT_NULL) {
5708 V_VT(result) = VT_NULL;
5709 hr = S_OK;
5710 goto end;
5711 }
5712 else if ((leftvt == VT_EMPTY || leftvt == VT_I2 ||
5713 leftvt == VT_I4 || leftvt == VT_R4 ||
5714 leftvt == VT_R8 || leftvt == VT_CY ||
5715 leftvt == VT_DATE || leftvt == VT_BSTR ||
5716 leftvt == VT_BOOL || leftvt == VT_DECIMAL ||
5717 (leftvt >= VT_I1 && leftvt <= VT_UINT)) &&
5718 (rightvt == VT_EMPTY || rightvt == VT_I2 ||
5719 rightvt == VT_I4 || rightvt == VT_R4 ||
5720 rightvt == VT_R8 || rightvt == VT_CY ||
5721 rightvt == VT_DATE || rightvt == VT_BSTR ||
5722 rightvt == VT_BOOL || rightvt == VT_DECIMAL ||
5723 (rightvt >= VT_I1 && rightvt <= VT_UINT)))
5724 resvt = VT_R8;
5725 else
5726 {
5727 hr = DISP_E_BADVARTYPE;
5728 goto end;
5729 }
5730
5731 hr = VariantChangeType(&dl,left,0,resvt);
5732 if (FAILED(hr)) {
5733 ERR("Could not change passed left argument to VT_R8, handle it differently.\n");
5734 hr = E_FAIL;
5735 goto end;
5736 }
5737
5738 hr = VariantChangeType(&dr,right,0,resvt);
5739 if (FAILED(hr)) {
5740 ERR("Could not change passed right argument to VT_R8, handle it differently.\n");
5741 hr = E_FAIL;
5742 goto end;
5743 }
5744
5745 V_VT(result) = VT_R8;
5746 V_R8(result) = pow(V_R8(&dl),V_R8(&dr));
5747
5748 end:
5749 VariantClear(&dl);
5750 VariantClear(&dr);
5751 VariantClear(&tempLeft);
5752 VariantClear(&tempRight);
5753
5754 return hr;
5755 }
5756
5757 /**********************************************************************
5758 * VarImp [OLEAUT32.154]
5759 *
5760 * Bitwise implication of two variants.
5761 *
5762 * PARAMS
5763 * left [I] First variant
5764 * right [I] Second variant
5765 * result [O] Result variant
5766 *
5767 * RETURNS
5768 * Success: S_OK.
5769 * Failure: An HRESULT error code indicating the error.
5770 */
5771 HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result)
5772 {
5773 HRESULT hres = S_OK;
5774 VARTYPE resvt = VT_EMPTY;
5775 VARTYPE leftvt,rightvt;
5776 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
5777 VARIANT lv,rv;
5778 double d;
5779 VARIANT tempLeft, tempRight;
5780
5781 VariantInit(&lv);
5782 VariantInit(&rv);
5783 VariantInit(&tempLeft);
5784 VariantInit(&tempRight);
5785
5786 TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
5787
5788 /* Handle VT_DISPATCH by storing and taking address of returned value */
5789 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
5790 {
5791 hres = VARIANT_FetchDispatchValue(left, &tempLeft);
5792 if (FAILED(hres)) goto VarImp_Exit;
5793 left = &tempLeft;
5794 }
5795 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
5796 {
5797 hres = VARIANT_FetchDispatchValue(right, &tempRight);
5798 if (FAILED(hres)) goto VarImp_Exit;
5799 right = &tempRight;
5800 }
5801
5802 leftvt = V_VT(left)&VT_TYPEMASK;
5803 rightvt = V_VT(right)&VT_TYPEMASK;
5804 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
5805 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
5806
5807 if (leftExtraFlags != rightExtraFlags)
5808 {
5809 hres = DISP_E_BADVARTYPE;
5810 goto VarImp_Exit;
5811 }
5812 ExtraFlags = leftExtraFlags;
5813
5814 /* Native VarImp always returns an error when using extra
5815 * flags or if the variants are I8 and INT.
5816 */
5817 if ((leftvt == VT_I8 && rightvt == VT_INT) ||
5818 ExtraFlags != 0)
5819 {
5820 hres = DISP_E_BADVARTYPE;
5821 goto VarImp_Exit;
5822 }
5823
5824 /* Determine result type */
5825 else if ((leftvt == VT_NULL && rightvt == VT_NULL) ||
5826 (leftvt == VT_NULL && rightvt == VT_EMPTY))
5827 {
5828 V_VT(result) = VT_NULL;
5829 hres = S_OK;
5830 goto VarImp_Exit;
5831 }
5832 else if (leftvt == VT_I8 || rightvt == VT_I8)
5833 resvt = VT_I8;
5834 else if (leftvt == VT_I4 || rightvt == VT_I4 ||
5835 leftvt == VT_INT || rightvt == VT_INT ||
5836 leftvt == VT_UINT || rightvt == VT_UINT ||
5837 leftvt == VT_UI4 || rightvt == VT_UI4 ||
5838 leftvt == VT_UI8 || rightvt == VT_UI8 ||
5839 leftvt == VT_UI2 || rightvt == VT_UI2 ||
5840 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL ||
5841 leftvt == VT_DATE || rightvt == VT_DATE ||
5842 leftvt == VT_CY || rightvt == VT_CY ||
5843 leftvt == VT_R8 || rightvt == VT_R8 ||
5844 leftvt == VT_R4 || rightvt == VT_R4 ||
5845 leftvt == VT_I1 || rightvt == VT_I1)
5846 resvt = VT_I4;
5847 else if ((leftvt == VT_UI1 && rightvt == VT_UI1) ||
5848 (leftvt == VT_UI1 && rightvt == VT_NULL) ||
5849 (leftvt == VT_NULL && rightvt == VT_UI1))
5850 resvt = VT_UI1;
5851 else if (leftvt == VT_EMPTY || rightvt == VT_EMPTY ||
5852 leftvt == VT_I2 || rightvt == VT_I2 ||
5853 leftvt == VT_UI1 || rightvt == VT_UI1)
5854 resvt = VT_I2;
5855 else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
5856 leftvt == VT_BSTR || rightvt == VT_BSTR)
5857 resvt = VT_BOOL;
5858
5859 /* VT_NULL requires special handling for when the opposite
5860 * variant is equal to something other than -1.
5861 * (NULL Imp 0 = NULL, NULL Imp n = n)
5862 */
5863 if (leftvt == VT_NULL)
5864 {
5865 VARIANT_BOOL b;
5866 switch(rightvt)
5867 {
5868 case VT_I1: if (!V_I1(right)) resvt = VT_NULL; break;
5869 case VT_UI1: if (!V_UI1(right)) resvt = VT_NULL; break;
5870 case VT_I2: if (!V_I2(right)) resvt = VT_NULL; break;
5871 case VT_UI2: if (!V_UI2(right)) resvt = VT_NULL; break;
5872 case VT_I4: if (!V_I4(right)) resvt = VT_NULL; break;
5873 case VT_UI4: if (!V_UI4(right)) resvt = VT_NULL; break;
5874 case VT_I8: if (!V_I8(right)) resvt = VT_NULL; break;
5875 case VT_UI8: if (!V_UI8(right)) resvt = VT_NULL; break;
5876 case VT_INT: if (!V_INT(right)) resvt = VT_NULL; break;
5877 case VT_UINT: if (!V_UINT(right)) resvt = VT_NULL; break;
5878 case VT_BOOL: if (!V_BOOL(right)) resvt = VT_NULL; break;
5879 case VT_R4: if (!V_R4(right)) resvt = VT_NULL; break;
5880 case VT_R8: if (!V_R8(right)) resvt = VT_NULL; break;
5881 case VT_DATE: if (!V_DATE(right)) resvt = VT_NULL; break;
5882 case VT_CY: if (!V_CY(right).int64) resvt = VT_NULL; break;
5883 case VT_DECIMAL:
5884 if (!(DEC_HI32(&V_DECIMAL(right)) || DEC_LO64(&V_DECIMAL(right))))
5885 resvt = VT_NULL;
5886 break;
5887 case VT_BSTR:
5888 hres = VarBoolFromStr(V_BSTR(right),LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b);
5889 if (FAILED(hres)) goto VarImp_Exit;
5890 else if (!b)
5891 V_VT(result) = VT_NULL;
5892 else
5893 {
5894 V_VT(result) = VT_BOOL;
5895 V_BOOL(result) = b;
5896 }
5897 goto VarImp_Exit;
5898 }
5899 if (resvt == VT_NULL)
5900 {
5901 V_VT(result) = resvt;
5902 goto VarImp_Exit;
5903 }
5904 else
5905 {
5906 hres = VariantChangeType(result,right,0,resvt);
5907 goto VarImp_Exit;
5908 }
5909 }
5910
5911 /* Special handling is required when NULL is the right variant.
5912 * (-1 Imp NULL = NULL, n Imp NULL = n Imp 0)
5913 */
5914 else if (rightvt == VT_NULL)
5915 {
5916 VARIANT_BOOL b;
5917 switch(leftvt)
5918 {
5919 case VT_I1: if (V_I1(left) == -1) resvt = VT_NULL; break;
5920 case VT_UI1: if (V_UI1(left) == 0xff) resvt = VT_NULL; break;
5921 case VT_I2: if (V_I2(left) == -1) resvt = VT_NULL; break;
5922 case VT_UI2: if (V_UI2(left) == 0xffff) resvt = VT_NULL; break;
5923 case VT_INT: if (V_INT(left) == -1) resvt = VT_NULL; break;
5924 case VT_UINT: if (V_UINT(left) == ~0u) resvt = VT_NULL; break;
5925 case VT_I4: if (V_I4(left) == -1) resvt = VT_NULL; break;
5926 case VT_UI4: if (V_UI4(left) == ~0u) resvt = VT_NULL; break;
5927 case VT_I8: if (V_I8(left) == -1) resvt = VT_NULL; break;
5928 case VT_UI8: if (V_UI8(left) == ~(ULONGLONG)0) resvt = VT_NULL; break;
5929 case VT_BOOL: if (V_BOOL(left) == VARIANT_TRUE) resvt = VT_NULL; break;
5930 case VT_R4: if (V_R4(left) == -1.0) resvt = VT_NULL; break;
5931 case VT_R8: if (V_R8(left) == -1.0) resvt = VT_NULL; break;
5932 case VT_CY: if (V_CY(left).int64 == -1) resvt = VT_NULL; break;
5933 case VT_DECIMAL:
5934 if (DEC_HI32(&V_DECIMAL(left)) == 0xffffffff)
5935 resvt = VT_NULL;
5936 break;
5937 case VT_BSTR:
5938 hres = VarBoolFromStr(V_BSTR(left),LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b);
5939 if (FAILED(hres)) goto VarImp_Exit;
5940 else if (b == VARIANT_TRUE)
5941 resvt = VT_NULL;
5942 }
5943 if (resvt == VT_NULL)
5944 {
5945 V_VT(result) = resvt;
5946 goto VarImp_Exit;
5947 }
5948 }
5949
5950 hres = VariantCopy(&lv, left);
5951 if (FAILED(hres)) goto VarImp_Exit;
5952
5953 if (rightvt == VT_NULL)
5954 {
5955 memset( &rv, 0, sizeof(rv) );
5956 V_VT(&rv) = resvt;
5957 }
5958 else
5959 {
5960 hres = VariantCopy(&rv, right);
5961 if (FAILED(hres)) goto VarImp_Exit;
5962 }
5963
5964 if (V_VT(&lv) == VT_BSTR &&
5965 FAILED(VarR8FromStr(V_BSTR(&lv),LOCALE_USER_DEFAULT, 0, &d)))
5966 hres = VariantChangeType(&lv,&lv,VARIANT_LOCALBOOL, VT_BOOL);
5967 if (SUCCEEDED(hres) && V_VT(&lv) != resvt)
5968 hres = VariantChangeType(&lv,&lv,0,resvt);
5969 if (FAILED(hres)) goto VarImp_Exit;
5970
5971 if (V_VT(&rv) == VT_BSTR &&
5972 FAILED(VarR8FromStr(V_BSTR(&rv),LOCALE_USER_DEFAULT, 0, &d)))
5973 hres = VariantChangeType(&rv, &rv,VARIANT_LOCALBOOL, VT_BOOL);
5974 if (SUCCEEDED(hres) && V_VT(&rv) != resvt)
5975 hres = VariantChangeType(&rv, &rv, 0, resvt);
5976 if (FAILED(hres)) goto VarImp_Exit;
5977
5978 /* do the math */
5979 V_VT(result) = resvt;
5980 switch (resvt)
5981 {
5982 case VT_I8:
5983 V_I8(result) = (~V_I8(&lv)) | V_I8(&rv);
5984 break;
5985 case VT_I4:
5986 V_I4(result) = (~V_I4(&lv)) | V_I4(&rv);
5987 break;
5988 case VT_I2:
5989 V_I2(result) = (~V_I2(&lv)) | V_I2(&rv);
5990 break;
5991 case VT_UI1:
5992 V_UI1(result) = (~V_UI1(&lv)) | V_UI1(&rv);
5993 break;
5994 case VT_BOOL:
5995 V_BOOL(result) = (~V_BOOL(&lv)) | V_BOOL(&rv);
5996 break;
5997 default:
5998 FIXME("Couldn't perform bitwise implication on variant types %d,%d\n",
5999 leftvt,rightvt);
6000 }
6001
6002 VarImp_Exit:
6003
6004 VariantClear(&lv);
6005 VariantClear(&rv);
6006 VariantClear(&tempLeft);
6007 VariantClear(&tempRight);
6008
6009 return hres;
6010 }
Windows API implementation