| /* |
| * Variant Inlines |
| * |
| * Copyright 2003 Jon Griffiths |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| #define NONAMELESSUNION |
| #define NONAMELESSSTRUCT |
| #include "windef.h" |
| #include "winerror.h" |
| #include "objbase.h" |
| #include "oleauto.h" |
| #include <math.h> |
| |
| /* Get just the type from a variant pointer */ |
| #define V_TYPE(v) (V_VT((v)) & VT_TYPEMASK) |
| |
| /* Flags set in V_VT, other than the actual type value */ |
| #define VT_EXTRA_TYPE (VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED) |
| |
| /* Get the extra flags from a variant pointer */ |
| #define V_EXTRA_TYPE(v) (V_VT((v)) & VT_EXTRA_TYPE) |
| |
| extern const char* wine_vtypes[]; |
| #define debugstr_vt(v) (((v)&VT_TYPEMASK) <= VT_CLSID ? wine_vtypes[((v)&VT_TYPEMASK)] : \ |
| ((v)&VT_TYPEMASK) == VT_BSTR_BLOB ? "VT_BSTR_BLOB": "Invalid") |
| #define debugstr_VT(v) (!(v) ? "(null)" : debugstr_vt(V_TYPE((v)))) |
| |
| extern const char* wine_vflags[]; |
| #define debugstr_vf(v) (wine_vflags[((v)&VT_EXTRA_TYPE)>>12]) |
| #define debugstr_VF(v) (!(v) ? "(null)" : debugstr_vf(V_EXTRA_TYPE(v))) |
| |
| /* Size constraints */ |
| #define I1_MAX 0x7f |
| #define I1_MIN ((-I1_MAX)-1) |
| #define UI1_MAX 0xff |
| #define UI1_MIN 0 |
| #define I2_MAX 0x7fff |
| #define I2_MIN ((-I2_MAX)-1) |
| #define UI2_MAX 0xffff |
| #define UI2_MIN 0 |
| #define I4_MAX 0x7fffffff |
| #define I4_MIN ((-I4_MAX)-1) |
| #define UI4_MAX 0xffffffff |
| #define UI4_MIN 0 |
| #define I8_MAX (((LONGLONG)I4_MAX << 32) | UI4_MAX) |
| #define I8_MIN ((-I8_MAX)-1) |
| #define UI8_MAX (((ULONGLONG)UI4_MAX << 32) | UI4_MAX) |
| #define UI8_MIN 0 |
| #define DATE_MAX 2958465 |
| #define DATE_MIN -657434 |
| #define R4_MAX 3.402823567797336e38 |
| #define R4_MIN 1.40129846432481707e-45 |
| #define R8_MAX 1.79769313486231470e+308 |
| #define R8_MIN 4.94065645841246544e-324 |
| |
| /* Value of sign for a positive decimal number */ |
| #define DECIMAL_POS 0 |
| |
| /* Native headers don't change the union ordering for DECIMAL sign/scale (duh). |
| * This means that the signscale member is only useful for setting both members to 0. |
| * SIGNSCALE creates endian-correct values so that we can properly set both at once |
| * to values other than 0. |
| */ |
| #ifdef WORDS_BIGENDIAN |
| #define SIGNSCALE(sign,scale) (((scale) << 8) | sign) |
| #else |
| #define SIGNSCALE(sign,scale) (((sign) << 8) | scale) |
| #endif |
| |
| /* Macros for getting at a DECIMAL's parts */ |
| #define DEC_SIGN(d) ((d)->u.s.sign) |
| #define DEC_SCALE(d) ((d)->u.s.scale) |
| #define DEC_SIGNSCALE(d) ((d)->u.signscale) |
| #define DEC_HI32(d) ((d)->Hi32) |
| #define DEC_MID32(d) ((d)->u1.s1.Mid32) |
| #define DEC_LO32(d) ((d)->u1.s1.Lo32) |
| #define DEC_LO64(d) ((d)->u1.Lo64) |
| |
| #define DEC_MAX_SCALE 28 /* Maximum scale for a decimal */ |
| |
| /* Inline return type */ |
| #define RETTYP inline static HRESULT |
| |
| /* Simple compiler cast from one type to another */ |
| #define SIMPLE(dest, src, func) RETTYP _##func(src in, dest* out) { \ |
| *out = in; return S_OK; } |
| |
| /* Compiler cast where input cannot be negative */ |
| #define NEGTST(dest, src, func) RETTYP _##func(src in, dest* out) { \ |
| if (in < (src)0) return DISP_E_OVERFLOW; *out = in; return S_OK; } |
| |
| /* Compiler cast where input cannot be > some number */ |
| #define POSTST(dest, src, func, tst) RETTYP _##func(src in, dest* out) { \ |
| if (in > (dest)tst) return DISP_E_OVERFLOW; *out = in; return S_OK; } |
| |
| /* Compiler cast where input cannot be < some number or >= some other number */ |
| #define BOTHTST(dest, src, func, lo, hi) RETTYP _##func(src in, dest* out) { \ |
| if (in < (dest)lo || in > hi) return DISP_E_OVERFLOW; *out = in; return S_OK; } |
| |
| /* Conversions from IDispatch use the same code */ |
| HRESULT VARIANT_FromDisp(IDispatch*,LCID,void*,VARTYPE); |
| /* As do conversions from BSTR to numeric types */ |
| HRESULT VARIANT_NumberFromBstr(OLECHAR*,LCID,ULONG,void*,VARTYPE); |
| |
| #define CY_MULTIPLIER 10000 /* 4 dp of precision */ |
| #define CY_MULTIPLIER_F 10000.0 |
| #define CY_HALF (CY_MULTIPLIER/2) /* 0.5 */ |
| #define CY_HALF_F (CY_MULTIPLIER_F/2.0) |
| |
| /* I1 */ |
| POSTST(signed char, BYTE, VarI1FromUI1, I1_MAX); |
| BOTHTST(signed char, SHORT, VarI1FromI2, I1_MIN, I1_MAX); |
| BOTHTST(signed char, LONG, VarI1FromI4, I1_MIN, I1_MAX); |
| #define _VarI1FromR4(flt,out) VarI1FromR8((double)flt,out) |
| #define _VarI1FromR8 VarI1FromR8 |
| #define _VarI1FromCy VarI1FromCy |
| #define _VarI1FromDate(dt,out) VarI1FromR8((double)dt,out) |
| #define _VarI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I1) |
| #define _VarI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I1) |
| SIMPLE(signed char, VARIANT_BOOL, VarI1FromBool); |
| POSTST(signed char, USHORT, VarI1FromUI2, I1_MAX); |
| POSTST(signed char, ULONG, VarI1FromUI4, I1_MAX); |
| #define _VarI1FromDec VarI1FromDec |
| BOTHTST(signed char, LONG64, VarI1FromI8, I1_MIN, I1_MAX); |
| POSTST(signed char, ULONG64, VarI1FromUI8, I1_MAX); |
| |
| /* UI1 */ |
| BOTHTST(BYTE, SHORT, VarUI1FromI2, UI1_MIN, UI1_MAX); |
| #define _VarUI1FromR4(flt,out) VarUI1FromR8((double)flt,out) |
| #define _VarUI1FromR8 VarUI1FromR8 |
| #define _VarUI1FromCy VarUI1FromCy |
| #define _VarUI1FromDate(dt,out) VarUI1FromR8((double)dt,out) |
| #define _VarUI1FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI1) |
| #define _VarUI1FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI1) |
| SIMPLE(BYTE, VARIANT_BOOL, VarUI1FromBool); |
| NEGTST(BYTE, signed char, VarUI1FromI1); |
| POSTST(BYTE, USHORT, VarUI1FromUI2, UI1_MAX); |
| BOTHTST(BYTE, LONG, VarUI1FromI4, UI1_MIN, UI1_MAX); |
| POSTST(BYTE, ULONG, VarUI1FromUI4, UI1_MAX); |
| #define _VarUI1FromDec VarUI1FromDec |
| BOTHTST(BYTE, LONG64, VarUI1FromI8, UI1_MIN, UI1_MAX); |
| POSTST(BYTE, ULONG64, VarUI1FromUI8, UI1_MAX); |
| |
| /* I2 */ |
| SIMPLE(SHORT, BYTE, VarI2FromUI1); |
| BOTHTST(SHORT, LONG, VarI2FromI4, I2_MIN, I2_MAX); |
| #define _VarI2FromR4(flt,out) VarI2FromR8((double)flt,out) |
| #define _VarI2FromR8 VarI2FromR8 |
| #define _VarI2FromCy VarI2FromCy |
| #define _VarI2FromDate(dt,out) VarI2FromR8((double)dt,out) |
| #define _VarI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I2) |
| #define _VarI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I2) |
| SIMPLE(SHORT, VARIANT_BOOL, VarI2FromBool); |
| SIMPLE(SHORT, signed char, VarI2FromI1); |
| POSTST(SHORT, USHORT, VarI2FromUI2, I2_MAX); |
| POSTST(SHORT, ULONG, VarI2FromUI4, I2_MAX); |
| #define _VarI2FromDec VarI2FromDec |
| BOTHTST(SHORT, LONG64, VarI2FromI8, I2_MIN, I2_MAX); |
| POSTST(SHORT, ULONG64, VarI2FromUI8, I2_MAX); |
| |
| /* UI2 */ |
| SIMPLE(USHORT, BYTE, VarUI2FromUI1); |
| NEGTST(USHORT, SHORT, VarUI2FromI2); |
| BOTHTST(USHORT, LONG, VarUI2FromI4, UI2_MIN, UI2_MAX); |
| #define _VarUI2FromR4(flt,out) VarUI2FromR8((double)flt,out) |
| #define _VarUI2FromR8 VarUI2FromR8 |
| #define _VarUI2FromCy VarUI2FromCy |
| #define _VarUI2FromDate(dt,out) VarUI2FromR8((double)dt,out) |
| #define _VarUI2FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI2) |
| #define _VarUI2FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI2) |
| SIMPLE(USHORT, VARIANT_BOOL, VarUI2FromBool); |
| NEGTST(USHORT, signed char, VarUI2FromI1); |
| POSTST(USHORT, ULONG, VarUI2FromUI4, UI2_MAX); |
| #define _VarUI2FromDec VarUI2FromDec |
| BOTHTST(USHORT, LONG64, VarUI2FromI8, UI2_MIN, UI2_MAX); |
| POSTST(USHORT, ULONG64, VarUI2FromUI8, UI2_MAX); |
| |
| /* I4 */ |
| SIMPLE(LONG, BYTE, VarI4FromUI1); |
| SIMPLE(LONG, SHORT, VarI4FromI2); |
| #define _VarI4FromR4(flt,out) VarI4FromR8((double)flt,out) |
| #define _VarI4FromR8 VarI4FromR8 |
| #define _VarI4FromCy VarI4FromCy |
| #define _VarI4FromDate(dt,out) VarI4FromR8((double)dt,out) |
| #define _VarI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I4) |
| #define _VarI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_I4) |
| SIMPLE(LONG, VARIANT_BOOL, VarI4FromBool); |
| SIMPLE(LONG, signed char, VarI4FromI1); |
| SIMPLE(LONG, USHORT, VarI4FromUI2); |
| POSTST(LONG, ULONG, VarI4FromUI4, I4_MAX); |
| #define _VarI4FromDec VarI4FromDec |
| BOTHTST(LONG, LONG64, VarI4FromI8, I4_MIN, I4_MAX); |
| POSTST(LONG, ULONG64, VarI4FromUI8, I4_MAX); |
| |
| /* UI4 */ |
| SIMPLE(ULONG, BYTE, VarUI4FromUI1); |
| NEGTST(ULONG, SHORT, VarUI4FromI2); |
| NEGTST(ULONG, LONG, VarUI4FromI4); |
| #define _VarUI4FromR4(flt,out) VarUI4FromR8((double)flt,out) |
| #define _VarUI4FromR8 VarUI4FromR8 |
| #define _VarUI4FromCy VarUI4FromCy |
| #define _VarUI4FromDate(dt,out) VarUI4FromR8((double)dt,out) |
| #define _VarUI4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI4) |
| #define _VarUI4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI4) |
| SIMPLE(ULONG, VARIANT_BOOL, VarUI4FromBool); |
| NEGTST(ULONG, signed char, VarUI4FromI1); |
| SIMPLE(ULONG, USHORT, VarUI4FromUI2); |
| #define _VarUI4FromDec VarUI4FromDec |
| BOTHTST(ULONG, LONG64, VarUI4FromI8, UI4_MIN, UI4_MAX); |
| POSTST(ULONG, ULONG64, VarUI4FromUI8, UI4_MAX); |
| |
| /* I8 */ |
| SIMPLE(LONG64, BYTE, VarI8FromUI1); |
| SIMPLE(LONG64, SHORT, VarI8FromI2); |
| #define _VarI8FromR4 VarI8FromR8 |
| #define _VarI8FromR8 VarI8FromR8 |
| #define _VarI8FromCy VarI8FromCy |
| #define _VarI8FromDate(dt,out) VarI8FromR8((double)dt,out) |
| #define _VarI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_I8) |
| #define _VarI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_I8) |
| #define _VarI8FromBool _VarI8FromI2 |
| SIMPLE(LONG64, signed char, VarI8FromI1); |
| SIMPLE(LONG64, USHORT, VarI8FromUI2); |
| SIMPLE(LONG64, LONG, VarI8FromI4); |
| SIMPLE(LONG64, ULONG, VarI8FromUI4); |
| #define _VarI8FromDec VarI8FromDec |
| POSTST(LONG64, ULONG64, VarI8FromUI8, I8_MAX); |
| |
| /* UI8 */ |
| SIMPLE(ULONG64, BYTE, VarUI8FromUI1); |
| NEGTST(ULONG64, SHORT, VarUI8FromI2); |
| #define _VarUI8FromR4 VarUI8FromR8 |
| #define _VarUI8FromR8 VarUI8FromR8 |
| #define _VarUI8FromCy VarUI8FromCy |
| #define _VarUI8FromDate(dt,out) VarUI8FromR8((double)dt,out) |
| #define _VarUI8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_UI8) |
| #define _VarUI8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_UI8) |
| #define _VarUI8FromBool _VarI8FromI2 |
| NEGTST(ULONG64, signed char, VarUI8FromI1); |
| SIMPLE(ULONG64, USHORT, VarUI8FromUI2); |
| NEGTST(ULONG64, LONG, VarUI8FromI4); |
| SIMPLE(ULONG64, ULONG, VarUI8FromUI4); |
| #define _VarUI8FromDec VarUI8FromDec |
| NEGTST(ULONG64, LONG64, VarUI8FromI8); |
| |
| /* R4 (float) */ |
| SIMPLE(float, BYTE, VarR4FromUI1); |
| SIMPLE(float, SHORT, VarR4FromI2); |
| RETTYP _VarR4FromR8(double i, float* o) { |
| double d = i < 0.0 ? -i : i; |
| if (d > R4_MAX) return DISP_E_OVERFLOW; |
| *o = i; |
| return S_OK; |
| } |
| RETTYP _VarR4FromCy(CY i, float* o) { *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; } |
| #define _VarR4FromDate(dt,out) _VarR4FromR8((double)dt,out) |
| #define _VarR4FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R4) |
| #define _VarR4FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R4) |
| #define _VarR4FromBool _VarR4FromI2 |
| SIMPLE(float, signed char, VarR4FromI1); |
| SIMPLE(float, USHORT, VarR4FromUI2); |
| SIMPLE(float, LONG, VarR4FromI4); |
| SIMPLE(float, ULONG, VarR4FromUI4); |
| #define _VarR4FromDec VarR4FromDec |
| SIMPLE(float, LONG64, VarR4FromI8); |
| SIMPLE(float, ULONG64, VarR4FromUI8); |
| |
| /* R8 (double) */ |
| SIMPLE(double, BYTE, VarR8FromUI1); |
| SIMPLE(double, SHORT, VarR8FromI2); |
| SIMPLE(double, float, VarR8FromR4); |
| RETTYP _VarR8FromCy(CY i, double* o) { *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; } |
| SIMPLE(double, DATE, VarR8FromDate); |
| #define _VarR8FromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_R8) |
| #define _VarR8FromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_R8) |
| #define _VarR8FromBool _VarR8FromI2 |
| SIMPLE(double, signed char, VarR8FromI1); |
| SIMPLE(double, USHORT, VarR8FromUI2); |
| SIMPLE(double, LONG, VarR8FromI4); |
| SIMPLE(double, ULONG, VarR8FromUI4); |
| #define _VarR8FromDec VarR8FromDec |
| SIMPLE(double, LONG64, VarR8FromI8); |
| SIMPLE(double, ULONG64, VarR8FromUI8); |
| |
| /* BOOL */ |
| #define BOOLFUNC(src, func) RETTYP _##func(src in, VARIANT_BOOL* out) { \ |
| *out = in ? VARIANT_TRUE : VARIANT_FALSE; return S_OK; } |
| |
| BOOLFUNC(signed char,VarBoolFromI1); |
| BOOLFUNC(BYTE,VarBoolFromUI1); |
| BOOLFUNC(SHORT,VarBoolFromI2); |
| BOOLFUNC(USHORT,VarBoolFromUI2); |
| BOOLFUNC(LONG,VarBoolFromI4); |
| BOOLFUNC(ULONG,VarBoolFromUI4); |
| BOOLFUNC(LONG64,VarBoolFromI8); |
| BOOLFUNC(ULONG64,VarBoolFromUI8); |
| #define _VarBoolFromR4(flt,out) _VarBoolFromR8((double)flt,out) |
| BOOLFUNC(double,VarBoolFromR8); |
| #define _VarBoolFromCy(i,o) _VarBoolFromI8(i.int64,o) |
| #define _VarBoolFromDate(dt,out) _VarBoolFromR8((double)dt,out) |
| #define _VarBoolFromStr VarBoolFromStr |
| #define _VarBoolFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, (BYTE*)out, VT_BOOL) |
| #define _VarBoolFromDec VarBoolFromDec |
| |
| /* Internal flags for low level conversion functions */ |
| #define VAR_BOOLONOFF 0x0400 /* Convert bool to "On"/"Off" */ |
| #define VAR_BOOLYESNO 0x0800 /* Convert bool to "Yes"/"No" */ |
| #define VAR_NEGATIVE 0x1000 /* Number is negative */ |
| |
| /* DECIMAL */ |
| #define _VarDecFromUI1 VarDecFromUI4 |
| #define _VarDecFromI2 VarDecFromI4 |
| #define _VarDecFromR4 VarDecFromR4 |
| #define _VarDecFromR8 VarDecFromR8 |
| #define _VarDecFromCy VarDecFromCy |
| #define _VarDecFromDate(dt,out) VarDecFromR8((double)dt,out) |
| #define _VarDecFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_DECIMAL) |
| #define _VarDecFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DECIMAL) |
| #define _VarDecFromBool VarDecFromBool |
| #define _VarDecFromI1 VarDecFromI4 |
| #define _VarDecFromUI2 VarDecFromUI4 |
| #define _VarDecFromI4 VarDecFromI4 |
| #define _VarDecFromUI4 VarDecFromUI4 |
| #define _VarDecFromI8 VarDecFromI8 |
| #define _VarDecFromUI8 VarDecFromUI8 |
| |
| /* CY (Currency) */ |
| #define _VarCyFromUI1 VarCyFromR8 |
| #define _VarCyFromI2 VarCyFromR8 |
| #define _VarCyFromR4 VarCyFromR8 |
| #define _VarCyFromR8 VarCyFromR8 |
| #define _VarCyFromDate VarCyFromR8 |
| #define _VarCyFromStr(str,lcid,flags,out) VARIANT_NumberFromBstr(str,lcid,flags,(BYTE*)out,VT_CY) |
| #define _VarCyFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_CY) |
| #define _VarCyFromBool VarCyFromR8 |
| #define _VarCyFromI1 VarCyFromR8 |
| #define _VarCyFromUI2 VarCyFromR8 |
| #define _VarCyFromI4 VarCyFromR8 |
| #define _VarCyFromUI4 VarCyFromR8 |
| #define _VarCyFromDec VarCyFromDec |
| RETTYP _VarCyFromI8(LONG64 i, CY* o) { |
| if (i <= (I8_MIN/CY_MULTIPLIER) || i >= (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW; |
| o->int64 = i * CY_MULTIPLIER; |
| return S_OK; |
| } |
| #define _VarCyFromUI8 VarCyFromR8 |
| |
| /* DATE */ |
| #define _VarDateFromUI1 _VarR8FromUI1 |
| #define _VarDateFromI2 _VarR8FromI2 |
| #define _VarDateFromR4 _VarDateFromR8 |
| RETTYP _VarDateFromR8(double i, DATE* o) { |
| if (i <= (DATE_MIN - 1.0) || i >= (DATE_MAX + 1.0)) return DISP_E_OVERFLOW; |
| *o = (DATE)i; |
| return S_OK; |
| } |
| #define _VarDateFromCy _VarR8FromCy |
| #define _VarDateFromStr VarDateFromStr |
| #define _VarDateFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_DATE) |
| #define _VarDateFromBool _VarR8FromBool |
| #define _VarDateFromI1 _VarR8FromI1 |
| #define _VarDateFromUI2 _VarR8FromUI2 |
| #define _VarDateFromI4 _VarDateFromR8 |
| #define _VarDateFromUI4 _VarDateFromR8 |
| #define _VarDateFromDec _VarR8FromDec |
| RETTYP _VarDateFromI8(LONG64 i, DATE* o) { |
| if (i < DATE_MIN || i > DATE_MAX) return DISP_E_OVERFLOW; |
| *o = (DATE)i; |
| return S_OK; |
| } |
| RETTYP _VarDateFromUI8(ULONG64 i, DATE* o) { |
| if (i > DATE_MAX) return DISP_E_OVERFLOW; |
| *o = (DATE)i; |
| return S_OK; |
| } |
| |
| /* BSTR */ |
| #define _VarBstrFromUI1 VarBstrFromUI4 |
| #define _VarBstrFromI2 VarBstrFromI4 |
| #define _VarBstrFromR4 VarBstrFromR8 |
| #define _VarBstrFromR8 VarBstrFromR8 |
| #define _VarBstrFromCy VarBstrFromCy |
| #define _VarBstrFromDate VarBstrFromDate |
| #define _VarBstrFromDisp(disp,lcid,out) VARIANT_FromDisp(disp, lcid, out, VT_BSTR) |
| #define _VarBstrFromBool VarBstrFromBool |
| #define _VarBstrFromI1 VarBstrFromI4 |
| #define _VarBstrFromUI2 VarBstrFromUI4 |
| #define _VarBstrFromI4 VarBstrFromI4 |
| #define _VarBstrFromUI4 VarBstrFromUI4 |
| #define _VarBstrFromDec VarBstrFromDec |
| #define _VarBstrFromI8 VarBstrFromI8 |
| #define _VarBstrFromUI8 VarBstrFromUI8 |
| |
| /* Macro to inline conversion from a float or double to any integer type, |
| * rounding according to the 'dutch' convention. |
| */ |
| #define OLEAUT32_DutchRound(typ, value, res) do { \ |
| double whole = (double)value < 0 ? ceil((double)value) : floor((double)value); \ |
| double fract = (double)value - whole; \ |
| if (fract > 0.5) res = (typ)whole + (typ)1; \ |
| else if (fract == 0.5) { typ is_odd = (typ)whole & 1; res = whole + is_odd; } \ |
| else if (fract >= 0.0) res = (typ)whole; \ |
| else if (fract == -0.5) { typ is_odd = (typ)whole & 1; res = whole - is_odd; } \ |
| else if (fract > -0.5) res = (typ)whole; \ |
| else res = (typ)whole - (typ)1; \ |
| } while(0); |
| |
| /* The localised characters that make up a valid number */ |
| typedef struct tagVARIANT_NUMBER_CHARS |
| { |
| WCHAR cNegativeSymbol; |
| WCHAR cPositiveSymbol; |
| WCHAR cDecimalPoint; |
| WCHAR cDigitSeperator; |
| WCHAR cCurrencyLocal; |
| WCHAR cCurrencyLocal2; |
| WCHAR cCurrencyDecimalPoint; |
| WCHAR cCurrencyDigitSeperator; |
| } VARIANT_NUMBER_CHARS; |
| |
| void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS*,LCID,DWORD); |