git.oblomov.eu Git - wine/blob - dlls/oleaut32/variant.c

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