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