Wine Cross Reference
wine/dlls/oleaut32/vartype.c

   /*
    * Low level variant functions
    *
    * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #define COBJMACROS
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
  
  #include "wine/debug.h"
  #include "wine/unicode.h"
  #include "winbase.h"
  #include "winuser.h"
  #include "winnt.h"
  #include "variant.h"
  #include "resource.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(variant);
  
  extern HMODULE hProxyDll DECLSPEC_HIDDEN;
  
  #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)
  
  static const WCHAR szFloatFormatW[] = { '%','.','7','G','\0' };
  static const WCHAR szDoubleFormatW[] = { '%','.','1','5','G','\0' };
  
  /* Copy data from one variant to another. */
  static inline void VARIANT_CopyData(const VARIANT *srcVar, VARTYPE vt, void *pOut)
  {
    switch (vt)
    {
    case VT_I1:
    case VT_UI1: memcpy(pOut, &V_UI1(srcVar), sizeof(BYTE)); break;
    case VT_BOOL:
    case VT_I2:
    case VT_UI2: memcpy(pOut, &V_UI2(srcVar), sizeof(SHORT)); break;
    case VT_R4:
    case VT_INT:
    case VT_I4:
    case VT_UINT:
    case VT_UI4: memcpy(pOut, &V_UI4(srcVar), sizeof (LONG)); break;
    case VT_R8:
    case VT_DATE:
    case VT_CY:
    case VT_I8:
    case VT_UI8: memcpy(pOut, &V_UI8(srcVar), sizeof (LONG64)); break;
    case VT_INT_PTR: memcpy(pOut, &V_INT_PTR(srcVar), sizeof (INT_PTR)); break;
    case VT_DECIMAL: memcpy(pOut, &V_DECIMAL(srcVar), sizeof (DECIMAL)); break;
    case VT_BSTR: memcpy(pOut, &V_BSTR(srcVar), sizeof(BSTR)); break;
    default:
      FIXME("VT_ type %d unhandled, please report!\n", vt);
    }
  }
  
  /* Macro to inline conversion from a float or double to any integer type,
   * rounding according to the 'dutch' convention.
   */
  #define VARIANT_DutchRound(typ, value, res) do { \
    double whole = value < 0 ? ceil(value) : floor(value); \
    double fract = 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)
  
  
  /* Coerce VT_BSTR to a numeric type */
  static HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
                                        void* pOut, VARTYPE vt)
  {
    VARIANTARG dstVar;
    HRESULT hRet;
    NUMPARSE np;
    BYTE rgb[1024];
  
    /* Use VarParseNumFromStr/VarNumFromParseNum as MSDN indicates */
    np.cDig = sizeof(rgb) / sizeof(BYTE);
    np.dwInFlags = NUMPRS_STD;
 
   hRet = VarParseNumFromStr(pStrIn, lcid, ulFlags, &np, rgb);
 
   if (SUCCEEDED(hRet))
   {
     /* 1 << vt gives us the VTBIT constant for the destination number type */
     hRet = VarNumFromParseNum(&np, rgb, 1 << vt, &dstVar);
     if (SUCCEEDED(hRet))
       VARIANT_CopyData(&dstVar, vt, pOut);
   }
   return hRet;
 }
 
 /* Coerce VT_DISPATCH to another type */
 static HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut,
                                 VARTYPE vt, DWORD dwFlags)
 {
   static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
   VARIANTARG srcVar, dstVar;
   HRESULT hRet;
 
   if (!pdispIn)
     return DISP_E_BADVARTYPE;
 
   /* Get the default 'value' property from the IDispatch */
   hRet = IDispatch_Invoke(pdispIn, DISPID_VALUE, &IID_NULL, lcid, DISPATCH_PROPERTYGET,
                           &emptyParams, &srcVar, NULL, NULL);
 
   if (SUCCEEDED(hRet))
   {
     /* Convert the property to the requested type */
     V_VT(&dstVar) = VT_EMPTY;
     hRet = VariantChangeTypeEx(&dstVar, &srcVar, lcid, dwFlags, vt);
     VariantClear(&srcVar);
 
     if (SUCCEEDED(hRet))
     {
       VARIANT_CopyData(&dstVar, vt, pOut);
       VariantClear(&srcVar);
     }
   }
   else
     hRet = DISP_E_TYPEMISMATCH;
   return hRet;
 }
 
 /* Inline return type */
 #define RETTYP static inline 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 < 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; }
 
 /* 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)
 SIMPLE(signed char, VARIANT_BOOL, VarI1FromBool)
 POSTST(signed char, USHORT, VarI1FromUI2, I1_MAX)
 POSTST(signed char, ULONG, VarI1FromUI4, I1_MAX)
 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)
 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)
 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)
 SIMPLE(SHORT, VARIANT_BOOL, VarI2FromBool)
 SIMPLE(SHORT, signed char, VarI2FromI1)
 POSTST(SHORT, USHORT, VarI2FromUI2, I2_MAX)
 POSTST(SHORT, ULONG, VarI2FromUI4, I2_MAX)
 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)
 SIMPLE(USHORT, VARIANT_BOOL, VarUI2FromBool)
 NEGTST(USHORT, signed char, VarUI2FromI1)
 POSTST(USHORT, ULONG, VarUI2FromUI4, UI2_MAX)
 BOTHTST(USHORT, LONG64, VarUI2FromI8, UI2_MIN, UI2_MAX)
 POSTST(USHORT, ULONG64, VarUI2FromUI8, UI2_MAX)
 
 /* I4 */
 SIMPLE(LONG, BYTE, VarI4FromUI1)
 SIMPLE(LONG, SHORT, VarI4FromI2)
 SIMPLE(LONG, VARIANT_BOOL, VarI4FromBool)
 SIMPLE(LONG, signed char, VarI4FromI1)
 SIMPLE(LONG, USHORT, VarI4FromUI2)
 POSTST(LONG, ULONG, VarI4FromUI4, I4_MAX)
 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)
 SIMPLE(ULONG, VARIANT_BOOL, VarUI4FromBool)
 NEGTST(ULONG, signed char, VarUI4FromI1)
 SIMPLE(ULONG, USHORT, VarUI4FromUI2)
 BOTHTST(ULONG, LONG64, VarUI4FromI8, UI4_MIN, UI4_MAX)
 POSTST(ULONG, ULONG64, VarUI4FromUI8, UI4_MAX)
 
 /* I8 */
 SIMPLE(LONG64, BYTE, VarI8FromUI1)
 SIMPLE(LONG64, SHORT, VarI8FromI2)
 SIMPLE(LONG64, signed char, VarI8FromI1)
 SIMPLE(LONG64, USHORT, VarI8FromUI2)
 SIMPLE(LONG64, ULONG, VarI8FromUI4)
 POSTST(LONG64, ULONG64, VarI8FromUI8, I8_MAX)
 
 /* UI8 */
 SIMPLE(ULONG64, BYTE, VarUI8FromUI1)
 NEGTST(ULONG64, SHORT, VarUI8FromI2)
 NEGTST(ULONG64, signed char, VarUI8FromI1)
 SIMPLE(ULONG64, USHORT, VarUI8FromUI2)
 SIMPLE(ULONG64, ULONG, VarUI8FromUI4)
 NEGTST(ULONG64, LONG64, VarUI8FromI8)
 
 /* R4 (float) */
 SIMPLE(float, BYTE, VarR4FromUI1)
 SIMPLE(float, SHORT, VarR4FromI2)
 SIMPLE(float, signed char, VarR4FromI1)
 SIMPLE(float, USHORT, VarR4FromUI2)
 SIMPLE(float, LONG, VarR4FromI4)
 SIMPLE(float, ULONG, VarR4FromUI4)
 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)
 SIMPLE(double, signed char, VarR8FromI1)
 SIMPLE(double, USHORT, VarR8FromUI2)
 SIMPLE(double, LONG, VarR8FromI4)
 SIMPLE(double, ULONG, VarR8FromUI4)
 SIMPLE(double, LONG64, VarR8FromI8)
 SIMPLE(double, ULONG64, VarR8FromUI8)
 
 
 /* I1
  */
 
 /************************************************************************
  * VarI1FromUI1 (OLEAUT32.244)
  *
  * Convert a VT_UI1 to a VT_I1.
  *
  * PARAMS
  *  bIn     [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromUI1(BYTE bIn, signed char* pcOut)
 {
   return _VarI1FromUI1(bIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromI2 (OLEAUT32.245)
  *
  * Convert a VT_I2 to a VT_I1.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromI2(SHORT sIn, signed char* pcOut)
 {
   return _VarI1FromI2(sIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromI4 (OLEAUT32.246)
  *
  * Convert a VT_I4 to a VT_I1.
  *
  * PARAMS
  *  iIn     [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromI4(LONG iIn, signed char* pcOut)
 {
   return _VarI1FromI4(iIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromR4 (OLEAUT32.247)
  *
  * Convert a VT_R4 to a VT_I1.
  *
  * PARAMS
  *  fltIn   [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char* pcOut)
 {
   return VarI1FromR8(fltIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromR8 (OLEAUT32.248)
  *
  * Convert a VT_R8 to a VT_I1.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarI1FromR8(double dblIn, signed char* pcOut)
 {
   if (dblIn < (double)I1_MIN || dblIn > (double)I1_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(CHAR, dblIn, *pcOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarI1FromDate (OLEAUT32.249)
  *
  * Convert a VT_DATE to a VT_I1.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char* pcOut)
 {
   return VarI1FromR8(dateIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromCy (OLEAUT32.250)
  *
  * Convert a VT_CY to a VT_I1.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromCy(CY cyIn, signed char* pcOut)
 {
   LONG i = I1_MAX + 1;
 
   VarI4FromCy(cyIn, &i);
   return _VarI1FromI4(i, pcOut);
 }
 
 /************************************************************************
  * VarI1FromStr (OLEAUT32.251)
  *
  * Convert a VT_BSTR to a VT_I1.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char* pcOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pcOut, VT_I1);
 }
 
 /************************************************************************
  * VarI1FromDisp (OLEAUT32.252)
  *
  * Convert a VT_DISPATCH to a VT_I1.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pcOut    [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI1FromDisp(IDispatch* pdispIn, LCID lcid, signed char* pcOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pcOut, VT_I1, 0);
 }
 
 /************************************************************************
  * VarI1FromBool (OLEAUT32.253)
  *
  * Convert a VT_BOOL to a VT_I1.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, signed char* pcOut)
 {
   return _VarI1FromBool(boolIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromUI2 (OLEAUT32.254)
  *
  * Convert a VT_UI2 to a VT_I1.
  *
  * PARAMS
  *  usIn    [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromUI2(USHORT usIn, signed char* pcOut)
 {
   return _VarI1FromUI2(usIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromUI4 (OLEAUT32.255)
  *
  * Convert a VT_UI4 to a VT_I1.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, signed char* pcOut)
 {
   return _VarI1FromUI4(ulIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromDec (OLEAUT32.256)
  *
  * Convert a VT_DECIMAL to a VT_I1.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromDec(DECIMAL *pdecIn, signed char* pcOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI1FromI8(i64, pcOut);
   return hRet;
 }
 
 /************************************************************************
  * VarI1FromI8 (OLEAUT32.376)
  *
  * Convert a VT_I8 to a VT_I1.
  *
  * PARAMS
  *  llIn  [I] Source
  *  pcOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromI8(LONG64 llIn, signed char* pcOut)
 {
   return _VarI1FromI8(llIn, pcOut);
 }
 
 /************************************************************************
  * VarI1FromUI8 (OLEAUT32.377)
  *
  * Convert a VT_UI8 to a VT_I1.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pcOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI1FromUI8(ULONG64 ullIn, signed char* pcOut)
 {
   return _VarI1FromUI8(ullIn, pcOut);
 }
 
 /* UI1
  */
 
 /************************************************************************
  * VarUI1FromI2 (OLEAUT32.130)
  *
  * Convert a VT_I2 to a VT_UI1.
  *
  * PARAMS
  *  sIn   [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromI2(SHORT sIn, BYTE* pbOut)
 {
   return _VarUI1FromI2(sIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromI4 (OLEAUT32.131)
  *
  * Convert a VT_I4 to a VT_UI1.
  *
  * PARAMS
  *  iIn   [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromI4(LONG iIn, BYTE* pbOut)
 {
   return _VarUI1FromI4(iIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromR4 (OLEAUT32.132)
  *
  * Convert a VT_R4 to a VT_UI1.
  *
  * PARAMS
  *  fltIn [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
 {
   return VarUI1FromR8(fltIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromR8 (OLEAUT32.133)
  *
  * Convert a VT_R8 to a VT_UI1.
  *
  * PARAMS
  *  dblIn [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI1_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(BYTE, dblIn, *pbOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarUI1FromCy (OLEAUT32.134)
  *
  * Convert a VT_CY to a VT_UI1.
  *
  * PARAMS
  *  cyIn     [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  Negative values >= -5000 will be converted to 0.
  */
 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut)
 {
   ULONG i = UI1_MAX + 1;
 
   VarUI4FromCy(cyIn, &i);
   return _VarUI1FromUI4(i, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromDate (OLEAUT32.135)
  *
  * Convert a VT_DATE to a VT_UI1.
  *
  * PARAMS
  *  dateIn [I] Source
  *  pbOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
 {
   return VarUI1FromR8(dateIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromStr (OLEAUT32.136)
  *
  * Convert a VT_BSTR to a VT_UI1.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pbOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pbOut, VT_UI1);
 }
 
 /************************************************************************
  * VarUI1FromDisp (OLEAUT32.137)
  *
  * Convert a VT_DISPATCH to a VT_UI1.
  *
  * PARAMS
  *  pdispIn [I] Source
  *  lcid    [I] LCID for conversion
  *  pbOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI1FromDisp(IDispatch* pdispIn, LCID lcid, BYTE* pbOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pbOut, VT_UI1, 0);
 }
 
 /************************************************************************
  * VarUI1FromBool (OLEAUT32.138)
  *
  * Convert a VT_BOOL to a VT_UI1.
  *
  * PARAMS
  *  boolIn [I] Source
  *  pbOut  [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
 {
   return _VarUI1FromBool(boolIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromI1 (OLEAUT32.237)
  *
  * Convert a VT_I1 to a VT_UI1.
  *
  * PARAMS
  *  cIn   [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromI1(signed char cIn, BYTE* pbOut)
 {
   return _VarUI1FromI1(cIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromUI2 (OLEAUT32.238)
  *
  * Convert a VT_UI2 to a VT_UI1.
  *
  * PARAMS
  *  usIn  [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromUI2(USHORT usIn, BYTE* pbOut)
 {
   return _VarUI1FromUI2(usIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromUI4 (OLEAUT32.239)
  *
  * Convert a VT_UI4 to a VT_UI1.
  *
  * PARAMS
  *  ulIn  [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
 {
   return _VarUI1FromUI4(ulIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromDec (OLEAUT32.240)
  *
  * Convert a VT_DECIMAL to a VT_UI1.
  *
  * PARAMS
  *  pDecIn [I] Source
  *  pbOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE* pbOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI1FromI8(i64, pbOut);
   return hRet;
 }
 
 /************************************************************************
  * VarUI1FromI8 (OLEAUT32.372)
  *
  * Convert a VT_I8 to a VT_UI1.
  *
  * PARAMS
  *  llIn  [I] Source
  *  pbOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromI8(LONG64 llIn, BYTE* pbOut)
 {
   return _VarUI1FromI8(llIn, pbOut);
 }
 
 /************************************************************************
  * VarUI1FromUI8 (OLEAUT32.373)
  *
  * Convert a VT_UI8 to a VT_UI1.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pbOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI1FromUI8(ULONG64 ullIn, BYTE* pbOut)
 {
   return _VarUI1FromUI8(ullIn, pbOut);
 }
 
 
 /* I2
  */
 
 /************************************************************************
  * VarI2FromUI1 (OLEAUT32.48)
  *
  * Convert a VT_UI2 to a VT_I2.
  *
  * PARAMS
  *  bIn     [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI2FromUI1(BYTE bIn, SHORT* psOut)
 {
   return _VarI2FromUI1(bIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromI4 (OLEAUT32.49)
  *
  * Convert a VT_I4 to a VT_I2.
  *
  * PARAMS
  *  iIn     [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromI4(LONG iIn, SHORT* psOut)
 {
   return _VarI2FromI4(iIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromR4 (OLEAUT32.50)
  *
  * Convert a VT_R4 to a VT_I2.
  *
  * PARAMS
  *  fltIn   [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, SHORT* psOut)
 {
   return VarI2FromR8(fltIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromR8 (OLEAUT32.51)
  *
  * Convert a VT_R8 to a VT_I2.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarI2FromR8(double dblIn, SHORT* psOut)
 {
   if (dblIn < (double)I2_MIN || dblIn > (double)I2_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(SHORT, dblIn, *psOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarI2FromCy (OLEAUT32.52)
  *
  * Convert a VT_CY to a VT_I2.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromCy(CY cyIn, SHORT* psOut)
 {
   LONG i = I2_MAX + 1;
 
   VarI4FromCy(cyIn, &i);
   return _VarI2FromI4(i, psOut);
 }
 
 /************************************************************************
  * VarI2FromDate (OLEAUT32.53)
  *
  * Convert a VT_DATE to a VT_I2.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
 {
   return VarI2FromR8(dateIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromStr (OLEAUT32.54)
  *
  * Convert a VT_BSTR to a VT_I2.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if any parameter is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, psOut, VT_I2);
 }
 
 /************************************************************************
  * VarI2FromDisp (OLEAUT32.55)
  *
  * Convert a VT_DISPATCH to a VT_I2.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  psOut    [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if pdispIn is invalid,
  *           DISP_E_OVERFLOW, if the value will not fit in the destination,
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI2FromDisp(IDispatch* pdispIn, LCID lcid, SHORT* psOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, psOut, VT_I2, 0);
 }
 
 /************************************************************************
  * VarI2FromBool (OLEAUT32.56)
  *
  * Convert a VT_BOOL to a VT_I2.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, SHORT* psOut)
 {
   return _VarI2FromBool(boolIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromI1 (OLEAUT32.205)
  *
  * Convert a VT_I1 to a VT_I2.
  *
  * PARAMS
  *  cIn     [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI2FromI1(signed char cIn, SHORT* psOut)
 {
   return _VarI2FromI1(cIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromUI2 (OLEAUT32.206)
  *
  * Convert a VT_UI2 to a VT_I2.
  *
  * PARAMS
  *  usIn    [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromUI2(USHORT usIn, SHORT* psOut)
 {
   return _VarI2FromUI2(usIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromUI4 (OLEAUT32.207)
  *
  * Convert a VT_UI4 to a VT_I2.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, SHORT* psOut)
 {
   return _VarI2FromUI4(ulIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromDec (OLEAUT32.208)
  *
  * Convert a VT_DECIMAL to a VT_I2.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  psOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromDec(DECIMAL *pdecIn, SHORT* psOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI2FromI8(i64, psOut);
   return hRet;
 }
 
 /************************************************************************
  * VarI2FromI8 (OLEAUT32.346)
  *
  * Convert a VT_I8 to a VT_I2.
  *
  * PARAMS
  *  llIn  [I] Source
  *  psOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromI8(LONG64 llIn, SHORT* psOut)
 {
   return _VarI2FromI8(llIn, psOut);
 }
 
 /************************************************************************
  * VarI2FromUI8 (OLEAUT32.347)
  *
  * Convert a VT_UI8 to a VT_I2.
  *
  * PARAMS
  *  ullIn [I] Source
  *  psOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI2FromUI8(ULONG64 ullIn, SHORT* psOut)
 {
   return _VarI2FromUI8(ullIn, psOut);
 }
 
 /* UI2
  */
 
 /************************************************************************
  * VarUI2FromUI1 (OLEAUT32.257)
  *
  * Convert a VT_UI1 to a VT_UI2.
  *
  * PARAMS
  *  bIn    [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* pusOut)
 {
   return _VarUI2FromUI1(bIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromI2 (OLEAUT32.258)
  *
  * Convert a VT_I2 to a VT_UI2.
  *
  * PARAMS
  *  sIn    [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromI2(SHORT sIn, USHORT* pusOut)
 {
   return _VarUI2FromI2(sIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromI4 (OLEAUT32.259)
  *
  * Convert a VT_I4 to a VT_UI2.
  *
  * PARAMS
  *  iIn    [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromI4(LONG iIn, USHORT* pusOut)
 {
   return _VarUI2FromI4(iIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromR4 (OLEAUT32.260)
  *
  * Convert a VT_R4 to a VT_UI2.
  *
  * PARAMS
  *  fltIn  [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* pusOut)
 {
   return VarUI2FromR8(fltIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromR8 (OLEAUT32.261)
  *
  * Convert a VT_R8 to a VT_UI2.
  *
  * PARAMS
  *  dblIn  [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* pusOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI2_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(USHORT, dblIn, *pusOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarUI2FromDate (OLEAUT32.262)
  *
  * Convert a VT_DATE to a VT_UI2.
  *
  * PARAMS
  *  dateIn [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* pusOut)
 {
   return VarUI2FromR8(dateIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromCy (OLEAUT32.263)
  *
  * Convert a VT_CY to a VT_UI2.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  Negative values >= -5000 will be converted to 0.
  */
 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut)
 {
   ULONG i = UI2_MAX + 1;
 
   VarUI4FromCy(cyIn, &i);
   return _VarUI2FromUI4(i, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromStr (OLEAUT32.264)
  *
  * Convert a VT_BSTR to a VT_UI2.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pusOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* pusOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pusOut, VT_UI2);
 }
 
 /************************************************************************
  * VarUI2FromDisp (OLEAUT32.265)
  *
  * Convert a VT_DISPATCH to a VT_UI2.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pusOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI2FromDisp(IDispatch* pdispIn, LCID lcid, USHORT* pusOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pusOut, VT_UI2, 0);
 }
 
 /************************************************************************
  * VarUI2FromBool (OLEAUT32.266)
  *
  * Convert a VT_BOOL to a VT_UI2.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pusOut  [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* pusOut)
 {
   return _VarUI2FromBool(boolIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromI1 (OLEAUT32.267)
  *
  * Convert a VT_I1 to a VT_UI2.
  *
  * PARAMS
  *  cIn    [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromI1(signed char cIn, USHORT* pusOut)
 {
   return _VarUI2FromI1(cIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromUI4 (OLEAUT32.268)
  *
  * Convert a VT_UI4 to a VT_UI2.
  *
  * PARAMS
  *  ulIn   [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* pusOut)
 {
   return _VarUI2FromUI4(ulIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromDec (OLEAUT32.269)
  *
  * Convert a VT_DECIMAL to a VT_UI2.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pusOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT* pusOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI2FromI8(i64, pusOut);
   return hRet;
 }
 
 /************************************************************************
  * VarUI2FromI8 (OLEAUT32.378)
  *
  * Convert a VT_I8 to a VT_UI2.
  *
  * PARAMS
  *  llIn   [I] Source
  *  pusOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromI8(LONG64 llIn, USHORT* pusOut)
 {
   return _VarUI2FromI8(llIn, pusOut);
 }
 
 /************************************************************************
  * VarUI2FromUI8 (OLEAUT32.379)
  *
  * Convert a VT_UI8 to a VT_UI2.
  *
  * PARAMS
  *  ullIn    [I] Source
  *  pusOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI2FromUI8(ULONG64 ullIn, USHORT* pusOut)
 {
   return _VarUI2FromUI8(ullIn, pusOut);
 }
 
 /* I4
  */
 
 /************************************************************************
  * VarI4FromUI1 (OLEAUT32.58)
  *
  * Convert a VT_UI1 to a VT_I4.
  *
  * PARAMS
  *  bIn     [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG *piOut)
 {
   return _VarI4FromUI1(bIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromI2 (OLEAUT32.59)
  *
  * Convert a VT_I2 to a VT_I4.
  *
  * PARAMS
  *  sIn     [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromI2(SHORT sIn, LONG *piOut)
 {
   return _VarI4FromI2(sIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromR4 (OLEAUT32.60)
  *
  * Convert a VT_R4 to a VT_I4.
  *
  * PARAMS
  *  fltIn   [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG *piOut)
 {
   return VarI4FromR8(fltIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromR8 (OLEAUT32.61)
  *
  * Convert a VT_R8 to a VT_I4.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarI4FromR8(double dblIn, LONG *piOut)
 {
   if (dblIn < (double)I4_MIN || dblIn > (double)I4_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(LONG, dblIn, *piOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarI4FromCy (OLEAUT32.62)
  *
  * Convert a VT_CY to a VT_I4.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG *piOut)
 {
   double d = cyIn.int64 / CY_MULTIPLIER_F;
   return VarI4FromR8(d, piOut);
 }
 
 /************************************************************************
  * VarI4FromDate (OLEAUT32.63)
  *
  * Convert a VT_DATE to a VT_I4.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
 {
   return VarI4FromR8(dateIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromStr (OLEAUT32.64)
  *
  * Convert a VT_BSTR to a VT_I4.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if any parameter is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
  */
 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, piOut, VT_I4);
 }
 
 /************************************************************************
  * VarI4FromDisp (OLEAUT32.65)
  *
  * Convert a VT_DISPATCH to a VT_I4.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  piOut    [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI4FromDisp(IDispatch* pdispIn, LCID lcid, LONG *piOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, piOut, VT_I4, 0);
 }
 
 /************************************************************************
  * VarI4FromBool (OLEAUT32.66)
  *
  * Convert a VT_BOOL to a VT_I4.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG *piOut)
 {
   return _VarI4FromBool(boolIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromI1 (OLEAUT32.209)
  *
  * Convert a VT_I4 to a VT_I4.
  *
  * PARAMS
  *  cIn     [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI4FromI1(signed char cIn, LONG *piOut)
 {
   return _VarI4FromI1(cIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromUI2 (OLEAUT32.210)
  *
  * Convert a VT_UI2 to a VT_I4.
  *
  * PARAMS
  *  usIn    [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI4FromUI2(USHORT usIn, LONG *piOut)
 {
   return _VarI4FromUI2(usIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromUI4 (OLEAUT32.211)
  *
  * Convert a VT_UI4 to a VT_I4.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG *piOut)
 {
   return _VarI4FromUI4(ulIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromDec (OLEAUT32.212)
  *
  * Convert a VT_DECIMAL to a VT_I4.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  piOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if pdecIn is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromDec(DECIMAL *pdecIn, LONG *piOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarI4FromI8(i64, piOut);
   return hRet;
 }
 
 /************************************************************************
  * VarI4FromI8 (OLEAUT32.348)
  *
  * Convert a VT_I8 to a VT_I4.
  *
  * PARAMS
  *  llIn  [I] Source
  *  piOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromI8(LONG64 llIn, LONG *piOut)
 {
   return _VarI4FromI8(llIn, piOut);
 }
 
 /************************************************************************
  * VarI4FromUI8 (OLEAUT32.349)
  *
  * Convert a VT_UI8 to a VT_I4.
  *
  * PARAMS
  *  ullIn [I] Source
  *  piOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI4FromUI8(ULONG64 ullIn, LONG *piOut)
 {
   return _VarI4FromUI8(ullIn, piOut);
 }
 
 /* UI4
  */
 
 /************************************************************************
  * VarUI4FromUI1 (OLEAUT32.270)
  *
  * Convert a VT_UI1 to a VT_UI4.
  *
  * PARAMS
  *  bIn    [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG *pulOut)
 {
   return _VarUI4FromUI1(bIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromI2 (OLEAUT32.271)
  *
  * Convert a VT_I2 to a VT_UI4.
  *
  * PARAMS
  *  sIn    [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromI2(SHORT sIn, ULONG *pulOut)
 {
   return _VarUI4FromI2(sIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromI4 (OLEAUT32.272)
  *
  * Convert a VT_I4 to a VT_UI4.
  *
  * PARAMS
  *  iIn    [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromI4(LONG iIn, ULONG *pulOut)
 {
   return _VarUI4FromI4(iIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromR4 (OLEAUT32.273)
  *
  * Convert a VT_R4 to a VT_UI4.
  *
  * PARAMS
  *  fltIn  [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut)
 {
   return VarUI4FromR8(fltIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromR8 (OLEAUT32.274)
  *
  * Convert a VT_R8 to a VT_UI4.
  *
  * PARAMS
  *  dblIn  [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG *pulOut)
 {
   if (dblIn < -0.5 || dblIn > (double)UI4_MAX)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(ULONG, dblIn, *pulOut);
   return S_OK;
 }
 
 /************************************************************************
  * VarUI4FromDate (OLEAUT32.275)
  *
  * Convert a VT_DATE to a VT_UI4.
  *
  * PARAMS
  *  dateIn [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut)
 {
   return VarUI4FromR8(dateIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromCy (OLEAUT32.276)
  *
  * Convert a VT_CY to a VT_UI4.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
 {
   double d = cyIn.int64 / CY_MULTIPLIER_F;
   return VarUI4FromR8(d, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromStr (OLEAUT32.277)
  *
  * Convert a VT_BSTR to a VT_UI4.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pulOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if any parameter is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
  */
 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pulOut, VT_UI4);
 }
 
 /************************************************************************
  * VarUI4FromDisp (OLEAUT32.278)
  *
  * Convert a VT_DISPATCH to a VT_UI4.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pulOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI4FromDisp(IDispatch* pdispIn, LCID lcid, ULONG *pulOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pulOut, VT_UI4, 0);
 }
 
 /************************************************************************
  * VarUI4FromBool (OLEAUT32.279)
  *
  * Convert a VT_BOOL to a VT_UI4.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pulOut  [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG *pulOut)
 {
   return _VarUI4FromBool(boolIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromI1 (OLEAUT32.280)
  *
  * Convert a VT_I1 to a VT_UI4.
  *
  * PARAMS
  *  cIn    [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromI1(signed char cIn, ULONG *pulOut)
 {
   return _VarUI4FromI1(cIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromUI2 (OLEAUT32.281)
  *
  * Convert a VT_UI2 to a VT_UI4.
  *
  * PARAMS
  *  usIn   [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI4FromUI2(USHORT usIn, ULONG *pulOut)
 {
   return _VarUI4FromUI2(usIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromDec (OLEAUT32.282)
  *
  * Convert a VT_DECIMAL to a VT_UI4.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pulOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if pdecIn is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut)
 {
   LONG64 i64;
   HRESULT hRet;
 
   hRet = VarI8FromDec(pdecIn, &i64);
 
   if (SUCCEEDED(hRet))
     hRet = _VarUI4FromI8(i64, pulOut);
   return hRet;
 }
 
 /************************************************************************
  * VarUI4FromI8 (OLEAUT32.425)
  *
  * Convert a VT_I8 to a VT_UI4.
  *
  * PARAMS
  *  llIn   [I] Source
  *  pulOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromI8(LONG64 llIn, ULONG *pulOut)
 {
   return _VarUI4FromI8(llIn, pulOut);
 }
 
 /************************************************************************
  * VarUI4FromUI8 (OLEAUT32.426)
  *
  * Convert a VT_UI8 to a VT_UI4.
  *
  * PARAMS
  *  ullIn    [I] Source
  *  pulOut   [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI4FromUI8(ULONG64 ullIn, ULONG *pulOut)
 {
   return _VarUI4FromUI8(ullIn, pulOut);
 }
 
 /* I8
  */
 
 /************************************************************************
  * VarI8FromUI1 (OLEAUT32.333)
  *
  * Convert a VT_UI1 to a VT_I8.
  *
  * PARAMS
  *  bIn     [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromUI1(BYTE bIn, LONG64* pi64Out)
 {
   return _VarI8FromUI1(bIn, pi64Out);
 }
 
 
 /************************************************************************
  * VarI8FromI2 (OLEAUT32.334)
  *
  * Convert a VT_I2 to a VT_I8.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromI2(SHORT sIn, LONG64* pi64Out)
 {
   return _VarI8FromI2(sIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromR4 (OLEAUT32.335)
  *
  * Convert a VT_R4 to a VT_I8.
  *
  * PARAMS
  *  fltIn   [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI8FromR4(FLOAT fltIn, LONG64* pi64Out)
 {
   return VarI8FromR8(fltIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromR8 (OLEAUT32.336)
  *
  * Convert a VT_R8 to a VT_I8.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  Only values that fit into 63 bits are accepted. Due to rounding issues,
  *  very high or low values will not be accurately converted.
  *
  *  Numbers are rounded using Dutch rounding, as follows:
  *
  *|  Fractional Part   Sign  Direction  Example
  *|  ---------------   ----  ---------  -------
  *|  < 0.5              +    Down        0.4 ->  0.0
  *|  < 0.5              -    Up         -0.4 ->  0.0
  *|  > 0.5              +    Up          0.6 ->  1.0
  *|  < 0.5              -    Up         -0.6 -> -1.0
  *|  = 0.5              +    Up/Down    Down if even, Up if odd
  *|  = 0.5              -    Up/Down    Up if even, Down if odd
  *
  *  This system is often used in supermarkets.
  */
 HRESULT WINAPI VarI8FromR8(double dblIn, LONG64* pi64Out)
 {
   if ( dblIn < -4611686018427387904.0 || dblIn >= 4611686018427387904.0)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(LONG64, dblIn, *pi64Out);
   return S_OK;
 }
 
 /************************************************************************
  * VarI8FromCy (OLEAUT32.337)
  *
  * Convert a VT_CY to a VT_I8.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  *
  * NOTES
  *  All negative numbers are rounded down by 1, including those that are
  *  evenly divisible by 10000 (this is a Win32 bug that Wine mimics).
  *  Positive numbers are rounded using Dutch rounding: See VarI8FromR8()
  *  for details.
  */
 HRESULT WINAPI VarI8FromCy(CY cyIn, LONG64* pi64Out)
 {
   *pi64Out = cyIn.int64 / CY_MULTIPLIER;
 
   if (cyIn.int64 < 0)
     (*pi64Out)--; /* Mimic Win32 bug */
   else
   {
     cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
 
     if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pi64Out & 0x1)))
       (*pi64Out)++;
   }
   return S_OK;
 }
 
 /************************************************************************
  * VarI8FromDate (OLEAUT32.338)
  *
  * Convert a VT_DATE to a VT_I8.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
 {
   return VarI8FromR8(dateIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromStr (OLEAUT32.339)
  *
  * Convert a VT_BSTR to a VT_I8.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi64Out)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pi64Out, VT_I8);
 }
 
 /************************************************************************
  * VarI8FromDisp (OLEAUT32.340)
  *
  * Convert a VT_DISPATCH to a VT_I8.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pi64Out  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarI8FromDisp(IDispatch* pdispIn, LCID lcid, LONG64* pi64Out)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pi64Out, VT_I8, 0);
 }
 
 /************************************************************************
  * VarI8FromBool (OLEAUT32.341)
  *
  * Convert a VT_BOOL to a VT_I8.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromBool(VARIANT_BOOL boolIn, LONG64* pi64Out)
 {
   return VarI8FromI2(boolIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromI1 (OLEAUT32.342)
  *
  * Convert a VT_I1 to a VT_I8.
  *
  * PARAMS
  *  cIn     [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromI1(signed char cIn, LONG64* pi64Out)
 {
   return _VarI8FromI1(cIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromUI2 (OLEAUT32.343)
  *
  * Convert a VT_UI2 to a VT_I8.
  *
  * PARAMS
  *  usIn    [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromUI2(USHORT usIn, LONG64* pi64Out)
 {
   return _VarI8FromUI2(usIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromUI4 (OLEAUT32.344)
  *
  * Convert a VT_UI4 to a VT_I8.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarI8FromUI4(ULONG ulIn, LONG64* pi64Out)
 {
   return _VarI8FromUI4(ulIn, pi64Out);
 }
 
 /************************************************************************
  * VarI8FromDec (OLEAUT32.345)
  *
  * Convert a VT_DECIMAL to a VT_I8.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI8FromDec(DECIMAL *pdecIn, LONG64* pi64Out)
 {
   if (!DEC_SCALE(pdecIn))
   {
     /* This decimal is just a 96 bit integer */
     if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
       return E_INVALIDARG;
 
     if (DEC_HI32(pdecIn) || DEC_MID32(pdecIn) & 0x80000000)
       return DISP_E_OVERFLOW;
 
     if (DEC_SIGN(pdecIn))
       *pi64Out = -DEC_LO64(pdecIn);
     else
       *pi64Out = DEC_LO64(pdecIn);
     return S_OK;
   }
   else
   {
     /* Decimal contains a floating point number */
     HRESULT hRet;
     double dbl;
 
     hRet = VarR8FromDec(pdecIn, &dbl);
     if (SUCCEEDED(hRet))
       hRet = VarI8FromR8(dbl, pi64Out);
     return hRet;
   }
 }
 
 /************************************************************************
  * VarI8FromUI8 (OLEAUT32.427)
  *
  * Convert a VT_UI8 to a VT_I8.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pi64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarI8FromUI8(ULONG64 ullIn, LONG64* pi64Out)
 {
   return _VarI8FromUI8(ullIn, pi64Out);
 }
 
 /* UI8
  */
 
 /************************************************************************
  * VarUI8FromI8 (OLEAUT32.428)
  *
  * Convert a VT_I8 to a VT_UI8.
  *
  * PARAMS
  *  ulIn     [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI8FromI8(LONG64 llIn, ULONG64* pui64Out)
 {
   return _VarUI8FromI8(llIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromUI1 (OLEAUT32.429)
  *
  * Convert a VT_UI1 to a VT_UI8.
  *
  * PARAMS
  *  bIn      [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI8FromUI1(BYTE bIn, ULONG64* pui64Out)
 {
   return _VarUI8FromUI1(bIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromI2 (OLEAUT32.430)
  *
  * Convert a VT_I2 to a VT_UI8.
  *
  * PARAMS
  *  sIn      [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI8FromI2(SHORT sIn, ULONG64* pui64Out)
 {
   return _VarUI8FromI2(sIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromR4 (OLEAUT32.431)
  *
  * Convert a VT_R4 to a VT_UI8.
  *
  * PARAMS
  *  fltIn    [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI8FromR4(FLOAT fltIn, ULONG64* pui64Out)
 {
   return VarUI8FromR8(fltIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromR8 (OLEAUT32.432)
  *
  * Convert a VT_R8 to a VT_UI8.
  *
  * PARAMS
  *  dblIn    [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  See VarI8FromR8() for details concerning rounding.
  */
 HRESULT WINAPI VarUI8FromR8(double dblIn, ULONG64* pui64Out)
 {
   if (dblIn < -0.5 || dblIn > 1.844674407370955e19)
     return DISP_E_OVERFLOW;
   VARIANT_DutchRound(ULONG64, dblIn, *pui64Out);
   return S_OK;
 }
 
 /************************************************************************
  * VarUI8FromCy (OLEAUT32.433)
  *
  * Convert a VT_CY to a VT_UI8.
  *
  * PARAMS
  *  cyIn     [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  Negative values >= -5000 will be converted to 0.
  */
 HRESULT WINAPI VarUI8FromCy(CY cyIn, ULONG64* pui64Out)
 {
   if (cyIn.int64 < 0)
   {
     if (cyIn.int64 < -CY_HALF)
       return DISP_E_OVERFLOW;
     *pui64Out = 0;
   }
   else
   {
     *pui64Out = cyIn.int64 / CY_MULTIPLIER;
 
     cyIn.int64 -= *pui64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
 
     if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pui64Out & 0x1)))
       (*pui64Out)++;
   }
   return S_OK;
 }
 
 /************************************************************************
  * VarUI8FromDate (OLEAUT32.434)
  *
  * Convert a VT_DATE to a VT_UI8.
  *
  * PARAMS
  *  dateIn   [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
 {
   return VarUI8FromR8(dateIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromStr (OLEAUT32.435)
  *
  * Convert a VT_BSTR to a VT_UI8.
  *
  * PARAMS
  *  strIn    [I] Source
  *  lcid     [I] LCID for the conversion
  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64* pui64Out)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pui64Out, VT_UI8);
 }
 
 /************************************************************************
  * VarUI8FromDisp (OLEAUT32.436)
  *
  * Convert a VT_DISPATCH to a VT_UI8.
  *
  * PARAMS
  *  pdispIn   [I] Source
  *  lcid      [I] LCID for conversion
  *  pui64Out  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarUI8FromDisp(IDispatch* pdispIn, LCID lcid, ULONG64* pui64Out)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pui64Out, VT_UI8, 0);
 }
 
 /************************************************************************
  * VarUI8FromBool (OLEAUT32.437)
  *
  * Convert a VT_BOOL to a VT_UI8.
  *
  * PARAMS
  *  boolIn   [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL boolIn, ULONG64* pui64Out)
 {
   return VarI8FromI2(boolIn, (LONG64 *)pui64Out);
 }
 /************************************************************************
  * VarUI8FromI1 (OLEAUT32.438)
  *
  * Convert a VT_I1 to a VT_UI8.
  *
  * PARAMS
  *  cIn      [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarUI8FromI1(signed char cIn, ULONG64* pui64Out)
 {
   return _VarUI8FromI1(cIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromUI2 (OLEAUT32.439)
  *
  * Convert a VT_UI2 to a VT_UI8.
  *
  * PARAMS
  *  usIn     [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI8FromUI2(USHORT usIn, ULONG64* pui64Out)
 {
   return _VarUI8FromUI2(usIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromUI4 (OLEAUT32.440)
  *
  * Convert a VT_UI4 to a VT_UI8.
  *
  * PARAMS
  *  ulIn     [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarUI8FromUI4(ULONG ulIn, ULONG64* pui64Out)
 {
   return _VarUI8FromUI4(ulIn, pui64Out);
 }
 
 /************************************************************************
  * VarUI8FromDec (OLEAUT32.441)
  *
  * Convert a VT_DECIMAL to a VT_UI8.
  *
  * PARAMS
  *  pDecIn   [I] Source
  *  pui64Out [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  Under native Win32, if the source value has a scale of 0, its sign is
  *  ignored, i.e. this function takes the absolute value rather than fail
  *  with DISP_E_OVERFLOW. This bug has been fixed in Wine's implementation
  *  (use VarAbs() on pDecIn first if you really want this behaviour).
  */
 HRESULT WINAPI VarUI8FromDec(DECIMAL *pdecIn, ULONG64* pui64Out)
 {
   if (!DEC_SCALE(pdecIn))
   {
     /* This decimal is just a 96 bit integer */
     if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
       return E_INVALIDARG;
 
     if (DEC_HI32(pdecIn))
       return DISP_E_OVERFLOW;
 
     if (DEC_SIGN(pdecIn))
     {
       WARN("Sign would be ignored under Win32!\n");
       return DISP_E_OVERFLOW;
     }
 
     *pui64Out = DEC_LO64(pdecIn);
     return S_OK;
   }
   else
   {
     /* Decimal contains a floating point number */
     HRESULT hRet;
     double dbl;
 
     hRet = VarR8FromDec(pdecIn, &dbl);
     if (SUCCEEDED(hRet))
       hRet = VarUI8FromR8(dbl, pui64Out);
     return hRet;
   }
 }
 
 /* R4
  */
 
 /************************************************************************
  * VarR4FromUI1 (OLEAUT32.68)
  *
  * Convert a VT_UI1 to a VT_R4.
  *
  * PARAMS
  *  bIn     [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromUI1(BYTE bIn, float *pFltOut)
 {
   return _VarR4FromUI1(bIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromI2 (OLEAUT32.69)
  *
  * Convert a VT_I2 to a VT_R4.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromI2(SHORT sIn, float *pFltOut)
 {
   return _VarR4FromI2(sIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromI4 (OLEAUT32.70)
  *
  * Convert a VT_I4 to a VT_R4.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromI4(LONG lIn, float *pFltOut)
 {
   return _VarR4FromI4(lIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromR8 (OLEAUT32.71)
  *
  * Convert a VT_R8 to a VT_R4.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination.
  */
 HRESULT WINAPI VarR4FromR8(double dblIn, float *pFltOut)
 {
   double d = dblIn < 0.0 ? -dblIn : dblIn;
   if (d > R4_MAX) return DISP_E_OVERFLOW;
   *pFltOut = dblIn;
   return S_OK;
 }
 
 /************************************************************************
  * VarR4FromCy (OLEAUT32.72)
  *
  * Convert a VT_CY to a VT_R4.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromCy(CY cyIn, float *pFltOut)
 {
   *pFltOut = (double)cyIn.int64 / CY_MULTIPLIER_F;
   return S_OK;
 }
 
 /************************************************************************
  * VarR4FromDate (OLEAUT32.73)
  *
  * Convert a VT_DATE to a VT_R4.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination.
  */
 HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
 {
   return VarR4FromR8(dateIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromStr (OLEAUT32.74)
  *
  * Convert a VT_BSTR to a VT_R4.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if strIn or pFltOut is invalid.
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pFltOut, VT_R4);
 }
 
 /************************************************************************
  * VarR4FromDisp (OLEAUT32.75)
  *
  * Convert a VT_DISPATCH to a VT_R4.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pFltOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR4FromDisp(IDispatch* pdispIn, LCID lcid, float *pFltOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pFltOut, VT_R4, 0);
 }
 
 /************************************************************************
  * VarR4FromBool (OLEAUT32.76)
  *
  * Convert a VT_BOOL to a VT_R4.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, float *pFltOut)
 {
   return VarR4FromI2(boolIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromI1 (OLEAUT32.213)
  *
  * Convert a VT_I1 to a VT_R4.
  *
  * PARAMS
  *  cIn     [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR4FromI1(signed char cIn, float *pFltOut)
 {
   return _VarR4FromI1(cIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromUI2 (OLEAUT32.214)
  *
  * Convert a VT_UI2 to a VT_R4.
  *
  * PARAMS
  *  usIn    [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR4FromUI2(USHORT usIn, float *pFltOut)
 {
   return _VarR4FromUI2(usIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromUI4 (OLEAUT32.215)
  *
  * Convert a VT_UI4 to a VT_R4.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, float *pFltOut)
 {
   return _VarR4FromUI4(ulIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromDec (OLEAUT32.216)
  *
  * Convert a VT_DECIMAL to a VT_R4.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid.
  */
 HRESULT WINAPI VarR4FromDec(DECIMAL* pDecIn, float *pFltOut)
 {
   BYTE scale = DEC_SCALE(pDecIn);
   int divisor = 1;
   double highPart;
 
   if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
   while (scale--)
     divisor *= 10;
 
   if (DEC_SIGN(pDecIn))
     divisor = -divisor;
 
   if (DEC_HI32(pDecIn))
   {
     highPart = (double)DEC_HI32(pDecIn) / (double)divisor;
     highPart *= 4294967296.0F;
     highPart *= 4294967296.0F;
   }
   else
     highPart = 0.0;
 
   *pFltOut = (double)DEC_LO64(pDecIn) / (double)divisor + highPart;
   return S_OK;
 }
 
 /************************************************************************
  * VarR4FromI8 (OLEAUT32.360)
  *
  * Convert a VT_I8 to a VT_R4.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromI8(LONG64 llIn, float *pFltOut)
 {
   return _VarR4FromI8(llIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4FromUI8 (OLEAUT32.361)
  *
  * Convert a VT_UI8 to a VT_R4.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pFltOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR4FromUI8(ULONG64 ullIn, float *pFltOut)
 {
   return _VarR4FromUI8(ullIn, pFltOut);
 }
 
 /************************************************************************
  * VarR4CmpR8 (OLEAUT32.316)
  *
  * Compare a VT_R4 to a VT_R8.
  *
  * PARAMS
  *  fltLeft  [I] Source
  *  dblRight [I] Value to compare
  *
  * RETURNS
  *  VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that fltLeft is less than,
  *  equal to or greater than dblRight respectively.
  */
 HRESULT WINAPI VarR4CmpR8(float fltLeft, double dblRight)
 {
   if (fltLeft < dblRight)
     return VARCMP_LT;
   else if (fltLeft > dblRight)
     return VARCMP_GT;
   return VARCMP_EQ;
 }
 
 /* R8
  */
 
 /************************************************************************
  * VarR8FromUI1 (OLEAUT32.78)
  *
  * Convert a VT_UI1 to a VT_R8.
  *
  * PARAMS
  *  bIn     [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double *pDblOut)
 {
   return _VarR8FromUI1(bIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromI2 (OLEAUT32.79)
  *
  * Convert a VT_I2 to a VT_R8.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromI2(SHORT sIn, double *pDblOut)
 {
   return _VarR8FromI2(sIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromI4 (OLEAUT32.80)
  *
  * Convert a VT_I4 to a VT_R8.
  *
  * PARAMS
  *  sIn     [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromI4(LONG lIn, double *pDblOut)
 {
   return _VarR8FromI4(lIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromR4 (OLEAUT32.81)
  *
  * Convert a VT_R4 to a VT_R8.
  *
  * PARAMS
  *  fltIn   [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double *pDblOut)
 {
   return _VarR8FromR4(fltIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromCy (OLEAUT32.82)
  *
  * Convert a VT_CY to a VT_R8.
  *
  * PARAMS
  *  cyIn    [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromCy(CY cyIn, double *pDblOut)
 {
   return _VarR8FromCy(cyIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromDate (OLEAUT32.83)
  *
  * Convert a VT_DATE to a VT_R8.
  *
  * PARAMS
  *  dateIn  [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromDate(DATE dateIn, double *pDblOut)
 {
   return _VarR8FromDate(dateIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromStr (OLEAUT32.84)
  *
  * Convert a VT_BSTR to a VT_R8.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if strIn or pDblOut is invalid.
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDblOut, VT_R8);
 }
 
 /************************************************************************
  * VarR8FromDisp (OLEAUT32.85)
  *
  * Convert a VT_DISPATCH to a VT_R8.
  *
  * PARAMS
  *  pdispIn  [I] Source
  *  lcid     [I] LCID for conversion
  *  pDblOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR8FromDisp(IDispatch* pdispIn, LCID lcid, double *pDblOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pDblOut, VT_R8, 0);
 }
 
 /************************************************************************
  * VarR8FromBool (OLEAUT32.86)
  *
  * Convert a VT_BOOL to a VT_R8.
  *
  * PARAMS
  *  boolIn  [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double *pDblOut)
 {
   return VarR8FromI2(boolIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromI1 (OLEAUT32.217)
  *
  * Convert a VT_I1 to a VT_R8.
  *
  * PARAMS
  *  cIn     [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR8FromI1(signed char cIn, double *pDblOut)
 {
   return _VarR8FromI1(cIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromUI2 (OLEAUT32.218)
  *
  * Convert a VT_UI2 to a VT_R8.
  *
  * PARAMS
  *  usIn    [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR8FromUI2(USHORT usIn, double *pDblOut)
 {
   return _VarR8FromUI2(usIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromUI4 (OLEAUT32.219)
  *
  * Convert a VT_UI4 to a VT_R8.
  *
  * PARAMS
  *  ulIn    [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double *pDblOut)
 {
   return _VarR8FromUI4(ulIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromDec (OLEAUT32.220)
  *
  * Convert a VT_DECIMAL to a VT_R8.
  *
  * PARAMS
  *  pDecIn  [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid.
  */
 HRESULT WINAPI VarR8FromDec(const DECIMAL* pDecIn, double *pDblOut)
 {
   BYTE scale = DEC_SCALE(pDecIn);
   double divisor = 1.0, highPart;
 
   if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
     return E_INVALIDARG;
 
   while (scale--)
     divisor *= 10;
 
   if (DEC_SIGN(pDecIn))
     divisor = -divisor;
 
   if (DEC_HI32(pDecIn))
   {
     highPart = (double)DEC_HI32(pDecIn) / divisor;
     highPart *= 4294967296.0F;
     highPart *= 4294967296.0F;
   }
   else
     highPart = 0.0;
 
   *pDblOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
   return S_OK;
 }
 
 /************************************************************************
  * VarR8FromI8 (OLEAUT32.362)
  *
  * Convert a VT_I8 to a VT_R8.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromI8(LONG64 llIn, double *pDblOut)
 {
   return _VarR8FromI8(llIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8FromUI8 (OLEAUT32.363)
  *
  * Convert a VT_UI8 to a VT_R8.
  *
  * PARAMS
  *  ullIn   [I] Source
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK.
  */
 HRESULT WINAPI VarR8FromUI8(ULONG64 ullIn, double *pDblOut)
 {
   return _VarR8FromUI8(ullIn, pDblOut);
 }
 
 /************************************************************************
  * VarR8Pow (OLEAUT32.315)
  *
  * Raise a VT_R8 to a power.
  *
  * PARAMS
  *  dblLeft [I] Source
  *  dblPow  [I] Power to raise dblLeft by
  *  pDblOut [O] Destination
  *
  * RETURNS
  *  S_OK. pDblOut contains dblLeft to the power of dblRight.
  */
 HRESULT WINAPI VarR8Pow(double dblLeft, double dblPow, double *pDblOut)
 {
   *pDblOut = pow(dblLeft, dblPow);
   return S_OK;
 }
 
 /************************************************************************
  * VarR8Round (OLEAUT32.317)
  *
  * Round a VT_R8 to a given number of decimal points.
  *
  * PARAMS
  *  dblIn   [I] Source
  *  nDig    [I] Number of decimal points to round to
  *  pDblOut [O] Destination for rounded number
  *
  * RETURNS
  *  Success: S_OK. pDblOut is rounded to nDig digits.
  *  Failure: E_INVALIDARG, if cDecimals is less than 0.
  *
  * NOTES
  *  The native version of this function rounds using the internal
  *  binary representation of the number. Wine uses the dutch rounding
  *  convention, so therefore small differences can occur in the value returned.
  *  MSDN says that you should use your own rounding function if you want
  *  rounding to be predictable in your application.
  */
 HRESULT WINAPI VarR8Round(double dblIn, int nDig, double *pDblOut)
 {
   double scale, whole, fract;
 
   if (nDig < 0)
     return E_INVALIDARG;
 
   scale = pow(10.0, nDig);
 
   dblIn *= scale;
   whole = dblIn < 0 ? ceil(dblIn) : floor(dblIn);
   fract = dblIn - whole;
 
   if (fract > 0.5)
     dblIn = whole + 1.0;
   else if (fract == 0.5)
     dblIn = whole + fmod(whole, 2.0);
   else if (fract >= 0.0)
     dblIn = whole;
   else if (fract == -0.5)
     dblIn = whole - fmod(whole, 2.0);
   else if (fract > -0.5)
     dblIn = whole;
   else
     dblIn = whole - 1.0;
 
   *pDblOut = dblIn / scale;
   return S_OK;
 }
 
 /* CY
  */
 
 /* Powers of 10 from 0..4 D.P. */
 static const int CY_Divisors[5] = { CY_MULTIPLIER/10000, CY_MULTIPLIER/1000,
   CY_MULTIPLIER/100, CY_MULTIPLIER/10, CY_MULTIPLIER };
 
 /************************************************************************
  * VarCyFromUI1 (OLEAUT32.98)
  *
  * Convert a VT_UI1 to a VT_CY.
  *
  * PARAMS
  *  bIn    [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pCyOut)
 {
   return VarCyFromR8(bIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromI2 (OLEAUT32.99)
  *
  * Convert a VT_I2 to a VT_CY.
  *
  * PARAMS
  *  sIn    [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromI2(SHORT sIn, CY* pCyOut)
 {
   return VarCyFromR8(sIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromI4 (OLEAUT32.100)
  *
  * Convert a VT_I4 to a VT_CY.
  *
  * PARAMS
  *  sIn    [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pCyOut)
 {
   return VarCyFromR8(lIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromR4 (OLEAUT32.101)
  *
  * Convert a VT_R4 to a VT_CY.
  *
  * PARAMS
  *  fltIn  [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pCyOut)
 {
   return VarCyFromR8(fltIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromR8 (OLEAUT32.102)
  *
  * Convert a VT_R8 to a VT_CY.
  *
  * PARAMS
  *  dblIn  [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pCyOut)
 {
 #if defined(__GNUC__) && defined(__i386__)
   /* This code gives identical results to Win32 on Intel.
    * Here we use fp exceptions to catch overflows when storing the value.
    */
   static const unsigned short r8_fpcontrol = 0x137f;
   static const double r8_multiplier = CY_MULTIPLIER_F;
   unsigned short old_fpcontrol, result_fpstatus;
 
   /* Clear exceptions, save the old fp state and load the new state */
   __asm__ __volatile__( "fnclex" );
   __asm__ __volatile__( "fstcw %0"   :   "=m" (old_fpcontrol) : );
   __asm__ __volatile__( "fldcw %0"   : : "m"  (r8_fpcontrol) );
   /* Perform the conversion. */
   __asm__ __volatile__( "fldl  %0"   : : "m"  (dblIn) );
   __asm__ __volatile__( "fmull %0"   : : "m"  (r8_multiplier) );
   __asm__ __volatile__( "fistpll %0" : : "m"  (*pCyOut) );
   /* Save the resulting fp state, load the old state and clear exceptions */
   __asm__ __volatile__( "fstsw %0"   :   "=m" (result_fpstatus) : );
   __asm__ __volatile__( "fnclex" );
   __asm__ __volatile__( "fldcw %0"   : : "m"  (old_fpcontrol) );
 
   if (result_fpstatus & 0x9) /* Overflow | Invalid */
     return DISP_E_OVERFLOW;
 #else
   /* This version produces slightly different results for boundary cases */
   if (dblIn < -922337203685477.5807 || dblIn >= 922337203685477.5807)
     return DISP_E_OVERFLOW;
   dblIn *= CY_MULTIPLIER_F;
   VARIANT_DutchRound(LONG64, dblIn, pCyOut->int64);
 #endif
   return S_OK;
 }
 
 /************************************************************************
  * VarCyFromDate (OLEAUT32.103)
  *
  * Convert a VT_DATE to a VT_CY.
  *
  * PARAMS
  *  dateIn [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
 {
   return VarCyFromR8(dateIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromStr (OLEAUT32.104)
  *
  * Convert a VT_BSTR to a VT_CY.
  *
  * PARAMS
  *  strIn   [I] Source
  *  lcid    [I] LCID for the conversion
  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut)
 {
   return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pCyOut, VT_CY);
 }
 
 /************************************************************************
  * VarCyFromDisp (OLEAUT32.105)
  *
  * Convert a VT_DISPATCH to a VT_CY.
  *
  * PARAMS
  *  pdispIn [I] Source
  *  lcid    [I] LCID for conversion
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromDisp(IDispatch* pdispIn, LCID lcid, CY* pCyOut)
 {
   return VARIANT_FromDisp(pdispIn, lcid, pCyOut, VT_CY, 0);
 }
 
 /************************************************************************
  * VarCyFromBool (OLEAUT32.106)
  *
  * Convert a VT_BOOL to a VT_CY.
  *
  * PARAMS
  *  boolIn [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  *
  * NOTES
  *  While the sign of the boolean is stored in the currency, the value is
  *  converted to either 0 or 1.
  */
 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pCyOut)
 {
   return VarCyFromR8(boolIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromI1 (OLEAUT32.225)
  *
  * Convert a VT_I1 to a VT_CY.
  *
  * PARAMS
  *  cIn    [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pCyOut)
 {
   return VarCyFromR8(cIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromUI2 (OLEAUT32.226)
  *
  * Convert a VT_UI2 to a VT_CY.
  *
  * PARAMS
  *  usIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pCyOut)
 {
   return VarCyFromR8(usIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromUI4 (OLEAUT32.227)
  *
  * Convert a VT_UI4 to a VT_CY.
  *
  * PARAMS
  *  ulIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pCyOut)
 {
   return VarCyFromR8(ulIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyFromDec (OLEAUT32.228)
  *
  * Convert a VT_DECIMAL to a VT_CY.
  *
  * PARAMS
  *  pdecIn  [I] Source
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
 {
   DECIMAL rounded;
   HRESULT hRet;
 
   hRet = VarDecRound(pdecIn, 4, &rounded);
 
   if (SUCCEEDED(hRet))
   {
     double d;
 
     if (DEC_HI32(&rounded))
       return DISP_E_OVERFLOW;
 
     /* Note: Without the casts this promotes to int64 which loses precision */
     d = (double)DEC_LO64(&rounded) / (double)CY_Divisors[DEC_SCALE(&rounded)];
     if (DEC_SIGN(&rounded))
       d = -d;
     return VarCyFromR8(d, pCyOut);
   }
   return hRet;
 }
 
 /************************************************************************
  * VarCyFromI8 (OLEAUT32.366)
  *
  * Convert a VT_I8 to a VT_CY.
  *
  * PARAMS
  *  ullIn  [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromI8(LONG64 llIn, CY* pCyOut)
 {
   if (llIn <= (I8_MIN/CY_MULTIPLIER) || llIn >= (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW;
   pCyOut->int64 = llIn * CY_MULTIPLIER;
   return S_OK;
 }
 
 /************************************************************************
  * VarCyFromUI8 (OLEAUT32.375)
  *
  * Convert a VT_UI8 to a VT_CY.
  *
  * PARAMS
  *  ullIn  [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if the source value is invalid
  *           DISP_E_OVERFLOW, if the value will not fit in the destination
  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
  */
 HRESULT WINAPI VarCyFromUI8(ULONG64 ullIn, CY* pCyOut)
 {
   return VarCyFromR8(ullIn, pCyOut);
 }
 
 /************************************************************************
  * VarCyAdd (OLEAUT32.299)
  *
  * Add one CY to another.
  *
  * PARAMS
  *  cyLeft  [I] Source
  *  cyRight [I] Value to add
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCyAdd(const CY cyLeft, const CY cyRight, CY* pCyOut)
 {
   double l,r;
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l + r;
   return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
  * VarCyMul (OLEAUT32.303)
  *
  * Multiply one CY by another.
  *
  * PARAMS
  *  cyLeft  [I] Source
  *  cyRight [I] Value to multiply by
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCyMul(const CY cyLeft, const CY cyRight, CY* pCyOut)
 {
   double l,r;
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l * r;
   return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
  * VarCyMulI4 (OLEAUT32.304)
  *
  * Multiply one CY by a VT_I4.
  *
  * PARAMS
  *  cyLeft  [I] Source
  *  lRight  [I] Value to multiply by
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCyMulI4(const CY cyLeft, LONG lRight, CY* pCyOut)
 {
   double d;
 
   _VarR8FromCy(cyLeft, &d);
   d = d * lRight;
   return VarCyFromR8(d, pCyOut);
 }
 
 /************************************************************************
  * VarCySub (OLEAUT32.305)
  *
  * Subtract one CY from another.
  *
  * PARAMS
  *  cyLeft  [I] Source
  *  cyRight [I] Value to subtract
  *  pCyOut  [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCySub(const CY cyLeft, const CY cyRight, CY* pCyOut)
 {
   double l,r;
   _VarR8FromCy(cyLeft, &l);
   _VarR8FromCy(cyRight, &r);
   l = l - r;
   return VarCyFromR8(l, pCyOut);
 }
 
 /************************************************************************
  * VarCyAbs (OLEAUT32.306)
  *
  * Convert a VT_CY into its absolute value.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK. pCyOut contains the absolute value.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCyAbs(const CY cyIn, CY* pCyOut)
 {
   if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
     return DISP_E_OVERFLOW;
 
   pCyOut->int64 = cyIn.int64 < 0 ? -cyIn.int64 : cyIn.int64;
   return S_OK;
 }
 
 /************************************************************************
  * VarCyFix (OLEAUT32.307)
  *
  * Return the integer part of a VT_CY.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  - The difference between this function and VarCyInt() is that VarCyInt() rounds
  *    negative numbers away from 0, while this function rounds them towards zero.
  */
 HRESULT WINAPI VarCyFix(const CY cyIn, CY* pCyOut)
 {
   pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
   pCyOut->int64 *= CY_MULTIPLIER;
   return S_OK;
 }
 
 /************************************************************************
  * VarCyInt (OLEAUT32.308)
  *
  * Return the integer part of a VT_CY.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  *
  * NOTES
  *  - The difference between this function and VarCyFix() is that VarCyFix() rounds
  *    negative numbers towards 0, while this function rounds them away from zero.
  */
 HRESULT WINAPI VarCyInt(const CY cyIn, CY* pCyOut)
 {
   pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
   pCyOut->int64 *= CY_MULTIPLIER;
 
   if (cyIn.int64 < 0 && cyIn.int64 % CY_MULTIPLIER != 0)
   {
     pCyOut->int64 -= CY_MULTIPLIER;
   }
   return S_OK;
 }
 
 /************************************************************************
  * VarCyNeg (OLEAUT32.309)
  *
  * Change the sign of a VT_CY.
  *
  * PARAMS
  *  cyIn   [I] Source
  *  pCyOut [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
  */
 HRESULT WINAPI VarCyNeg(const CY cyIn, CY* pCyOut)
 {
   if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
     return DISP_E_OVERFLOW;
 
   pCyOut->int64 = -cyIn.int64;
   return S_OK;
 }
 
 /************************************************************************
  * VarCyRound (OLEAUT32.310)
  *
  * Change the precision of a VT_CY.
  *
  * PARAMS
  *  cyIn      [I] Source
  *  cDecimals [I] New number of decimals to keep
  *  pCyOut    [O] Destination
  *
  * RETURNS
  *  Success: S_OK.
  *  Failure: E_INVALIDARG, if cDecimals is less than 0.
  */
 HRESULT WINAPI VarCyRound(const CY cyIn, int cDecimals, CY* pCyOut)
 {
   if (cDecimals < 0)
     return E_INVALIDARG;
 
   if (cDecimals > 3)
   {
     /* Rounding to more precision than we have */
     *pCyOut = cyIn;