4 * Copyright 2003 Jon Griffiths
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #define NONAMELESSUNION
21 #define NONAMELESSSTRUCT
27 /* Get just the type from a variant pointer */
28 #define V_TYPE(v) (V_VT((v)) & VT_TYPEMASK)
30 /* Flags set in V_VT, other than the actual type value */
31 #define VT_EXTRA_TYPE (VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED)
33 /* Get the extra flags from a variant pointer */
34 #define V_EXTRA_TYPE(v) (V_VT((v)) & VT_EXTRA_TYPE)
36 extern const char* wine_vtypes
[];
37 #define debugstr_vt(v) (((v)&VT_TYPEMASK) <= VT_CLSID ? wine_vtypes[((v)&VT_TYPEMASK)] : \
38 ((v)&VT_TYPEMASK) == VT_BSTR_BLOB ? "VT_BSTR_BLOB": "Invalid")
39 #define debugstr_VT(v) (!(v) ? "(null)" : debugstr_vt(V_TYPE((v))))
41 extern const char* wine_vflags
[];
42 #define debugstr_vf(v) (wine_vflags[((v)&VT_EXTRA_TYPE)>>12])
43 #define debugstr_VF(v) (!(v) ? "(null)" : debugstr_vf(V_EXTRA_TYPE(v)))
45 /* Size constraints */
47 #define I1_MIN ((-I1_MAX)-1)
51 #define I2_MIN ((-I2_MAX)-1)
52 #define UI2_MAX 0xffff
54 #define I4_MAX 0x7fffffff
55 #define I4_MIN ((-I4_MAX)-1)
56 #define UI4_MAX 0xffffffff
58 #define I8_MAX (((LONGLONG)I4_MAX << 32) | UI4_MAX)
59 #define I8_MIN ((-I8_MAX)-1)
60 #define UI8_MAX (((ULONGLONG)UI4_MAX << 32) | UI4_MAX)
62 #define DATE_MAX 2958465
63 #define DATE_MIN -657434
64 #define R4_MAX 3.402823567797336e38
65 #define R4_MIN 1.40129846432481707e-45
66 #define R8_MAX 1.79769313486231470e+308
67 #define R8_MIN 4.94065645841246544e-324
69 /* Value of sign for a positive decimal number */
72 /* Native headers don't change the union ordering for DECIMAL sign/scale (duh).
73 * This means that the signscale member is only useful for setting both members to 0.
74 * SIGNSCALE creates endian-correct values so that we can properly set both at once
75 * to values other than 0.
77 #ifdef WORDS_BIGENDIAN
78 #define SIGNSCALE(sign,scale) (((scale) << 8) | sign)
80 #define SIGNSCALE(sign,scale) (((sign) << 8) | scale)
83 /* Macros for getting at a DECIMAL's parts */
84 #define DEC_SIGN(d) ((d)->u.s.sign)
85 #define DEC_SCALE(d) ((d)->u.s.scale)
86 #define DEC_SIGNSCALE(d) ((d)->u.signscale)
87 #define DEC_HI32(d) ((d)->Hi32)
88 #define DEC_MID32(d) ((d)->u1.s1.Mid32)
89 #define DEC_LO32(d) ((d)->u1.s1.Lo32)
90 #define DEC_LO64(d) ((d)->u1.Lo64)
92 #define DEC_MAX_SCALE 28 /* Maximum scale for a decimal */
94 /* Inline return type */
95 #define RETTYP inline static HRESULT
97 /* Simple compiler cast from one type to another */
98 #define SIMPLE(dest, src, func) RETTYP _##func(src in, dest* out) { \
99 *out = in; return S_OK; }
101 /* Compiler cast where input cannot be negative */
102 #define NEGTST(dest, src, func) RETTYP _##func(src in, dest* out) { \
103 if (in < (src)0) return DISP_E_OVERFLOW; *out = in; return S_OK; }
105 /* Compiler cast where input cannot be > some number */
106 #define POSTST(dest, src, func, tst) RETTYP _##func(src in, dest* out) { \
107 if (in > (dest)tst) return DISP_E_OVERFLOW; *out = in; return S_OK; }
109 /* Compiler cast where input cannot be < some number or >= some other number */
110 #define BOTHTST(dest, src, func, lo, hi) RETTYP _##func(src in, dest* out) { \
111 if (in < (dest)lo || in > hi) return DISP_E_OVERFLOW; *out = in; return S_OK; }
113 /* Conversions from IDispatch use the same code */
114 HRESULT
VARIANT_FromDisp(IDispatch
*,LCID
,void*,VARTYPE
);
115 /* As do conversions from BSTR to numeric types */
116 HRESULT
VARIANT_NumberFromBstr(OLECHAR
*,LCID
,ULONG
,void*,VARTYPE
);
118 #define CY_MULTIPLIER 10000 /* 4 dp of precision */
119 #define CY_MULTIPLIER_F 10000.0
120 #define CY_HALF (CY_MULTIPLIER/2) /* 0.5 */
121 #define CY_HALF_F (CY_MULTIPLIER_F/2.0)
124 POSTST(signed char, BYTE
, VarI1FromUI1
, I1_MAX
);
125 BOTHTST(signed char, SHORT
, VarI1FromI2
, I1_MIN
, I1_MAX
);
126 BOTHTST(signed char, LONG
, VarI1FromI4
, I1_MIN
, I1_MAX
);
127 #define _VarI1FromR4(flt,out) VarI1FromR8((double)flt,out)
128 #define _VarI1FromR8 VarI1FromR8
129 #define _VarI1FromCy VarI1FromCy
130 #define _VarI1FromDate(dt,out) VarI1FromR8((double)dt,out)
131 #define _VarI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I1)
132 #define _VarI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I1)
133 SIMPLE(signed char, VARIANT_BOOL
, VarI1FromBool
);
134 POSTST(signed char, USHORT
, VarI1FromUI2
, I1_MAX
);
135 POSTST(signed char, ULONG
, VarI1FromUI4
, I1_MAX
);
136 #define _VarI1FromDec VarI1FromDec
137 BOTHTST(signed char, LONG64
, VarI1FromI8
, I1_MIN
, I1_MAX
);
138 POSTST(signed char, ULONG64
, VarI1FromUI8
, I1_MAX
);
141 BOTHTST(BYTE
, SHORT
, VarUI1FromI2
, UI1_MIN
, UI1_MAX
);
142 #define _VarUI1FromR4(flt,out) VarUI1FromR8((double)flt,out)
143 #define _VarUI1FromR8 VarUI1FromR8
144 #define _VarUI1FromCy VarUI1FromCy
145 #define _VarUI1FromDate(dt,out) VarUI1FromR8((double)dt,out)
146 #define _VarUI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI1)
147 #define _VarUI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI1)
148 SIMPLE(BYTE
, VARIANT_BOOL
, VarUI1FromBool
);
149 NEGTST(BYTE
, signed char, VarUI1FromI1
);
150 POSTST(BYTE
, USHORT
, VarUI1FromUI2
, UI1_MAX
);
151 BOTHTST(BYTE
, LONG
, VarUI1FromI4
, UI1_MIN
, UI1_MAX
);
152 POSTST(BYTE
, ULONG
, VarUI1FromUI4
, UI1_MAX
);
153 #define _VarUI1FromDec VarUI1FromDec
154 BOTHTST(BYTE
, LONG64
, VarUI1FromI8
, UI1_MIN
, UI1_MAX
);
155 POSTST(BYTE
, ULONG64
, VarUI1FromUI8
, UI1_MAX
);
158 SIMPLE(SHORT
, BYTE
, VarI2FromUI1
);
159 BOTHTST(SHORT
, LONG
, VarI2FromI4
, I2_MIN
, I2_MAX
);
160 #define _VarI2FromR4(flt,out) VarI2FromR8((double)flt,out)
161 #define _VarI2FromR8 VarI2FromR8
162 #define _VarI2FromCy VarI2FromCy
163 #define _VarI2FromDate(dt,out) VarI2FromR8((double)dt,out)
164 #define _VarI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I2)
165 #define _VarI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I2)
166 SIMPLE(SHORT
, VARIANT_BOOL
, VarI2FromBool
);
167 SIMPLE(SHORT
, signed char, VarI2FromI1
);
168 POSTST(SHORT
, USHORT
, VarI2FromUI2
, I2_MAX
);
169 POSTST(SHORT
, ULONG
, VarI2FromUI4
, I2_MAX
);
170 #define _VarI2FromDec VarI2FromDec
171 BOTHTST(SHORT
, LONG64
, VarI2FromI8
, I2_MIN
, I2_MAX
);
172 POSTST(SHORT
, ULONG64
, VarI2FromUI8
, I2_MAX
);
175 SIMPLE(USHORT
, BYTE
, VarUI2FromUI1
);
176 NEGTST(USHORT
, SHORT
, VarUI2FromI2
);
177 BOTHTST(USHORT
, LONG
, VarUI2FromI4
, UI2_MIN
, UI2_MAX
);
178 #define _VarUI2FromR4(flt,out) VarUI2FromR8((double)flt,out)
179 #define _VarUI2FromR8 VarUI2FromR8
180 #define _VarUI2FromCy VarUI2FromCy
181 #define _VarUI2FromDate(dt,out) VarUI2FromR8((double)dt,out)
182 #define _VarUI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI2)
183 #define _VarUI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI2)
184 SIMPLE(USHORT
, VARIANT_BOOL
, VarUI2FromBool
);
185 NEGTST(USHORT
, signed char, VarUI2FromI1
);
186 POSTST(USHORT
, ULONG
, VarUI2FromUI4
, UI2_MAX
);
187 #define _VarUI2FromDec VarUI2FromDec
188 BOTHTST(USHORT
, LONG64
, VarUI2FromI8
, UI2_MIN
, UI2_MAX
);
189 POSTST(USHORT
, ULONG64
, VarUI2FromUI8
, UI2_MAX
);
192 SIMPLE(LONG
, BYTE
, VarI4FromUI1
);
193 SIMPLE(LONG
, SHORT
, VarI4FromI2
);
194 #define _VarI4FromR4(flt,out) VarI4FromR8((double)flt,out)
195 #define _VarI4FromR8 VarI4FromR8
196 #define _VarI4FromCy VarI4FromCy
197 #define _VarI4FromDate(dt,out) VarI4FromR8((double)dt,out)
198 #define _VarI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I4)
199 #define _VarI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I4)
200 SIMPLE(LONG
, VARIANT_BOOL
, VarI4FromBool
);
201 SIMPLE(LONG
, signed char, VarI4FromI1
);
202 SIMPLE(LONG
, USHORT
, VarI4FromUI2
);
203 POSTST(LONG
, ULONG
, VarI4FromUI4
, I4_MAX
);
204 #define _VarI4FromDec VarI4FromDec
205 BOTHTST(LONG
, LONG64
, VarI4FromI8
, I4_MIN
, I4_MAX
);
206 POSTST(LONG
, ULONG64
, VarI4FromUI8
, I4_MAX
);
209 SIMPLE(ULONG
, BYTE
, VarUI4FromUI1
);
210 NEGTST(ULONG
, SHORT
, VarUI4FromI2
);
211 NEGTST(ULONG
, LONG
, VarUI4FromI4
);
212 #define _VarUI4FromR4(flt,out) VarUI4FromR8((double)flt,out)
213 #define _VarUI4FromR8 VarUI4FromR8
214 #define _VarUI4FromCy VarUI4FromCy
215 #define _VarUI4FromDate(dt,out) VarUI4FromR8((double)dt,out)
216 #define _VarUI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI4)
217 #define _VarUI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI4)
218 SIMPLE(ULONG
, VARIANT_BOOL
, VarUI4FromBool
);
219 NEGTST(ULONG
, signed char, VarUI4FromI1
);
220 SIMPLE(ULONG
, USHORT
, VarUI4FromUI2
);
221 #define _VarUI4FromDec VarUI4FromDec
222 BOTHTST(ULONG
, LONG64
, VarUI4FromI8
, UI4_MIN
, UI4_MAX
);
223 POSTST(ULONG
, ULONG64
, VarUI4FromUI8
, UI4_MAX
);
226 SIMPLE(LONG64
, BYTE
, VarI8FromUI1
);
227 SIMPLE(LONG64
, SHORT
, VarI8FromI2
);
228 #define _VarI8FromR4 VarI8FromR8
229 #define _VarI8FromR8 VarI8FromR8
230 #define _VarI8FromCy VarI8FromCy
231 #define _VarI8FromDate(dt,out) VarI8FromR8((double)dt,out)
232 #define _VarI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I8)
233 #define _VarI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_I8)
234 #define _VarI8FromBool _VarI8FromI2
235 SIMPLE(LONG64
, signed char, VarI8FromI1
);
236 SIMPLE(LONG64
, USHORT
, VarI8FromUI2
);
237 SIMPLE(LONG64
, LONG
, VarI8FromI4
);
238 SIMPLE(LONG64
, ULONG
, VarI8FromUI4
);
239 #define _VarI8FromDec VarI8FromDec
240 POSTST(LONG64
, ULONG64
, VarI8FromUI8
, I8_MAX
);
243 SIMPLE(ULONG64
, BYTE
, VarUI8FromUI1
);
244 NEGTST(ULONG64
, SHORT
, VarUI8FromI2
);
245 #define _VarUI8FromR4 VarUI8FromR8
246 #define _VarUI8FromR8 VarUI8FromR8
247 #define _VarUI8FromCy VarUI8FromCy
248 #define _VarUI8FromDate(dt,out) VarUI8FromR8((double)dt,out)
249 #define _VarUI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI8)
250 #define _VarUI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI8)
251 #define _VarUI8FromBool _VarI8FromI2
252 NEGTST(ULONG64
, signed char, VarUI8FromI1
);
253 SIMPLE(ULONG64
, USHORT
, VarUI8FromUI2
);
254 NEGTST(ULONG64
, LONG
, VarUI8FromI4
);
255 SIMPLE(ULONG64
, ULONG
, VarUI8FromUI4
);
256 #define _VarUI8FromDec VarUI8FromDec
257 NEGTST(ULONG64
, LONG64
, VarUI8FromI8
);
260 SIMPLE(float, BYTE
, VarR4FromUI1
);
261 SIMPLE(float, SHORT
, VarR4FromI2
);
262 RETTYP
_VarR4FromR8(double i
, float* o
) {
263 double d
= i
< 0.0 ? -i
: i
;
264 if (d
> R4_MAX
) return DISP_E_OVERFLOW
;
268 RETTYP
_VarR4FromCy(CY i
, float* o
) { *o
= (double)i
.int64
/ CY_MULTIPLIER_F
; return S_OK
; }
269 #define _VarR4FromDate(dt,out) _VarR4FromR8((double)dt,out)
270 #define _VarR4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R4)
271 #define _VarR4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R4)
272 #define _VarR4FromBool _VarR4FromI2
273 SIMPLE(float, signed char, VarR4FromI1
);
274 SIMPLE(float, USHORT
, VarR4FromUI2
);
275 SIMPLE(float, LONG
, VarR4FromI4
);
276 SIMPLE(float, ULONG
, VarR4FromUI4
);
277 #define _VarR4FromDec VarR4FromDec
278 SIMPLE(float, LONG64
, VarR4FromI8
);
279 SIMPLE(float, ULONG64
, VarR4FromUI8
);
282 SIMPLE(double, BYTE
, VarR8FromUI1
);
283 SIMPLE(double, SHORT
, VarR8FromI2
);
284 SIMPLE(double, float, VarR8FromR4
);
285 RETTYP
_VarR8FromCy(CY i
, double* o
) { *o
= (double)i
.int64
/ CY_MULTIPLIER_F
; return S_OK
; }
286 SIMPLE(double, DATE
, VarR8FromDate
);
287 #define _VarR8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R8)
288 #define _VarR8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R8)
289 #define _VarR8FromBool _VarR8FromI2
290 SIMPLE(double, signed char, VarR8FromI1
);
291 SIMPLE(double, USHORT
, VarR8FromUI2
);
292 SIMPLE(double, LONG
, VarR8FromI4
);
293 SIMPLE(double, ULONG
, VarR8FromUI4
);
294 #define _VarR8FromDec VarR8FromDec
295 SIMPLE(double, LONG64
, VarR8FromI8
);
296 SIMPLE(double, ULONG64
, VarR8FromUI8
);
299 #define BOOLFUNC(src, func) RETTYP _##func(src in, VARIANT_BOOL* out) { \
300 *out = in ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; }
302 BOOLFUNC(signed char,VarBoolFromI1
);
303 BOOLFUNC(BYTE
,VarBoolFromUI1
);
304 BOOLFUNC(SHORT
,VarBoolFromI2
);
305 BOOLFUNC(USHORT
,VarBoolFromUI2
);
306 BOOLFUNC(LONG
,VarBoolFromI4
);
307 BOOLFUNC(ULONG
,VarBoolFromUI4
);
308 BOOLFUNC(LONG64
,VarBoolFromI8
);
309 BOOLFUNC(ULONG64
,VarBoolFromUI8
);
310 #define _VarBoolFromR4(flt,out) _VarBoolFromR8((double)flt,out)
311 BOOLFUNC(double,VarBoolFromR8
);
312 #define _VarBoolFromCy(i,o) _VarBoolFromI8(i.int64,o)
313 #define _VarBoolFromDate(dt,out) _VarBoolFromR8((double)dt,out)
314 #define _VarBoolFromStr VarBoolFromStr
315 #define _VarBoolFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_BOOL)
316 #define _VarBoolFromDec VarBoolFromDec
318 /* Internal flags for low level conversion functions */
319 #define VAR_BOOLONOFF 0x0400 /* Convert bool to "On"/"Off" */
320 #define VAR_BOOLYESNO 0x0800 /* Convert bool to "Yes"/"No" */
321 #define VAR_NEGATIVE 0x1000 /* Number is negative */
324 #define _VarDecFromUI1 VarDecFromUI4
325 #define _VarDecFromI2 VarDecFromI4
326 #define _VarDecFromR4 VarDecFromR4
327 #define _VarDecFromR8 VarDecFromR8
328 #define _VarDecFromCy VarDecFromCy
329 #define _VarDecFromDate(dt,out) VarDecFromR8((double)dt,out)
330 #define _VarDecFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_DECIMAL)
331 #define _VarDecFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DECIMAL)
332 #define _VarDecFromBool VarDecFromBool
333 #define _VarDecFromI1 VarDecFromI4
334 #define _VarDecFromUI2 VarDecFromUI4
335 #define _VarDecFromI4 VarDecFromI4
336 #define _VarDecFromUI4 VarDecFromUI4
337 #define _VarDecFromI8 VarDecFromI8
338 #define _VarDecFromUI8 VarDecFromUI8
341 #define _VarCyFromUI1 VarCyFromR8
342 #define _VarCyFromI2 VarCyFromR8
343 #define _VarCyFromR4 VarCyFromR8
344 #define _VarCyFromR8 VarCyFromR8
345 #define _VarCyFromDate VarCyFromR8
346 #define _VarCyFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_CY)
347 #define _VarCyFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_CY)
348 #define _VarCyFromBool VarCyFromR8
349 #define _VarCyFromI1 VarCyFromR8
350 #define _VarCyFromUI2 VarCyFromR8
351 #define _VarCyFromI4 VarCyFromR8
352 #define _VarCyFromUI4 VarCyFromR8
353 #define _VarCyFromDec VarCyFromDec
354 RETTYP
_VarCyFromI8(LONG64 i
, CY
* o
) {
355 if (i
<= (I8_MIN
/CY_MULTIPLIER
) || i
>= (I8_MAX
/CY_MULTIPLIER
)) return DISP_E_OVERFLOW
;
356 o
->int64
= i
* CY_MULTIPLIER
;
359 #define _VarCyFromUI8 VarCyFromR8
362 #define _VarDateFromUI1 _VarR8FromUI1
363 #define _VarDateFromI2 _VarR8FromI2
364 #define _VarDateFromR4 _VarDateFromR8
365 RETTYP
_VarDateFromR8(double i
, DATE
* o
) {
366 if (i
<= (DATE_MIN
- 1.0) || i
>= (DATE_MAX
+ 1.0)) return DISP_E_OVERFLOW
;
370 #define _VarDateFromCy _VarR8FromCy
371 #define _VarDateFromStr VarDateFromStr
372 #define _VarDateFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DATE)
373 #define _VarDateFromBool _VarR8FromBool
374 #define _VarDateFromI1 _VarR8FromI1
375 #define _VarDateFromUI2 _VarR8FromUI2
376 #define _VarDateFromI4 _VarDateFromR8
377 #define _VarDateFromUI4 _VarDateFromR8
378 #define _VarDateFromDec _VarR8FromDec
379 RETTYP
_VarDateFromI8(LONG64 i
, DATE
* o
) {
380 if (i
< DATE_MIN
|| i
> DATE_MAX
) return DISP_E_OVERFLOW
;
384 RETTYP
_VarDateFromUI8(ULONG64 i
, DATE
* o
) {
385 if (i
> DATE_MAX
) return DISP_E_OVERFLOW
;
391 #define _VarBstrFromUI1 VarBstrFromUI4
392 #define _VarBstrFromI2 VarBstrFromI4
393 #define _VarBstrFromR4 VarBstrFromR8
394 #define _VarBstrFromR8 VarBstrFromR8
395 #define _VarBstrFromCy VarBstrFromCy
396 #define _VarBstrFromDate VarBstrFromDate
397 #define _VarBstrFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_BSTR)
398 #define _VarBstrFromBool VarBstrFromBool
399 #define _VarBstrFromI1 VarBstrFromI4
400 #define _VarBstrFromUI2 VarBstrFromUI4
401 #define _VarBstrFromI4 VarBstrFromI4
402 #define _VarBstrFromUI4 VarBstrFromUI4
403 #define _VarBstrFromDec VarBstrFromDec
404 #define _VarBstrFromI8 VarBstrFromI8
405 #define _VarBstrFromUI8 VarBstrFromUI8
407 /* Macro to inline conversion from a float or double to any integer type,
408 * rounding according to the 'dutch' convention.
410 #define OLEAUT32_DutchRound(typ, value, res) do { \
411 double whole = (double)value < 0 ? ceil((double)value) : floor((double)value); \
412 double fract = (double)value - whole; \
413 if (fract > 0.5) res = (typ)whole + (typ)1; \
414 else if (fract == 0.5) { typ is_odd = (typ)whole & 1; res = whole + is_odd; } \
415 else if (fract >= 0.0) res = (typ)whole; \
416 else if (fract == -0.5) { typ is_odd = (typ)whole & 1; res = whole - is_odd; } \
417 else if (fract > -0.5) res = (typ)whole; \
418 else res = (typ)whole - (typ)1; \
421 /* The localised characters that make up a valid number */
422 typedef struct tagVARIANT_NUMBER_CHARS
424 WCHAR cNegativeSymbol
;
425 WCHAR cPositiveSymbol
;
427 WCHAR cDigitSeperator
;
428 WCHAR cCurrencyLocal
;
429 WCHAR cCurrencyLocal2
;
430 WCHAR cCurrencyDecimalPoint
;
431 WCHAR cCurrencyDigitSeperator
;
432 } VARIANT_NUMBER_CHARS
;
434 void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS
*,LCID
,DWORD
);