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