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

   1 /*
   2  * Low level variant functions
   3  *
   4  * Copyright 2003 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #define COBJMACROS
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24
  25 #include "wine/debug.h"
  26 #include "wine/unicode.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "winnt.h"
  30 #include "variant.h"
  31 #include "resource.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(variant);
  34
  35 extern HMODULE OLEAUT32_hModule;
  36
  37 static const WCHAR szFloatFormatW[] = { '%','.','7','G','\0' };
  38 static const WCHAR szDoubleFormatW[] = { '%','.','1','5','G','\0' };
  39
  40 /* Copy data from one variant to another. */
  41 static inline void VARIANT_CopyData(const VARIANT *srcVar, VARTYPE vt, void *pOut)
  42 {
  43   switch (vt)
  44   {
  45   case VT_I1:
  46   case VT_UI1: memcpy(pOut, &V_UI1(srcVar), sizeof(BYTE)); break;
  47   case VT_BOOL:
  48   case VT_I2:
  49   case VT_UI2: memcpy(pOut, &V_UI2(srcVar), sizeof(SHORT)); break;
  50   case VT_R4:
  51   case VT_INT:
  52   case VT_I4:
  53   case VT_UINT:
  54   case VT_UI4: memcpy(pOut, &V_UI4(srcVar), sizeof (LONG)); break;
  55   case VT_R8:
  56   case VT_DATE:
  57   case VT_CY:
  58   case VT_I8:
  59   case VT_UI8: memcpy(pOut, &V_UI8(srcVar), sizeof (LONG64)); break;
  60   case VT_INT_PTR: memcpy(pOut, &V_INT_PTR(srcVar), sizeof (INT_PTR)); break;
  61   case VT_DECIMAL: memcpy(pOut, &V_DECIMAL(srcVar), sizeof (DECIMAL)); break;
  62   default:
  63     FIXME("VT_ type %d unhandled, please report!\n", vt);
  64   }
  65 }
  66
  67
  68 /* Coerce VT_BSTR to a numeric type */
  69 HRESULT VARIANT_NumberFromBstr(OLECHAR* pStrIn, LCID lcid, ULONG ulFlags,
  70                                void* pOut, VARTYPE vt)
  71 {
  72   VARIANTARG dstVar;
  73   HRESULT hRet;
  74   NUMPARSE np;
  75   BYTE rgb[1024];
  76
  77   /* Use VarParseNumFromStr/VarNumFromParseNum as MSDN indicates */
  78   np.cDig = sizeof(rgb) / sizeof(BYTE);
  79   np.dwInFlags = NUMPRS_STD;
  80
  81   hRet = VarParseNumFromStr(pStrIn, lcid, ulFlags, &np, rgb);
  82
  83   if (SUCCEEDED(hRet))
  84   {
  85     /* 1 << vt gives us the VTBIT constant for the destination number type */
  86     hRet = VarNumFromParseNum(&np, rgb, 1 << vt, &dstVar);
  87     if (SUCCEEDED(hRet))
  88       VARIANT_CopyData(&dstVar, vt, pOut);
  89   }
  90   return hRet;
  91 }
  92
  93 /* Coerce VT_DISPATCH to another type */
  94 HRESULT VARIANT_FromDisp(IDispatch* pdispIn, LCID lcid, void* pOut, VARTYPE vt)
  95 {
  96   static const DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
  97   VARIANTARG srcVar, dstVar;
  98   HRESULT hRet;
  99
 100   if (!pdispIn)
 101     return DISP_E_BADVARTYPE;
 102
 103   /* Get the default 'value' property from the IDispatch */
 104   hRet = IDispatch_Invoke(pdispIn, DISPID_VALUE, &IID_NULL, lcid, DISPATCH_PROPERTYGET,
 105                           (DISPPARAMS*)&emptyParams, &srcVar, NULL, NULL);
 106
 107   if (SUCCEEDED(hRet))
 108   {
 109     /* Convert the property to the requested type */
 110     V_VT(&dstVar) = VT_EMPTY;
 111     hRet = VariantChangeTypeEx(&dstVar, &srcVar, lcid, 0, vt);
 112     VariantClear(&srcVar);
 113
 114     if (SUCCEEDED(hRet))
 115     {
 116       VARIANT_CopyData(&dstVar, vt, pOut);
 117       VariantClear(&srcVar);
 118     }
 119   }
 120   else
 121     hRet = DISP_E_TYPEMISMATCH;
 122   return hRet;
 123 }
 124
 125 /* I1
 126  */
 127
 128 /************************************************************************
 129  * VarI1FromUI1 (OLEAUT32.244)
 130  *
 131  * Convert a VT_UI1 to a VT_I1.
 132  *
 133  * PARAMS
 134  *  bIn     [I] Source
 135  *  pcOut   [O] Destination
 136  *
 137  * RETURNS
 138  *  Success: S_OK.
 139  *  Failure: E_INVALIDARG, if the source value is invalid
 140  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 141  */
 142 HRESULT WINAPI VarI1FromUI1(BYTE bIn, signed char* pcOut)
 143 {
 144   return _VarI1FromUI1(bIn, pcOut);
 145 }
 146
 147 /************************************************************************
 148  * VarI1FromI2 (OLEAUT32.245)
 149  *
 150  * Convert a VT_I2 to a VT_I1.
 151  *
 152  * PARAMS
 153  *  sIn     [I] Source
 154  *  pcOut   [O] Destination
 155  *
 156  * RETURNS
 157  *  Success: S_OK.
 158  *  Failure: E_INVALIDARG, if the source value is invalid
 159  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 160  */
 161 HRESULT WINAPI VarI1FromI2(SHORT sIn, signed char* pcOut)
 162 {
 163   return _VarI1FromI2(sIn, pcOut);
 164 }
 165
 166 /************************************************************************
 167  * VarI1FromI4 (OLEAUT32.246)
 168  *
 169  * Convert a VT_I4 to a VT_I1.
 170  *
 171  * PARAMS
 172  *  iIn     [I] Source
 173  *  pcOut   [O] Destination
 174  *
 175  * RETURNS
 176  *  Success: S_OK.
 177  *  Failure: E_INVALIDARG, if the source value is invalid
 178  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 179  */
 180 HRESULT WINAPI VarI1FromI4(LONG iIn, signed char* pcOut)
 181 {
 182   return _VarI1FromI4(iIn, pcOut);
 183 }
 184
 185 /************************************************************************
 186  * VarI1FromR4 (OLEAUT32.247)
 187  *
 188  * Convert a VT_R4 to a VT_I1.
 189  *
 190  * PARAMS
 191  *  fltIn   [I] Source
 192  *  pcOut   [O] Destination
 193  *
 194  * RETURNS
 195  *  Success: S_OK.
 196  *  Failure: E_INVALIDARG, if the source value is invalid
 197  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 198  */
 199 HRESULT WINAPI VarI1FromR4(FLOAT fltIn, signed char* pcOut)
 200 {
 201   return _VarI1FromR4(fltIn, pcOut);
 202 }
 203
 204 /************************************************************************
 205  * VarI1FromR8 (OLEAUT32.248)
 206  *
 207  * Convert a VT_R8 to a VT_I1.
 208  *
 209  * PARAMS
 210  *  dblIn   [I] Source
 211  *  pcOut   [O] Destination
 212  *
 213  * RETURNS
 214  *  Success: S_OK.
 215  *  Failure: E_INVALIDARG, if the source value is invalid
 216  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 217  *
 218  * NOTES
 219  *  See VarI8FromR8() for details concerning rounding.
 220  */
 221 HRESULT WINAPI VarI1FromR8(double dblIn, signed char* pcOut)
 222 {
 223   if (dblIn < (double)I1_MIN || dblIn > (double)I1_MAX)
 224     return DISP_E_OVERFLOW;
 225   OLEAUT32_DutchRound(CHAR, dblIn, *pcOut);
 226   return S_OK;
 227 }
 228
 229 /************************************************************************
 230  * VarI1FromDate (OLEAUT32.249)
 231  *
 232  * Convert a VT_DATE to a VT_I1.
 233  *
 234  * PARAMS
 235  *  dateIn  [I] Source
 236  *  pcOut   [O] Destination
 237  *
 238  * RETURNS
 239  *  Success: S_OK.
 240  *  Failure: E_INVALIDARG, if the source value is invalid
 241  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 242  */
 243 HRESULT WINAPI VarI1FromDate(DATE dateIn, signed char* pcOut)
 244 {
 245   return _VarI1FromDate(dateIn, pcOut);
 246 }
 247
 248 /************************************************************************
 249  * VarI1FromCy (OLEAUT32.250)
 250  *
 251  * Convert a VT_CY to a VT_I1.
 252  *
 253  * PARAMS
 254  *  cyIn    [I] Source
 255  *  pcOut   [O] Destination
 256  *
 257  * RETURNS
 258  *  Success: S_OK.
 259  *  Failure: E_INVALIDARG, if the source value is invalid
 260  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 261  */
 262 HRESULT WINAPI VarI1FromCy(CY cyIn, signed char* pcOut)
 263 {
 264   LONG i = I1_MAX + 1;
 265
 266   _VarI4FromCy(cyIn, &i);
 267   return _VarI1FromI4(i, pcOut);
 268 }
 269
 270 /************************************************************************
 271  * VarI1FromStr (OLEAUT32.251)
 272  *
 273  * Convert a VT_BSTR to a VT_I1.
 274  *
 275  * PARAMS
 276  *  strIn   [I] Source
 277  *  lcid    [I] LCID for the conversion
 278  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
 279  *  pcOut   [O] Destination
 280  *
 281  * RETURNS
 282  *  Success: S_OK.
 283  *  Failure: E_INVALIDARG, if the source value is invalid
 284  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 285  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 286  */
 287 HRESULT WINAPI VarI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, signed char* pcOut)
 288 {
 289   return _VarI1FromStr(strIn, lcid, dwFlags, pcOut);
 290 }
 291
 292 /************************************************************************
 293  * VarI1FromDisp (OLEAUT32.252)
 294  *
 295  * Convert a VT_DISPATCH to a VT_I1.
 296  *
 297  * PARAMS
 298  *  pdispIn  [I] Source
 299  *  lcid     [I] LCID for conversion
 300  *  pcOut    [O] Destination
 301  *
 302  * RETURNS
 303  *  Success: S_OK.
 304  *  Failure: E_INVALIDARG, if the source value is invalid
 305  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 306  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 307  */
 308 HRESULT WINAPI VarI1FromDisp(IDispatch* pdispIn, LCID lcid, signed char* pcOut)
 309 {
 310   return _VarI1FromDisp(pdispIn, lcid, pcOut);
 311 }
 312
 313 /************************************************************************
 314  * VarI1FromBool (OLEAUT32.253)
 315  *
 316  * Convert a VT_BOOL to a VT_I1.
 317  *
 318  * PARAMS
 319  *  boolIn  [I] Source
 320  *  pcOut   [O] Destination
 321  *
 322  * RETURNS
 323  *  S_OK.
 324  */
 325 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL boolIn, signed char* pcOut)
 326 {
 327   return _VarI1FromBool(boolIn, pcOut);
 328 }
 329
 330 /************************************************************************
 331  * VarI1FromUI2 (OLEAUT32.254)
 332  *
 333  * Convert a VT_UI2 to a VT_I1.
 334  *
 335  * PARAMS
 336  *  usIn    [I] Source
 337  *  pcOut   [O] Destination
 338  *
 339  * RETURNS
 340  *  Success: S_OK.
 341  *  Failure: E_INVALIDARG, if the source value is invalid
 342  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 343  */
 344 HRESULT WINAPI VarI1FromUI2(USHORT usIn, signed char* pcOut)
 345 {
 346   return _VarI1FromUI2(usIn, pcOut);
 347 }
 348
 349 /************************************************************************
 350  * VarI1FromUI4 (OLEAUT32.255)
 351  *
 352  * Convert a VT_UI4 to a VT_I1.
 353  *
 354  * PARAMS
 355  *  ulIn    [I] Source
 356  *  pcOut   [O] Destination
 357  *
 358  * RETURNS
 359  *  Success: S_OK.
 360  *  Failure: E_INVALIDARG, if the source value is invalid
 361  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 362  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 363  */
 364 HRESULT WINAPI VarI1FromUI4(ULONG ulIn, signed char* pcOut)
 365 {
 366   return _VarI1FromUI4(ulIn, pcOut);
 367 }
 368
 369 /************************************************************************
 370  * VarI1FromDec (OLEAUT32.256)
 371  *
 372  * Convert a VT_DECIMAL to a VT_I1.
 373  *
 374  * PARAMS
 375  *  pDecIn  [I] Source
 376  *  pcOut   [O] Destination
 377  *
 378  * RETURNS
 379  *  Success: S_OK.
 380  *  Failure: E_INVALIDARG, if the source value is invalid
 381  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 382  */
 383 HRESULT WINAPI VarI1FromDec(DECIMAL *pdecIn, signed char* pcOut)
 384 {
 385   LONG64 i64;
 386   HRESULT hRet;
 387
 388   hRet = _VarI8FromDec(pdecIn, &i64);
 389
 390   if (SUCCEEDED(hRet))
 391     hRet = _VarI1FromI8(i64, pcOut);
 392   return hRet;
 393 }
 394
 395 /************************************************************************
 396  * VarI1FromI8 (OLEAUT32.376)
 397  *
 398  * Convert a VT_I8 to a VT_I1.
 399  *
 400  * PARAMS
 401  *  llIn  [I] Source
 402  *  pcOut [O] Destination
 403  *
 404  * RETURNS
 405  *  Success: S_OK.
 406  *  Failure: E_INVALIDARG, if the source value is invalid
 407  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 408  */
 409 HRESULT WINAPI VarI1FromI8(LONG64 llIn, signed char* pcOut)
 410 {
 411   return _VarI1FromI8(llIn, pcOut);
 412 }
 413
 414 /************************************************************************
 415  * VarI1FromUI8 (OLEAUT32.377)
 416  *
 417  * Convert a VT_UI8 to a VT_I1.
 418  *
 419  * PARAMS
 420  *  ullIn   [I] Source
 421  *  pcOut   [O] Destination
 422  *
 423  * RETURNS
 424  *  Success: S_OK.
 425  *  Failure: E_INVALIDARG, if the source value is invalid
 426  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 427  */
 428 HRESULT WINAPI VarI1FromUI8(ULONG64 ullIn, signed char* pcOut)
 429 {
 430   return _VarI1FromUI8(ullIn, pcOut);
 431 }
 432
 433 /* UI1
 434  */
 435
 436 /************************************************************************
 437  * VarUI1FromI2 (OLEAUT32.130)
 438  *
 439  * Convert a VT_I2 to a VT_UI1.
 440  *
 441  * PARAMS
 442  *  sIn   [I] Source
 443  *  pbOut [O] Destination
 444  *
 445  * RETURNS
 446  *  Success: S_OK.
 447  *  Failure: E_INVALIDARG, if the source value is invalid
 448  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 449  */
 450 HRESULT WINAPI VarUI1FromI2(SHORT sIn, BYTE* pbOut)
 451 {
 452   return _VarUI1FromI2(sIn, pbOut);
 453 }
 454
 455 /************************************************************************
 456  * VarUI1FromI4 (OLEAUT32.131)
 457  *
 458  * Convert a VT_I4 to a VT_UI1.
 459  *
 460  * PARAMS
 461  *  iIn   [I] Source
 462  *  pbOut [O] Destination
 463  *
 464  * RETURNS
 465  *  Success: S_OK.
 466  *  Failure: E_INVALIDARG, if the source value is invalid
 467  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 468  */
 469 HRESULT WINAPI VarUI1FromI4(LONG iIn, BYTE* pbOut)
 470 {
 471   return _VarUI1FromI4(iIn, pbOut);
 472 }
 473
 474 /************************************************************************
 475  * VarUI1FromR4 (OLEAUT32.132)
 476  *
 477  * Convert a VT_R4 to a VT_UI1.
 478  *
 479  * PARAMS
 480  *  fltIn [I] Source
 481  *  pbOut [O] Destination
 482  *
 483  * RETURNS
 484  *  Success: S_OK.
 485  *  Failure: E_INVALIDARG, if the source value is invalid
 486  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 487  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 488  */
 489 HRESULT WINAPI VarUI1FromR4(FLOAT fltIn, BYTE* pbOut)
 490 {
 491   return _VarUI1FromR4(fltIn, pbOut);
 492 }
 493
 494 /************************************************************************
 495  * VarUI1FromR8 (OLEAUT32.133)
 496  *
 497  * Convert a VT_R8 to a VT_UI1.
 498  *
 499  * PARAMS
 500  *  dblIn [I] Source
 501  *  pbOut [O] Destination
 502  *
 503  * RETURNS
 504  *  Success: S_OK.
 505  *  Failure: E_INVALIDARG, if the source value is invalid
 506  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 507  *
 508  * NOTES
 509  *  See VarI8FromR8() for details concerning rounding.
 510  */
 511 HRESULT WINAPI VarUI1FromR8(double dblIn, BYTE* pbOut)
 512 {
 513   if (dblIn < -0.5 || dblIn > (double)UI1_MAX)
 514     return DISP_E_OVERFLOW;
 515   OLEAUT32_DutchRound(BYTE, dblIn, *pbOut);
 516   return S_OK;
 517 }
 518
 519 /************************************************************************
 520  * VarUI1FromCy (OLEAUT32.134)
 521  *
 522  * Convert a VT_CY to a VT_UI1.
 523  *
 524  * PARAMS
 525  *  cyIn     [I] Source
 526  *  pbOut [O] Destination
 527  *
 528  * RETURNS
 529  *  Success: S_OK.
 530  *  Failure: E_INVALIDARG, if the source value is invalid
 531  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 532  *
 533  * NOTES
 534  *  Negative values >= -5000 will be converted to 0.
 535  */
 536 HRESULT WINAPI VarUI1FromCy(CY cyIn, BYTE* pbOut)
 537 {
 538   ULONG i = UI1_MAX + 1;
 539
 540   _VarUI4FromCy(cyIn, &i);
 541   return _VarUI1FromUI4(i, pbOut);
 542 }
 543
 544 /************************************************************************
 545  * VarUI1FromDate (OLEAUT32.135)
 546  *
 547  * Convert a VT_DATE to a VT_UI1.
 548  *
 549  * PARAMS
 550  *  dateIn [I] Source
 551  *  pbOut  [O] Destination
 552  *
 553  * RETURNS
 554  *  Success: S_OK.
 555  *  Failure: E_INVALIDARG, if the source value is invalid
 556  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 557  */
 558 HRESULT WINAPI VarUI1FromDate(DATE dateIn, BYTE* pbOut)
 559 {
 560   return _VarUI1FromDate(dateIn, pbOut);
 561 }
 562
 563 /************************************************************************
 564  * VarUI1FromStr (OLEAUT32.136)
 565  *
 566  * Convert a VT_BSTR to a VT_UI1.
 567  *
 568  * PARAMS
 569  *  strIn   [I] Source
 570  *  lcid    [I] LCID for the conversion
 571  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
 572  *  pbOut   [O] Destination
 573  *
 574  * RETURNS
 575  *  Success: S_OK.
 576  *  Failure: E_INVALIDARG, if the source value is invalid
 577  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 578  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 579  */
 580 HRESULT WINAPI VarUI1FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, BYTE* pbOut)
 581 {
 582   return _VarUI1FromStr(strIn, lcid, dwFlags, pbOut);
 583 }
 584
 585 /************************************************************************
 586  * VarUI1FromDisp (OLEAUT32.137)
 587  *
 588  * Convert a VT_DISPATCH to a VT_UI1.
 589  *
 590  * PARAMS
 591  *  pdispIn [I] Source
 592  *  lcid    [I] LCID for conversion
 593  *  pbOut   [O] Destination
 594  *
 595  * RETURNS
 596  *  Success: S_OK.
 597  *  Failure: E_INVALIDARG, if the source value is invalid
 598  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 599  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 600  */
 601 HRESULT WINAPI VarUI1FromDisp(IDispatch* pdispIn, LCID lcid, BYTE* pbOut)
 602 {
 603   return _VarUI1FromDisp(pdispIn, lcid, pbOut);
 604 }
 605
 606 /************************************************************************
 607  * VarUI1FromBool (OLEAUT32.138)
 608  *
 609  * Convert a VT_BOOL to a VT_UI1.
 610  *
 611  * PARAMS
 612  *  boolIn [I] Source
 613  *  pbOut  [O] Destination
 614  *
 615  * RETURNS
 616  *  S_OK.
 617  */
 618 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL boolIn, BYTE* pbOut)
 619 {
 620   return _VarUI1FromBool(boolIn, pbOut);
 621 }
 622
 623 /************************************************************************
 624  * VarUI1FromI1 (OLEAUT32.237)
 625  *
 626  * Convert a VT_I1 to a VT_UI1.
 627  *
 628  * PARAMS
 629  *  cIn   [I] Source
 630  *  pbOut [O] Destination
 631  *
 632  * RETURNS
 633  *  Success: S_OK.
 634  *  Failure: E_INVALIDARG, if the source value is invalid
 635  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 636  */
 637 HRESULT WINAPI VarUI1FromI1(signed char cIn, BYTE* pbOut)
 638 {
 639   return _VarUI1FromI1(cIn, pbOut);
 640 }
 641
 642 /************************************************************************
 643  * VarUI1FromUI2 (OLEAUT32.238)
 644  *
 645  * Convert a VT_UI2 to a VT_UI1.
 646  *
 647  * PARAMS
 648  *  usIn  [I] Source
 649  *  pbOut [O] Destination
 650  *
 651  * RETURNS
 652  *  Success: S_OK.
 653  *  Failure: E_INVALIDARG, if the source value is invalid
 654  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 655  */
 656 HRESULT WINAPI VarUI1FromUI2(USHORT usIn, BYTE* pbOut)
 657 {
 658   return _VarUI1FromUI2(usIn, pbOut);
 659 }
 660
 661 /************************************************************************
 662  * VarUI1FromUI4 (OLEAUT32.239)
 663  *
 664  * Convert a VT_UI4 to a VT_UI1.
 665  *
 666  * PARAMS
 667  *  ulIn  [I] Source
 668  *  pbOut [O] Destination
 669  *
 670  * RETURNS
 671  *  Success: S_OK.
 672  *  Failure: E_INVALIDARG, if the source value is invalid
 673  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 674  */
 675 HRESULT WINAPI VarUI1FromUI4(ULONG ulIn, BYTE* pbOut)
 676 {
 677   return _VarUI1FromUI4(ulIn, pbOut);
 678 }
 679
 680 /************************************************************************
 681  * VarUI1FromDec (OLEAUT32.240)
 682  *
 683  * Convert a VT_DECIMAL to a VT_UI1.
 684  *
 685  * PARAMS
 686  *  pDecIn [I] Source
 687  *  pbOut  [O] Destination
 688  *
 689  * RETURNS
 690  *  Success: S_OK.
 691  *  Failure: E_INVALIDARG, if the source value is invalid
 692  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 693  */
 694 HRESULT WINAPI VarUI1FromDec(DECIMAL *pdecIn, BYTE* pbOut)
 695 {
 696   LONG64 i64;
 697   HRESULT hRet;
 698
 699   hRet = _VarI8FromDec(pdecIn, &i64);
 700
 701   if (SUCCEEDED(hRet))
 702     hRet = _VarUI1FromI8(i64, pbOut);
 703   return hRet;
 704 }
 705
 706 /************************************************************************
 707  * VarUI1FromI8 (OLEAUT32.372)
 708  *
 709  * Convert a VT_I8 to a VT_UI1.
 710  *
 711  * PARAMS
 712  *  llIn  [I] Source
 713  *  pbOut [O] Destination
 714  *
 715  * RETURNS
 716  *  Success: S_OK.
 717  *  Failure: E_INVALIDARG, if the source value is invalid
 718  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 719  */
 720 HRESULT WINAPI VarUI1FromI8(LONG64 llIn, BYTE* pbOut)
 721 {
 722   return _VarUI1FromI8(llIn, pbOut);
 723 }
 724
 725 /************************************************************************
 726  * VarUI1FromUI8 (OLEAUT32.373)
 727  *
 728  * Convert a VT_UI8 to a VT_UI1.
 729  *
 730  * PARAMS
 731  *  ullIn   [I] Source
 732  *  pbOut   [O] Destination
 733  *
 734  * RETURNS
 735  *  Success: S_OK.
 736  *  Failure: E_INVALIDARG, if the source value is invalid
 737  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 738  */
 739 HRESULT WINAPI VarUI1FromUI8(ULONG64 ullIn, BYTE* pbOut)
 740 {
 741   return _VarUI1FromUI8(ullIn, pbOut);
 742 }
 743
 744
 745 /* I2
 746  */
 747
 748 /************************************************************************
 749  * VarI2FromUI1 (OLEAUT32.48)
 750  *
 751  * Convert a VT_UI2 to a VT_I2.
 752  *
 753  * PARAMS
 754  *  bIn     [I] Source
 755  *  psOut   [O] Destination
 756  *
 757  * RETURNS
 758  *  S_OK.
 759  */
 760 HRESULT WINAPI VarI2FromUI1(BYTE bIn, SHORT* psOut)
 761 {
 762   return _VarI2FromUI1(bIn, psOut);
 763 }
 764
 765 /************************************************************************
 766  * VarI2FromI4 (OLEAUT32.49)
 767  *
 768  * Convert a VT_I4 to a VT_I2.
 769  *
 770  * PARAMS
 771  *  iIn     [I] Source
 772  *  psOut   [O] Destination
 773  *
 774  * RETURNS
 775  *  Success: S_OK.
 776  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 777  */
 778 HRESULT WINAPI VarI2FromI4(LONG iIn, SHORT* psOut)
 779 {
 780   return _VarI2FromI4(iIn, psOut);
 781 }
 782
 783 /************************************************************************
 784  * VarI2FromR4 (OLEAUT32.50)
 785  *
 786  * Convert a VT_R4 to a VT_I2.
 787  *
 788  * PARAMS
 789  *  fltIn   [I] Source
 790  *  psOut   [O] Destination
 791  *
 792  * RETURNS
 793  *  Success: S_OK.
 794  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 795  */
 796 HRESULT WINAPI VarI2FromR4(FLOAT fltIn, SHORT* psOut)
 797 {
 798   return _VarI2FromR4(fltIn, psOut);
 799 }
 800
 801 /************************************************************************
 802  * VarI2FromR8 (OLEAUT32.51)
 803  *
 804  * Convert a VT_R8 to a VT_I2.
 805  *
 806  * PARAMS
 807  *  dblIn   [I] Source
 808  *  psOut   [O] Destination
 809  *
 810  * RETURNS
 811  *  Success: S_OK.
 812  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 813  *
 814  * NOTES
 815  *  See VarI8FromR8() for details concerning rounding.
 816  */
 817 HRESULT WINAPI VarI2FromR8(double dblIn, SHORT* psOut)
 818 {
 819   if (dblIn < (double)I2_MIN || dblIn > (double)I2_MAX)
 820     return DISP_E_OVERFLOW;
 821   OLEAUT32_DutchRound(SHORT, dblIn, *psOut);
 822   return S_OK;
 823 }
 824
 825 /************************************************************************
 826  * VarI2FromCy (OLEAUT32.52)
 827  *
 828  * Convert a VT_CY to a VT_I2.
 829  *
 830  * PARAMS
 831  *  cyIn    [I] Source
 832  *  psOut   [O] Destination
 833  *
 834  * RETURNS
 835  *  Success: S_OK.
 836  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 837  */
 838 HRESULT WINAPI VarI2FromCy(CY cyIn, SHORT* psOut)
 839 {
 840   LONG i = I2_MAX + 1;
 841
 842   _VarI4FromCy(cyIn, &i);
 843   return _VarI2FromI4(i, psOut);
 844 }
 845
 846 /************************************************************************
 847  * VarI2FromDate (OLEAUT32.53)
 848  *
 849  * Convert a VT_DATE to a VT_I2.
 850  *
 851  * PARAMS
 852  *  dateIn  [I] Source
 853  *  psOut   [O] Destination
 854  *
 855  * RETURNS
 856  *  Success: S_OK.
 857  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 858  */
 859 HRESULT WINAPI VarI2FromDate(DATE dateIn, SHORT* psOut)
 860 {
 861   return _VarI2FromDate(dateIn, psOut);
 862 }
 863
 864 /************************************************************************
 865  * VarI2FromStr (OLEAUT32.54)
 866  *
 867  * Convert a VT_BSTR to a VT_I2.
 868  *
 869  * PARAMS
 870  *  strIn   [I] Source
 871  *  lcid    [I] LCID for the conversion
 872  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
 873  *  psOut   [O] Destination
 874  *
 875  * RETURNS
 876  *  Success: S_OK.
 877  *  Failure: E_INVALIDARG, if any parameter is invalid
 878  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 879  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 880  */
 881 HRESULT WINAPI VarI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, SHORT* psOut)
 882 {
 883   return _VarI2FromStr(strIn, lcid, dwFlags, psOut);
 884 }
 885
 886 /************************************************************************
 887  * VarI2FromDisp (OLEAUT32.55)
 888  *
 889  * Convert a VT_DISPATCH to a VT_I2.
 890  *
 891  * PARAMS
 892  *  pdispIn  [I] Source
 893  *  lcid     [I] LCID for conversion
 894  *  psOut    [O] Destination
 895  *
 896  * RETURNS
 897  *  Success: S_OK.
 898  *  Failure: E_INVALIDARG, if pdispIn is invalid,
 899  *           DISP_E_OVERFLOW, if the value will not fit in the destination,
 900  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
 901  */
 902 HRESULT WINAPI VarI2FromDisp(IDispatch* pdispIn, LCID lcid, SHORT* psOut)
 903 {
 904   return _VarI2FromDisp(pdispIn, lcid, psOut);
 905 }
 906
 907 /************************************************************************
 908  * VarI2FromBool (OLEAUT32.56)
 909  *
 910  * Convert a VT_BOOL to a VT_I2.
 911  *
 912  * PARAMS
 913  *  boolIn  [I] Source
 914  *  psOut   [O] Destination
 915  *
 916  * RETURNS
 917  *  S_OK.
 918  */
 919 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL boolIn, SHORT* psOut)
 920 {
 921   return _VarI2FromBool(boolIn, psOut);
 922 }
 923
 924 /************************************************************************
 925  * VarI2FromI1 (OLEAUT32.205)
 926  *
 927  * Convert a VT_I1 to a VT_I2.
 928  *
 929  * PARAMS
 930  *  cIn     [I] Source
 931  *  psOut   [O] Destination
 932  *
 933  * RETURNS
 934  *  S_OK.
 935  */
 936 HRESULT WINAPI VarI2FromI1(signed char cIn, SHORT* psOut)
 937 {
 938   return _VarI2FromI1(cIn, psOut);
 939 }
 940
 941 /************************************************************************
 942  * VarI2FromUI2 (OLEAUT32.206)
 943  *
 944  * Convert a VT_UI2 to a VT_I2.
 945  *
 946  * PARAMS
 947  *  usIn    [I] Source
 948  *  psOut   [O] Destination
 949  *
 950  * RETURNS
 951  *  Success: S_OK.
 952  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 953  */
 954 HRESULT WINAPI VarI2FromUI2(USHORT usIn, SHORT* psOut)
 955 {
 956   return _VarI2FromUI2(usIn, psOut);
 957 }
 958
 959 /************************************************************************
 960  * VarI2FromUI4 (OLEAUT32.207)
 961  *
 962  * Convert a VT_UI4 to a VT_I2.
 963  *
 964  * PARAMS
 965  *  ulIn    [I] Source
 966  *  psOut   [O] Destination
 967  *
 968  * RETURNS
 969  *  Success: S_OK.
 970  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
 971  */
 972 HRESULT WINAPI VarI2FromUI4(ULONG ulIn, SHORT* psOut)
 973 {
 974   return _VarI2FromUI4(ulIn, psOut);
 975 }
 976
 977 /************************************************************************
 978  * VarI2FromDec (OLEAUT32.208)
 979  *
 980  * Convert a VT_DECIMAL to a VT_I2.
 981  *
 982  * PARAMS
 983  *  pDecIn  [I] Source
 984  *  psOut   [O] Destination
 985  *
 986  * RETURNS
 987  *  Success: S_OK.
 988  *  Failure: E_INVALIDARG, if the source value is invalid
 989  *           DISP_E_OVERFLOW, if the value will not fit in the destination
 990  */
 991 HRESULT WINAPI VarI2FromDec(DECIMAL *pdecIn, SHORT* psOut)
 992 {
 993   LONG64 i64;
 994   HRESULT hRet;
 995
 996   hRet = _VarI8FromDec(pdecIn, &i64);
 997
 998   if (SUCCEEDED(hRet))
 999     hRet = _VarI2FromI8(i64, psOut);
1000   return hRet;
1001 }
1002
1003 /************************************************************************
1004  * VarI2FromI8 (OLEAUT32.346)
1005  *
1006  * Convert a VT_I8 to a VT_I2.
1007  *
1008  * PARAMS
1009  *  llIn  [I] Source
1010  *  psOut [O] Destination
1011  *
1012  * RETURNS
1013  *  Success: S_OK.
1014  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1015  */
1016 HRESULT WINAPI VarI2FromI8(LONG64 llIn, SHORT* psOut)
1017 {
1018   return _VarI2FromI8(llIn, psOut);
1019 }
1020
1021 /************************************************************************
1022  * VarI2FromUI8 (OLEAUT32.347)
1023  *
1024  * Convert a VT_UI8 to a VT_I2.
1025  *
1026  * PARAMS
1027  *  ullIn [I] Source
1028  *  psOut [O] Destination
1029  *
1030  * RETURNS
1031  *  Success: S_OK.
1032  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1033  */
1034 HRESULT WINAPI VarI2FromUI8(ULONG64 ullIn, SHORT* psOut)
1035 {
1036   return _VarI2FromUI8(ullIn, psOut);
1037 }
1038
1039 /* UI2
1040  */
1041
1042 /************************************************************************
1043  * VarUI2FromUI1 (OLEAUT32.257)
1044  *
1045  * Convert a VT_UI1 to a VT_UI2.
1046  *
1047  * PARAMS
1048  *  bIn    [I] Source
1049  *  pusOut [O] Destination
1050  *
1051  * RETURNS
1052  *  S_OK.
1053  */
1054 HRESULT WINAPI VarUI2FromUI1(BYTE bIn, USHORT* pusOut)
1055 {
1056   return _VarUI2FromUI1(bIn, pusOut);
1057 }
1058
1059 /************************************************************************
1060  * VarUI2FromI2 (OLEAUT32.258)
1061  *
1062  * Convert a VT_I2 to a VT_UI2.
1063  *
1064  * PARAMS
1065  *  sIn    [I] Source
1066  *  pusOut [O] Destination
1067  *
1068  * RETURNS
1069  *  Success: S_OK.
1070  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1071  */
1072 HRESULT WINAPI VarUI2FromI2(SHORT sIn, USHORT* pusOut)
1073 {
1074   return _VarUI2FromI2(sIn, pusOut);
1075 }
1076
1077 /************************************************************************
1078  * VarUI2FromI4 (OLEAUT32.259)
1079  *
1080  * Convert a VT_I4 to a VT_UI2.
1081  *
1082  * PARAMS
1083  *  iIn    [I] Source
1084  *  pusOut [O] Destination
1085  *
1086  * RETURNS
1087  *  Success: S_OK.
1088  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1089  */
1090 HRESULT WINAPI VarUI2FromI4(LONG iIn, USHORT* pusOut)
1091 {
1092   return _VarUI2FromI4(iIn, pusOut);
1093 }
1094
1095 /************************************************************************
1096  * VarUI2FromR4 (OLEAUT32.260)
1097  *
1098  * Convert a VT_R4 to a VT_UI2.
1099  *
1100  * PARAMS
1101  *  fltIn  [I] Source
1102  *  pusOut [O] Destination
1103  *
1104  * RETURNS
1105  *  Success: S_OK.
1106  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1107  */
1108 HRESULT WINAPI VarUI2FromR4(FLOAT fltIn, USHORT* pusOut)
1109 {
1110   return _VarUI2FromR4(fltIn, pusOut);
1111 }
1112
1113 /************************************************************************
1114  * VarUI2FromR8 (OLEAUT32.261)
1115  *
1116  * Convert a VT_R8 to a VT_UI2.
1117  *
1118  * PARAMS
1119  *  dblIn  [I] Source
1120  *  pusOut [O] Destination
1121  *
1122  * RETURNS
1123  *  Success: S_OK.
1124  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1125  *
1126  * NOTES
1127  *  See VarI8FromR8() for details concerning rounding.
1128  */
1129 HRESULT WINAPI VarUI2FromR8(double dblIn, USHORT* pusOut)
1130 {
1131   if (dblIn < -0.5 || dblIn > (double)UI2_MAX)
1132     return DISP_E_OVERFLOW;
1133   OLEAUT32_DutchRound(USHORT, dblIn, *pusOut);
1134   return S_OK;
1135 }
1136
1137 /************************************************************************
1138  * VarUI2FromDate (OLEAUT32.262)
1139  *
1140  * Convert a VT_DATE to a VT_UI2.
1141  *
1142  * PARAMS
1143  *  dateIn [I] Source
1144  *  pusOut [O] Destination
1145  *
1146  * RETURNS
1147  *  Success: S_OK.
1148  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1149  */
1150 HRESULT WINAPI VarUI2FromDate(DATE dateIn, USHORT* pusOut)
1151 {
1152   return _VarUI2FromDate(dateIn, pusOut);
1153 }
1154
1155 /************************************************************************
1156  * VarUI2FromCy (OLEAUT32.263)
1157  *
1158  * Convert a VT_CY to a VT_UI2.
1159  *
1160  * PARAMS
1161  *  cyIn   [I] Source
1162  *  pusOut [O] Destination
1163  *
1164  * RETURNS
1165  *  Success: S_OK.
1166  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1167  *
1168  * NOTES
1169  *  Negative values >= -5000 will be converted to 0.
1170  */
1171 HRESULT WINAPI VarUI2FromCy(CY cyIn, USHORT* pusOut)
1172 {
1173   ULONG i = UI2_MAX + 1;
1174
1175   _VarUI4FromCy(cyIn, &i);
1176   return _VarUI2FromUI4(i, pusOut);
1177 }
1178
1179 /************************************************************************
1180  * VarUI2FromStr (OLEAUT32.264)
1181  *
1182  * Convert a VT_BSTR to a VT_UI2.
1183  *
1184  * PARAMS
1185  *  strIn   [I] Source
1186  *  lcid    [I] LCID for the conversion
1187  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1188  *  pusOut  [O] Destination
1189  *
1190  * RETURNS
1191  *  Success: S_OK.
1192  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1193  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
1194  */
1195 HRESULT WINAPI VarUI2FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, USHORT* pusOut)
1196 {
1197   return _VarUI2FromStr(strIn, lcid, dwFlags, pusOut);
1198 }
1199
1200 /************************************************************************
1201  * VarUI2FromDisp (OLEAUT32.265)
1202  *
1203  * Convert a VT_DISPATCH to a VT_UI2.
1204  *
1205  * PARAMS
1206  *  pdispIn  [I] Source
1207  *  lcid     [I] LCID for conversion
1208  *  pusOut   [O] Destination
1209  *
1210  * RETURNS
1211  *  Success: S_OK.
1212  *  Failure: E_INVALIDARG, if the source value is invalid
1213  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1214  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
1215  */
1216 HRESULT WINAPI VarUI2FromDisp(IDispatch* pdispIn, LCID lcid, USHORT* pusOut)
1217 {
1218   return _VarUI2FromDisp(pdispIn, lcid, pusOut);
1219 }
1220
1221 /************************************************************************
1222  * VarUI2FromBool (OLEAUT32.266)
1223  *
1224  * Convert a VT_BOOL to a VT_UI2.
1225  *
1226  * PARAMS
1227  *  boolIn  [I] Source
1228  *  pusOut  [O] Destination
1229  *
1230  * RETURNS
1231  *  S_OK.
1232  */
1233 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL boolIn, USHORT* pusOut)
1234 {
1235   return _VarUI2FromBool(boolIn, pusOut);
1236 }
1237
1238 /************************************************************************
1239  * VarUI2FromI1 (OLEAUT32.267)
1240  *
1241  * Convert a VT_I1 to a VT_UI2.
1242  *
1243  * PARAMS
1244  *  cIn    [I] Source
1245  *  pusOut [O] Destination
1246  *
1247  * RETURNS
1248  *  Success: S_OK.
1249  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1250  */
1251 HRESULT WINAPI VarUI2FromI1(signed char cIn, USHORT* pusOut)
1252 {
1253   return _VarUI2FromI1(cIn, pusOut);
1254 }
1255
1256 /************************************************************************
1257  * VarUI2FromUI4 (OLEAUT32.268)
1258  *
1259  * Convert a VT_UI4 to a VT_UI2.
1260  *
1261  * PARAMS
1262  *  ulIn   [I] Source
1263  *  pusOut [O] Destination
1264  *
1265  * RETURNS
1266  *  Success: S_OK.
1267  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1268  */
1269 HRESULT WINAPI VarUI2FromUI4(ULONG ulIn, USHORT* pusOut)
1270 {
1271   return _VarUI2FromUI4(ulIn, pusOut);
1272 }
1273
1274 /************************************************************************
1275  * VarUI2FromDec (OLEAUT32.269)
1276  *
1277  * Convert a VT_DECIMAL to a VT_UI2.
1278  *
1279  * PARAMS
1280  *  pDecIn  [I] Source
1281  *  pusOut  [O] Destination
1282  *
1283  * RETURNS
1284  *  Success: S_OK.
1285  *  Failure: E_INVALIDARG, if the source value is invalid
1286  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1287  */
1288 HRESULT WINAPI VarUI2FromDec(DECIMAL *pdecIn, USHORT* pusOut)
1289 {
1290   LONG64 i64;
1291   HRESULT hRet;
1292
1293   hRet = _VarI8FromDec(pdecIn, &i64);
1294
1295   if (SUCCEEDED(hRet))
1296     hRet = _VarUI2FromI8(i64, pusOut);
1297   return hRet;
1298 }
1299
1300 /************************************************************************
1301  * VarUI2FromI8 (OLEAUT32.378)
1302  *
1303  * Convert a VT_I8 to a VT_UI2.
1304  *
1305  * PARAMS
1306  *  llIn   [I] Source
1307  *  pusOut [O] Destination
1308  *
1309  * RETURNS
1310  *  Success: S_OK.
1311  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1312  */
1313 HRESULT WINAPI VarUI2FromI8(LONG64 llIn, USHORT* pusOut)
1314 {
1315   return _VarUI2FromI8(llIn, pusOut);
1316 }
1317
1318 /************************************************************************
1319  * VarUI2FromUI8 (OLEAUT32.379)
1320  *
1321  * Convert a VT_UI8 to a VT_UI2.
1322  *
1323  * PARAMS
1324  *  ullIn    [I] Source
1325  *  pusOut   [O] Destination
1326  *
1327  * RETURNS
1328  *  Success: S_OK.
1329  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1330  */
1331 HRESULT WINAPI VarUI2FromUI8(ULONG64 ullIn, USHORT* pusOut)
1332 {
1333   return _VarUI2FromUI8(ullIn, pusOut);
1334 }
1335
1336 /* I4
1337  */
1338
1339 /************************************************************************
1340  * VarI4FromUI1 (OLEAUT32.58)
1341  *
1342  * Convert a VT_UI1 to a VT_I4.
1343  *
1344  * PARAMS
1345  *  bIn     [I] Source
1346  *  piOut   [O] Destination
1347  *
1348  * RETURNS
1349  *  S_OK.
1350  */
1351 HRESULT WINAPI VarI4FromUI1(BYTE bIn, LONG *piOut)
1352 {
1353   return _VarI4FromUI1(bIn, piOut);
1354 }
1355
1356 /************************************************************************
1357  * VarI4FromI2 (OLEAUT32.59)
1358  *
1359  * Convert a VT_I2 to a VT_I4.
1360  *
1361  * PARAMS
1362  *  sIn     [I] Source
1363  *  piOut   [O] Destination
1364  *
1365  * RETURNS
1366  *  Success: S_OK.
1367  *  Failure: E_INVALIDARG, if the source value is invalid
1368  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1369  */
1370 HRESULT WINAPI VarI4FromI2(SHORT sIn, LONG *piOut)
1371 {
1372   return _VarI4FromI2(sIn, piOut);
1373 }
1374
1375 /************************************************************************
1376  * VarI4FromR4 (OLEAUT32.60)
1377  *
1378  * Convert a VT_R4 to a VT_I4.
1379  *
1380  * PARAMS
1381  *  fltIn   [I] Source
1382  *  piOut   [O] Destination
1383  *
1384  * RETURNS
1385  *  Success: S_OK.
1386  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1387  */
1388 HRESULT WINAPI VarI4FromR4(FLOAT fltIn, LONG *piOut)
1389 {
1390   return _VarI4FromR4(fltIn, piOut);
1391 }
1392
1393 /************************************************************************
1394  * VarI4FromR8 (OLEAUT32.61)
1395  *
1396  * Convert a VT_R8 to a VT_I4.
1397  *
1398  * PARAMS
1399  *  dblIn   [I] Source
1400  *  piOut   [O] Destination
1401  *
1402  * RETURNS
1403  *  Success: S_OK.
1404  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1405  *
1406  * NOTES
1407  *  See VarI8FromR8() for details concerning rounding.
1408  */
1409 HRESULT WINAPI VarI4FromR8(double dblIn, LONG *piOut)
1410 {
1411   if (dblIn < (double)I4_MIN || dblIn > (double)I4_MAX)
1412     return DISP_E_OVERFLOW;
1413   OLEAUT32_DutchRound(LONG, dblIn, *piOut);
1414   return S_OK;
1415 }
1416
1417 /************************************************************************
1418  * VarI4FromCy (OLEAUT32.62)
1419  *
1420  * Convert a VT_CY to a VT_I4.
1421  *
1422  * PARAMS
1423  *  cyIn    [I] Source
1424  *  piOut   [O] Destination
1425  *
1426  * RETURNS
1427  *  Success: S_OK.
1428  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1429  */
1430 HRESULT WINAPI VarI4FromCy(CY cyIn, LONG *piOut)
1431 {
1432   double d = cyIn.int64 / CY_MULTIPLIER_F;
1433   return _VarI4FromR8(d, piOut);
1434 }
1435
1436 /************************************************************************
1437  * VarI4FromDate (OLEAUT32.63)
1438  *
1439  * Convert a VT_DATE to a VT_I4.
1440  *
1441  * PARAMS
1442  *  dateIn  [I] Source
1443  *  piOut   [O] Destination
1444  *
1445  * RETURNS
1446  *  Success: S_OK.
1447  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1448  */
1449 HRESULT WINAPI VarI4FromDate(DATE dateIn, LONG *piOut)
1450 {
1451   return _VarI4FromDate(dateIn, piOut);
1452 }
1453
1454 /************************************************************************
1455  * VarI4FromStr (OLEAUT32.64)
1456  *
1457  * Convert a VT_BSTR to a VT_I4.
1458  *
1459  * PARAMS
1460  *  strIn   [I] Source
1461  *  lcid    [I] LCID for the conversion
1462  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1463  *  piOut   [O] Destination
1464  *
1465  * RETURNS
1466  *  Success: S_OK.
1467  *  Failure: E_INVALIDARG, if any parameter is invalid
1468  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1469  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
1470  */
1471 HRESULT WINAPI VarI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
1472 {
1473   return _VarI4FromStr(strIn, lcid, dwFlags, piOut);
1474 }
1475
1476 /************************************************************************
1477  * VarI4FromDisp (OLEAUT32.65)
1478  *
1479  * Convert a VT_DISPATCH to a VT_I4.
1480  *
1481  * PARAMS
1482  *  pdispIn  [I] Source
1483  *  lcid     [I] LCID for conversion
1484  *  piOut    [O] Destination
1485  *
1486  * RETURNS
1487  *  Success: S_OK.
1488  *  Failure: E_INVALIDARG, if the source value is invalid
1489  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1490  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
1491  */
1492 HRESULT WINAPI VarI4FromDisp(IDispatch* pdispIn, LCID lcid, LONG *piOut)
1493 {
1494   return _VarI4FromDisp(pdispIn, lcid, piOut);
1495 }
1496
1497 /************************************************************************
1498  * VarI4FromBool (OLEAUT32.66)
1499  *
1500  * Convert a VT_BOOL to a VT_I4.
1501  *
1502  * PARAMS
1503  *  boolIn  [I] Source
1504  *  piOut   [O] Destination
1505  *
1506  * RETURNS
1507  *  S_OK.
1508  */
1509 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL boolIn, LONG *piOut)
1510 {
1511   return _VarI4FromBool(boolIn, piOut);
1512 }
1513
1514 /************************************************************************
1515  * VarI4FromI1 (OLEAUT32.209)
1516  *
1517  * Convert a VT_I4 to a VT_I4.
1518  *
1519  * PARAMS
1520  *  cIn     [I] Source
1521  *  piOut   [O] Destination
1522  *
1523  * RETURNS
1524  *  S_OK.
1525  */
1526 HRESULT WINAPI VarI4FromI1(signed char cIn, LONG *piOut)
1527 {
1528   return _VarI4FromI1(cIn, piOut);
1529 }
1530
1531 /************************************************************************
1532  * VarI4FromUI2 (OLEAUT32.210)
1533  *
1534  * Convert a VT_UI2 to a VT_I4.
1535  *
1536  * PARAMS
1537  *  usIn    [I] Source
1538  *  piOut   [O] Destination
1539  *
1540  * RETURNS
1541  *  S_OK.
1542  */
1543 HRESULT WINAPI VarI4FromUI2(USHORT usIn, LONG *piOut)
1544 {
1545   return _VarI4FromUI2(usIn, piOut);
1546 }
1547
1548 /************************************************************************
1549  * VarI4FromUI4 (OLEAUT32.211)
1550  *
1551  * Convert a VT_UI4 to a VT_I4.
1552  *
1553  * PARAMS
1554  *  ulIn    [I] Source
1555  *  piOut   [O] Destination
1556  *
1557  * RETURNS
1558  *  Success: S_OK.
1559  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1560  */
1561 HRESULT WINAPI VarI4FromUI4(ULONG ulIn, LONG *piOut)
1562 {
1563   return _VarI4FromUI4(ulIn, piOut);
1564 }
1565
1566 /************************************************************************
1567  * VarI4FromDec (OLEAUT32.212)
1568  *
1569  * Convert a VT_DECIMAL to a VT_I4.
1570  *
1571  * PARAMS
1572  *  pDecIn  [I] Source
1573  *  piOut   [O] Destination
1574  *
1575  * RETURNS
1576  *  Success: S_OK.
1577  *  Failure: E_INVALIDARG, if pdecIn is invalid
1578  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1579  */
1580 HRESULT WINAPI VarI4FromDec(DECIMAL *pdecIn, LONG *piOut)
1581 {
1582   LONG64 i64;
1583   HRESULT hRet;
1584
1585   hRet = _VarI8FromDec(pdecIn, &i64);
1586
1587   if (SUCCEEDED(hRet))
1588     hRet = _VarI4FromI8(i64, piOut);
1589   return hRet;
1590 }
1591
1592 /************************************************************************
1593  * VarI4FromI8 (OLEAUT32.348)
1594  *
1595  * Convert a VT_I8 to a VT_I4.
1596  *
1597  * PARAMS
1598  *  llIn  [I] Source
1599  *  piOut [O] Destination
1600  *
1601  * RETURNS
1602  *  Success: S_OK.
1603  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1604  */
1605 HRESULT WINAPI VarI4FromI8(LONG64 llIn, LONG *piOut)
1606 {
1607   return _VarI4FromI8(llIn, piOut);
1608 }
1609
1610 /************************************************************************
1611  * VarI4FromUI8 (OLEAUT32.349)
1612  *
1613  * Convert a VT_UI8 to a VT_I4.
1614  *
1615  * PARAMS
1616  *  ullIn [I] Source
1617  *  piOut [O] Destination
1618  *
1619  * RETURNS
1620  *  Success: S_OK.
1621  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1622  */
1623 HRESULT WINAPI VarI4FromUI8(ULONG64 ullIn, LONG *piOut)
1624 {
1625   return _VarI4FromUI8(ullIn, piOut);
1626 }
1627
1628 /* UI4
1629  */
1630
1631 /************************************************************************
1632  * VarUI4FromUI1 (OLEAUT32.270)
1633  *
1634  * Convert a VT_UI1 to a VT_UI4.
1635  *
1636  * PARAMS
1637  *  bIn    [I] Source
1638  *  pulOut [O] Destination
1639  *
1640  * RETURNS
1641  *  S_OK.
1642  */
1643 HRESULT WINAPI VarUI4FromUI1(BYTE bIn, ULONG *pulOut)
1644 {
1645   return _VarUI4FromUI1(bIn, pulOut);
1646 }
1647
1648 /************************************************************************
1649  * VarUI4FromI2 (OLEAUT32.271)
1650  *
1651  * Convert a VT_I2 to a VT_UI4.
1652  *
1653  * PARAMS
1654  *  sIn    [I] Source
1655  *  pulOut [O] Destination
1656  *
1657  * RETURNS
1658  *  Success: S_OK.
1659  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1660  */
1661 HRESULT WINAPI VarUI4FromI2(SHORT sIn, ULONG *pulOut)
1662 {
1663   return _VarUI4FromI2(sIn, pulOut);
1664 }
1665
1666 /************************************************************************
1667  * VarUI4FromI4 (OLEAUT32.272)
1668  *
1669  * Convert a VT_I4 to a VT_UI4.
1670  *
1671  * PARAMS
1672  *  iIn    [I] Source
1673  *  pulOut [O] Destination
1674  *
1675  * RETURNS
1676  *  Success: S_OK.
1677  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1678  */
1679 HRESULT WINAPI VarUI4FromI4(LONG iIn, ULONG *pulOut)
1680 {
1681   return _VarUI4FromI4(iIn, pulOut);
1682 }
1683
1684 /************************************************************************
1685  * VarUI4FromR4 (OLEAUT32.273)
1686  *
1687  * Convert a VT_R4 to a VT_UI4.
1688  *
1689  * PARAMS
1690  *  fltIn  [I] Source
1691  *  pulOut [O] Destination
1692  *
1693  * RETURNS
1694  *  Success: S_OK.
1695  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1696  */
1697 HRESULT WINAPI VarUI4FromR4(FLOAT fltIn, ULONG *pulOut)
1698 {
1699   return _VarUI4FromR4(fltIn, pulOut);
1700 }
1701
1702 /************************************************************************
1703  * VarUI4FromR8 (OLEAUT32.274)
1704  *
1705  * Convert a VT_R8 to a VT_UI4.
1706  *
1707  * PARAMS
1708  *  dblIn  [I] Source
1709  *  pulOut [O] Destination
1710  *
1711  * RETURNS
1712  *  Success: S_OK.
1713  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1714  *
1715  * NOTES
1716  *  See VarI8FromR8() for details concerning rounding.
1717  */
1718 HRESULT WINAPI VarUI4FromR8(double dblIn, ULONG *pulOut)
1719 {
1720   if (dblIn < -0.5 || dblIn > (double)UI4_MAX)
1721     return DISP_E_OVERFLOW;
1722   OLEAUT32_DutchRound(ULONG, dblIn, *pulOut);
1723   return S_OK;
1724 }
1725
1726 /************************************************************************
1727  * VarUI4FromDate (OLEAUT32.275)
1728  *
1729  * Convert a VT_DATE to a VT_UI4.
1730  *
1731  * PARAMS
1732  *  dateIn [I] Source
1733  *  pulOut [O] Destination
1734  *
1735  * RETURNS
1736  *  Success: S_OK.
1737  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1738  */
1739 HRESULT WINAPI VarUI4FromDate(DATE dateIn, ULONG *pulOut)
1740 {
1741   return _VarUI4FromDate(dateIn, pulOut);
1742 }
1743
1744 /************************************************************************
1745  * VarUI4FromCy (OLEAUT32.276)
1746  *
1747  * Convert a VT_CY to a VT_UI4.
1748  *
1749  * PARAMS
1750  *  cyIn   [I] Source
1751  *  pulOut [O] Destination
1752  *
1753  * RETURNS
1754  *  Success: S_OK.
1755  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1756  */
1757 HRESULT WINAPI VarUI4FromCy(CY cyIn, ULONG *pulOut)
1758 {
1759   double d = cyIn.int64 / CY_MULTIPLIER_F;
1760   return _VarUI4FromR8(d, pulOut);
1761 }
1762
1763 /************************************************************************
1764  * VarUI4FromStr (OLEAUT32.277)
1765  *
1766  * Convert a VT_BSTR to a VT_UI4.
1767  *
1768  * PARAMS
1769  *  strIn   [I] Source
1770  *  lcid    [I] LCID for the conversion
1771  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
1772  *  pulOut  [O] Destination
1773  *
1774  * RETURNS
1775  *  Success: S_OK.
1776  *  Failure: E_INVALIDARG, if any parameter is invalid
1777  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1778  *           DISP_E_TYPEMISMATCH, if strIn cannot be converted
1779  */
1780 HRESULT WINAPI VarUI4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
1781 {
1782   return _VarUI4FromStr(strIn, lcid, dwFlags, pulOut);
1783 }
1784
1785 /************************************************************************
1786  * VarUI4FromDisp (OLEAUT32.278)
1787  *
1788  * Convert a VT_DISPATCH to a VT_UI4.
1789  *
1790  * PARAMS
1791  *  pdispIn  [I] Source
1792  *  lcid     [I] LCID for conversion
1793  *  pulOut   [O] Destination
1794  *
1795  * RETURNS
1796  *  Success: S_OK.
1797  *  Failure: E_INVALIDARG, if the source value is invalid
1798  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1799  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
1800  */
1801 HRESULT WINAPI VarUI4FromDisp(IDispatch* pdispIn, LCID lcid, ULONG *pulOut)
1802 {
1803   return _VarUI4FromDisp(pdispIn, lcid, pulOut);
1804 }
1805
1806 /************************************************************************
1807  * VarUI4FromBool (OLEAUT32.279)
1808  *
1809  * Convert a VT_BOOL to a VT_UI4.
1810  *
1811  * PARAMS
1812  *  boolIn  [I] Source
1813  *  pulOut  [O] Destination
1814  *
1815  * RETURNS
1816  *  S_OK.
1817  */
1818 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL boolIn, ULONG *pulOut)
1819 {
1820   return _VarUI4FromBool(boolIn, pulOut);
1821 }
1822
1823 /************************************************************************
1824  * VarUI4FromI1 (OLEAUT32.280)
1825  *
1826  * Convert a VT_I1 to a VT_UI4.
1827  *
1828  * PARAMS
1829  *  cIn    [I] Source
1830  *  pulOut [O] Destination
1831  *
1832  * RETURNS
1833  *  Success: S_OK.
1834  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1835  */
1836 HRESULT WINAPI VarUI4FromI1(signed char cIn, ULONG *pulOut)
1837 {
1838   return _VarUI4FromI1(cIn, pulOut);
1839 }
1840
1841 /************************************************************************
1842  * VarUI4FromUI2 (OLEAUT32.281)
1843  *
1844  * Convert a VT_UI2 to a VT_UI4.
1845  *
1846  * PARAMS
1847  *  usIn   [I] Source
1848  *  pulOut [O] Destination
1849  *
1850  * RETURNS
1851  *  S_OK.
1852  */
1853 HRESULT WINAPI VarUI4FromUI2(USHORT usIn, ULONG *pulOut)
1854 {
1855   return _VarUI4FromUI2(usIn, pulOut);
1856 }
1857
1858 /************************************************************************
1859  * VarUI4FromDec (OLEAUT32.282)
1860  *
1861  * Convert a VT_DECIMAL to a VT_UI4.
1862  *
1863  * PARAMS
1864  *  pDecIn  [I] Source
1865  *  pulOut  [O] Destination
1866  *
1867  * RETURNS
1868  *  Success: S_OK.
1869  *  Failure: E_INVALIDARG, if pdecIn is invalid
1870  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1871  */
1872 HRESULT WINAPI VarUI4FromDec(DECIMAL *pdecIn, ULONG *pulOut)
1873 {
1874   LONG64 i64;
1875   HRESULT hRet;
1876
1877   hRet = _VarI8FromDec(pdecIn, &i64);
1878
1879   if (SUCCEEDED(hRet))
1880     hRet = _VarUI4FromI8(i64, pulOut);
1881   return hRet;
1882 }
1883
1884 /************************************************************************
1885  * VarUI4FromI8 (OLEAUT32.425)
1886  *
1887  * Convert a VT_I8 to a VT_UI4.
1888  *
1889  * PARAMS
1890  *  llIn   [I] Source
1891  *  pulOut [O] Destination
1892  *
1893  * RETURNS
1894  *  Success: S_OK.
1895  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1896  */
1897 HRESULT WINAPI VarUI4FromI8(LONG64 llIn, ULONG *pulOut)
1898 {
1899   return _VarUI4FromI8(llIn, pulOut);
1900 }
1901
1902 /************************************************************************
1903  * VarUI4FromUI8 (OLEAUT32.426)
1904  *
1905  * Convert a VT_UI8 to a VT_UI4.
1906  *
1907  * PARAMS
1908  *  ullIn    [I] Source
1909  *  pulOut   [O] Destination
1910  *
1911  * RETURNS
1912  *  Success: S_OK.
1913  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
1914  */
1915 HRESULT WINAPI VarUI4FromUI8(ULONG64 ullIn, ULONG *pulOut)
1916 {
1917   return _VarUI4FromUI8(ullIn, pulOut);
1918 }
1919
1920 /* I8
1921  */
1922
1923 /************************************************************************
1924  * VarI8FromUI1 (OLEAUT32.333)
1925  *
1926  * Convert a VT_UI1 to a VT_I8.
1927  *
1928  * PARAMS
1929  *  bIn     [I] Source
1930  *  pi64Out [O] Destination
1931  *
1932  * RETURNS
1933  *  S_OK.
1934  */
1935 HRESULT WINAPI VarI8FromUI1(BYTE bIn, LONG64* pi64Out)
1936 {
1937   return _VarI8FromUI1(bIn, pi64Out);
1938 }
1939
1940
1941 /************************************************************************
1942  * VarI8FromI2 (OLEAUT32.334)
1943  *
1944  * Convert a VT_I2 to a VT_I8.
1945  *
1946  * PARAMS
1947  *  sIn     [I] Source
1948  *  pi64Out [O] Destination
1949  *
1950  * RETURNS
1951  *  S_OK.
1952  */
1953 HRESULT WINAPI VarI8FromI2(SHORT sIn, LONG64* pi64Out)
1954 {
1955   return _VarI8FromI2(sIn, pi64Out);
1956 }
1957
1958 /************************************************************************
1959  * VarI8FromR4 (OLEAUT32.335)
1960  *
1961  * Convert a VT_R4 to a VT_I8.
1962  *
1963  * PARAMS
1964  *  fltIn   [I] Source
1965  *  pi64Out [O] Destination
1966  *
1967  * RETURNS
1968  *  Success: S_OK.
1969  *  Failure: E_INVALIDARG, if the source value is invalid
1970  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1971  */
1972 HRESULT WINAPI VarI8FromR4(FLOAT fltIn, LONG64* pi64Out)
1973 {
1974   return _VarI8FromR4(fltIn, pi64Out);
1975 }
1976
1977 /************************************************************************
1978  * VarI8FromR8 (OLEAUT32.336)
1979  *
1980  * Convert a VT_R8 to a VT_I8.
1981  *
1982  * PARAMS
1983  *  dblIn   [I] Source
1984  *  pi64Out [O] Destination
1985  *
1986  * RETURNS
1987  *  Success: S_OK.
1988  *  Failure: E_INVALIDARG, if the source value is invalid
1989  *           DISP_E_OVERFLOW, if the value will not fit in the destination
1990  *
1991  * NOTES
1992  *  Only values that fit into 63 bits are accepted. Due to rounding issues,
1993  *  very high or low values will not be accurately converted.
1994  *
1995  *  Numbers are rounded using Dutch rounding, as follows:
1996  *
1997  *|  Fractional Part   Sign  Direction  Example
1998  *|  ---------------   ----  ---------  -------
1999  *|  < 0.5              +    Down        0.4 ->  0.0
2000  *|  < 0.5              -    Up         -0.4 ->  0.0
2001  *|  > 0.5              +    Up          0.6 ->  1.0
2002  *|  < 0.5              -    Up         -0.6 -> -1.0
2003  *|  = 0.5              +    Up/Down    Down if even, Up if odd
2004  *|  = 0.5              -    Up/Down    Up if even, Down if odd
2005  *
2006  *  This system is often used in supermarkets.
2007  */
2008 HRESULT WINAPI VarI8FromR8(double dblIn, LONG64* pi64Out)
2009 {
2010   if ( dblIn < -4611686018427387904.0 || dblIn >= 4611686018427387904.0)
2011     return DISP_E_OVERFLOW;
2012   OLEAUT32_DutchRound(LONG64, dblIn, *pi64Out);
2013   return S_OK;
2014 }
2015
2016 /************************************************************************
2017  * VarI8FromCy (OLEAUT32.337)
2018  *
2019  * Convert a VT_CY to a VT_I8.
2020  *
2021  * PARAMS
2022  *  cyIn    [I] Source
2023  *  pi64Out [O] Destination
2024  *
2025  * RETURNS
2026  *  S_OK.
2027  *
2028  * NOTES
2029  *  All negative numbers are rounded down by 1, including those that are
2030  *  evenly divisible by 10000 (this is a Win32 bug that Wine mimics).
2031  *  Positive numbers are rounded using Dutch rounding: See VarI8FromR8()
2032  *  for details.
2033  */
2034 HRESULT WINAPI VarI8FromCy(CY cyIn, LONG64* pi64Out)
2035 {
2036   *pi64Out = cyIn.int64 / CY_MULTIPLIER;
2037
2038   if (cyIn.int64 < 0)
2039     (*pi64Out)--; /* Mimic Win32 bug */
2040   else
2041   {
2042     cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
2043
2044     if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pi64Out & 0x1)))
2045       (*pi64Out)++;
2046   }
2047   return S_OK;
2048 }
2049
2050 /************************************************************************
2051  * VarI8FromDate (OLEAUT32.338)
2052  *
2053  * Convert a VT_DATE to a VT_I8.
2054  *
2055  * PARAMS
2056  *  dateIn  [I] Source
2057  *  pi64Out [O] Destination
2058  *
2059  * RETURNS
2060  *  Success: S_OK.
2061  *  Failure: E_INVALIDARG, if the source value is invalid
2062  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2063  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2064  */
2065 HRESULT WINAPI VarI8FromDate(DATE dateIn, LONG64* pi64Out)
2066 {
2067   return _VarI8FromDate(dateIn, pi64Out);
2068 }
2069
2070 /************************************************************************
2071  * VarI8FromStr (OLEAUT32.339)
2072  *
2073  * Convert a VT_BSTR to a VT_I8.
2074  *
2075  * PARAMS
2076  *  strIn   [I] Source
2077  *  lcid    [I] LCID for the conversion
2078  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
2079  *  pi64Out [O] Destination
2080  *
2081  * RETURNS
2082  *  Success: S_OK.
2083  *  Failure: E_INVALIDARG, if the source value is invalid
2084  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2085  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2086  */
2087 HRESULT WINAPI VarI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, LONG64* pi64Out)
2088 {
2089   return _VarI8FromStr(strIn, lcid, dwFlags, pi64Out);
2090 }
2091
2092 /************************************************************************
2093  * VarI8FromDisp (OLEAUT32.340)
2094  *
2095  * Convert a VT_DISPATCH to a VT_I8.
2096  *
2097  * PARAMS
2098  *  pdispIn  [I] Source
2099  *  lcid     [I] LCID for conversion
2100  *  pi64Out  [O] Destination
2101  *
2102  * RETURNS
2103  *  Success: S_OK.
2104  *  Failure: E_INVALIDARG, if the source value is invalid
2105  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2106  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2107  */
2108 HRESULT WINAPI VarI8FromDisp(IDispatch* pdispIn, LCID lcid, LONG64* pi64Out)
2109 {
2110   return _VarI8FromDisp(pdispIn, lcid, pi64Out);
2111 }
2112
2113 /************************************************************************
2114  * VarI8FromBool (OLEAUT32.341)
2115  *
2116  * Convert a VT_BOOL to a VT_I8.
2117  *
2118  * PARAMS
2119  *  boolIn  [I] Source
2120  *  pi64Out [O] Destination
2121  *
2122  * RETURNS
2123  *  S_OK.
2124  */
2125 HRESULT WINAPI VarI8FromBool(VARIANT_BOOL boolIn, LONG64* pi64Out)
2126 {
2127   return _VarI8FromBool(boolIn, pi64Out);
2128 }
2129
2130 /************************************************************************
2131  * VarI8FromI1 (OLEAUT32.342)
2132  *
2133  * Convert a VT_I1 to a VT_I8.
2134  *
2135  * PARAMS
2136  *  cIn     [I] Source
2137  *  pi64Out [O] Destination
2138  *
2139  * RETURNS
2140  *  S_OK.
2141  */
2142 HRESULT WINAPI VarI8FromI1(signed char cIn, LONG64* pi64Out)
2143 {
2144   return _VarI8FromI1(cIn, pi64Out);
2145 }
2146
2147 /************************************************************************
2148  * VarI8FromUI2 (OLEAUT32.343)
2149  *
2150  * Convert a VT_UI2 to a VT_I8.
2151  *
2152  * PARAMS
2153  *  usIn    [I] Source
2154  *  pi64Out [O] Destination
2155  *
2156  * RETURNS
2157  *  S_OK.
2158  */
2159 HRESULT WINAPI VarI8FromUI2(USHORT usIn, LONG64* pi64Out)
2160 {
2161   return _VarI8FromUI2(usIn, pi64Out);
2162 }
2163
2164 /************************************************************************
2165  * VarI8FromUI4 (OLEAUT32.344)
2166  *
2167  * Convert a VT_UI4 to a VT_I8.
2168  *
2169  * PARAMS
2170  *  ulIn    [I] Source
2171  *  pi64Out [O] Destination
2172  *
2173  * RETURNS
2174  *  S_OK.
2175  */
2176 HRESULT WINAPI VarI8FromUI4(ULONG ulIn, LONG64* pi64Out)
2177 {
2178   return _VarI8FromUI4(ulIn, pi64Out);
2179 }
2180
2181 /************************************************************************
2182  * VarI8FromDec (OLEAUT32.345)
2183  *
2184  * Convert a VT_DECIMAL to a VT_I8.
2185  *
2186  * PARAMS
2187  *  pDecIn  [I] Source
2188  *  pi64Out [O] Destination
2189  *
2190  * RETURNS
2191  *  Success: S_OK.
2192  *  Failure: E_INVALIDARG, if the source value is invalid
2193  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2194  */
2195 HRESULT WINAPI VarI8FromDec(DECIMAL *pdecIn, LONG64* pi64Out)
2196 {
2197   if (!DEC_SCALE(pdecIn))
2198   {
2199     /* This decimal is just a 96 bit integer */
2200     if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
2201       return E_INVALIDARG;
2202
2203     if (DEC_HI32(pdecIn) || DEC_MID32(pdecIn) & 0x80000000)
2204       return DISP_E_OVERFLOW;
2205
2206     if (DEC_SIGN(pdecIn))
2207       *pi64Out = -DEC_LO64(pdecIn);
2208     else
2209       *pi64Out = DEC_LO64(pdecIn);
2210     return S_OK;
2211   }
2212   else
2213   {
2214     /* Decimal contains a floating point number */
2215     HRESULT hRet;
2216     double dbl;
2217
2218     hRet = _VarR8FromDec(pdecIn, &dbl);
2219     if (SUCCEEDED(hRet))
2220       hRet = VarI8FromR8(dbl, pi64Out);
2221     return hRet;
2222   }
2223 }
2224
2225 /************************************************************************
2226  * VarI8FromUI8 (OLEAUT32.427)
2227  *
2228  * Convert a VT_UI8 to a VT_I8.
2229  *
2230  * PARAMS
2231  *  ullIn   [I] Source
2232  *  pi64Out [O] Destination
2233  *
2234  * RETURNS
2235  *  Success: S_OK.
2236  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
2237  */
2238 HRESULT WINAPI VarI8FromUI8(ULONG64 ullIn, LONG64* pi64Out)
2239 {
2240   return _VarI8FromUI8(ullIn, pi64Out);
2241 }
2242
2243 /* UI8
2244  */
2245
2246 /************************************************************************
2247  * VarUI8FromI8 (OLEAUT32.428)
2248  *
2249  * Convert a VT_I8 to a VT_UI8.
2250  *
2251  * PARAMS
2252  *  ulIn     [I] Source
2253  *  pui64Out [O] Destination
2254  *
2255  * RETURNS
2256  *  Success: S_OK.
2257  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
2258  */
2259 HRESULT WINAPI VarUI8FromI8(LONG64 llIn, ULONG64* pui64Out)
2260 {
2261   return _VarUI8FromI8(llIn, pui64Out);
2262 }
2263
2264 /************************************************************************
2265  * VarUI8FromUI1 (OLEAUT32.429)
2266  *
2267  * Convert a VT_UI1 to a VT_UI8.
2268  *
2269  * PARAMS
2270  *  bIn      [I] Source
2271  *  pui64Out [O] Destination
2272  *
2273  * RETURNS
2274  *  S_OK.
2275  */
2276 HRESULT WINAPI VarUI8FromUI1(BYTE bIn, ULONG64* pui64Out)
2277 {
2278   return _VarUI8FromUI1(bIn, pui64Out);
2279 }
2280
2281 /************************************************************************
2282  * VarUI8FromI2 (OLEAUT32.430)
2283  *
2284  * Convert a VT_I2 to a VT_UI8.
2285  *
2286  * PARAMS
2287  *  sIn      [I] Source
2288  *  pui64Out [O] Destination
2289  *
2290  * RETURNS
2291  *  S_OK.
2292  */
2293 HRESULT WINAPI VarUI8FromI2(SHORT sIn, ULONG64* pui64Out)
2294 {
2295   return _VarUI8FromI2(sIn, pui64Out);
2296 }
2297
2298 /************************************************************************
2299  * VarUI8FromR4 (OLEAUT32.431)
2300  *
2301  * Convert a VT_R4 to a VT_UI8.
2302  *
2303  * PARAMS
2304  *  fltIn    [I] Source
2305  *  pui64Out [O] Destination
2306  *
2307  * RETURNS
2308  *  Success: S_OK.
2309  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
2310  */
2311 HRESULT WINAPI VarUI8FromR4(FLOAT fltIn, ULONG64* pui64Out)
2312 {
2313   return _VarUI8FromR4(fltIn, pui64Out);
2314 }
2315
2316 /************************************************************************
2317  * VarUI8FromR8 (OLEAUT32.432)
2318  *
2319  * Convert a VT_R8 to a VT_UI8.
2320  *
2321  * PARAMS
2322  *  dblIn    [I] Source
2323  *  pui64Out [O] Destination
2324  *
2325  * RETURNS
2326  *  Success: S_OK.
2327  *  Failure: E_INVALIDARG, if the source value is invalid
2328  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2329  *
2330  * NOTES
2331  *  See VarI8FromR8() for details concerning rounding.
2332  */
2333 HRESULT WINAPI VarUI8FromR8(double dblIn, ULONG64* pui64Out)
2334 {
2335   if (dblIn < -0.5 || dblIn > 1.844674407370955e19)
2336     return DISP_E_OVERFLOW;
2337   OLEAUT32_DutchRound(ULONG64, dblIn, *pui64Out);
2338   return S_OK;
2339 }
2340
2341 /************************************************************************
2342  * VarUI8FromCy (OLEAUT32.433)
2343  *
2344  * Convert a VT_CY to a VT_UI8.
2345  *
2346  * PARAMS
2347  *  cyIn     [I] Source
2348  *  pui64Out [O] Destination
2349  *
2350  * RETURNS
2351  *  Success: S_OK.
2352  *  Failure: E_INVALIDARG, if the source value is invalid
2353  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2354  *
2355  * NOTES
2356  *  Negative values >= -5000 will be converted to 0.
2357  */
2358 HRESULT WINAPI VarUI8FromCy(CY cyIn, ULONG64* pui64Out)
2359 {
2360   if (cyIn.int64 < 0)
2361   {
2362     if (cyIn.int64 < -CY_HALF)
2363       return DISP_E_OVERFLOW;
2364     *pui64Out = 0;
2365   }
2366   else
2367   {
2368     *pui64Out = cyIn.int64 / CY_MULTIPLIER;
2369
2370     cyIn.int64 -= *pui64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
2371
2372     if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pui64Out & 0x1)))
2373       (*pui64Out)++;
2374   }
2375   return S_OK;
2376 }
2377
2378 /************************************************************************
2379  * VarUI8FromDate (OLEAUT32.434)
2380  *
2381  * Convert a VT_DATE to a VT_UI8.
2382  *
2383  * PARAMS
2384  *  dateIn   [I] Source
2385  *  pui64Out [O] Destination
2386  *
2387  * RETURNS
2388  *  Success: S_OK.
2389  *  Failure: E_INVALIDARG, if the source value is invalid
2390  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2391  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2392  */
2393 HRESULT WINAPI VarUI8FromDate(DATE dateIn, ULONG64* pui64Out)
2394 {
2395   return _VarUI8FromDate(dateIn, pui64Out);
2396 }
2397
2398 /************************************************************************
2399  * VarUI8FromStr (OLEAUT32.435)
2400  *
2401  * Convert a VT_BSTR to a VT_UI8.
2402  *
2403  * PARAMS
2404  *  strIn    [I] Source
2405  *  lcid     [I] LCID for the conversion
2406  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
2407  *  pui64Out [O] Destination
2408  *
2409  * RETURNS
2410  *  Success: S_OK.
2411  *  Failure: E_INVALIDARG, if the source value is invalid
2412  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2413  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2414  */
2415 HRESULT WINAPI VarUI8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, ULONG64* pui64Out)
2416 {
2417   return _VarUI8FromStr(strIn, lcid, dwFlags, pui64Out);
2418 }
2419
2420 /************************************************************************
2421  * VarUI8FromDisp (OLEAUT32.436)
2422  *
2423  * Convert a VT_DISPATCH to a VT_UI8.
2424  *
2425  * PARAMS
2426  *  pdispIn   [I] Source
2427  *  lcid      [I] LCID for conversion
2428  *  pui64Out  [O] Destination
2429  *
2430  * RETURNS
2431  *  Success: S_OK.
2432  *  Failure: E_INVALIDARG, if the source value is invalid
2433  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2434  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2435  */
2436 HRESULT WINAPI VarUI8FromDisp(IDispatch* pdispIn, LCID lcid, ULONG64* pui64Out)
2437 {
2438   return _VarUI8FromDisp(pdispIn, lcid, pui64Out);
2439 }
2440
2441 /************************************************************************
2442  * VarUI8FromBool (OLEAUT32.437)
2443  *
2444  * Convert a VT_BOOL to a VT_UI8.
2445  *
2446  * PARAMS
2447  *  boolIn   [I] Source
2448  *  pui64Out [O] Destination
2449  *
2450  * RETURNS
2451  *  Success: S_OK.
2452  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
2453  */
2454 HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL boolIn, ULONG64* pui64Out)
2455 {
2456   return _VarUI8FromBool(boolIn, pui64Out);
2457 }
2458 /************************************************************************
2459  * VarUI8FromI1 (OLEAUT32.438)
2460  *
2461  * Convert a VT_I1 to a VT_UI8.
2462  *
2463  * PARAMS
2464  *  cIn      [I] Source
2465  *  pui64Out [O] Destination
2466  *
2467  * RETURNS
2468  *  Success: S_OK.
2469  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
2470  */
2471 HRESULT WINAPI VarUI8FromI1(signed char cIn, ULONG64* pui64Out)
2472 {
2473   return _VarUI8FromI1(cIn, pui64Out);
2474 }
2475
2476 /************************************************************************
2477  * VarUI8FromUI2 (OLEAUT32.439)
2478  *
2479  * Convert a VT_UI2 to a VT_UI8.
2480  *
2481  * PARAMS
2482  *  usIn     [I] Source
2483  *  pui64Out [O] Destination
2484  *
2485  * RETURNS
2486  *  S_OK.
2487  */
2488 HRESULT WINAPI VarUI8FromUI2(USHORT usIn, ULONG64* pui64Out)
2489 {
2490   return _VarUI8FromUI2(usIn, pui64Out);
2491 }
2492
2493 /************************************************************************
2494  * VarUI8FromUI4 (OLEAUT32.440)
2495  *
2496  * Convert a VT_UI4 to a VT_UI8.
2497  *
2498  * PARAMS
2499  *  ulIn     [I] Source
2500  *  pui64Out [O] Destination
2501  *
2502  * RETURNS
2503  *  S_OK.
2504  */
2505 HRESULT WINAPI VarUI8FromUI4(ULONG ulIn, ULONG64* pui64Out)
2506 {
2507   return _VarUI8FromUI4(ulIn, pui64Out);
2508 }
2509
2510 /************************************************************************
2511  * VarUI8FromDec (OLEAUT32.441)
2512  *
2513  * Convert a VT_DECIMAL to a VT_UI8.
2514  *
2515  * PARAMS
2516  *  pDecIn   [I] Source
2517  *  pui64Out [O] Destination
2518  *
2519  * RETURNS
2520  *  Success: S_OK.
2521  *  Failure: E_INVALIDARG, if the source value is invalid
2522  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2523  *
2524  * NOTES
2525  *  Under native Win32, if the source value has a scale of 0, its sign is
2526  *  ignored, i.e. this function takes the absolute value rather than fail
2527  *  with DISP_E_OVERFLOW. This bug has been fixed in Wine's implementation
2528  *  (use VarAbs() on pDecIn first if you really want this behaviour).
2529  */
2530 HRESULT WINAPI VarUI8FromDec(DECIMAL *pdecIn, ULONG64* pui64Out)
2531 {
2532   if (!DEC_SCALE(pdecIn))
2533   {
2534     /* This decimal is just a 96 bit integer */
2535     if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
2536       return E_INVALIDARG;
2537
2538     if (DEC_HI32(pdecIn))
2539       return DISP_E_OVERFLOW;
2540
2541     if (DEC_SIGN(pdecIn))
2542     {
2543       WARN("Sign would be ignored under Win32!\n");
2544       return DISP_E_OVERFLOW;
2545     }
2546
2547     *pui64Out = DEC_LO64(pdecIn);
2548     return S_OK;
2549   }
2550   else
2551   {
2552     /* Decimal contains a floating point number */
2553     HRESULT hRet;
2554     double dbl;
2555
2556     hRet = _VarR8FromDec(pdecIn, &dbl);
2557     if (SUCCEEDED(hRet))
2558       hRet = VarUI8FromR8(dbl, pui64Out);
2559     return hRet;
2560   }
2561 }
2562
2563 /* R4
2564  */
2565
2566 /************************************************************************
2567  * VarR4FromUI1 (OLEAUT32.68)
2568  *
2569  * Convert a VT_UI1 to a VT_R4.
2570  *
2571  * PARAMS
2572  *  bIn     [I] Source
2573  *  pFltOut [O] Destination
2574  *
2575  * RETURNS
2576  *  S_OK.
2577  */
2578 HRESULT WINAPI VarR4FromUI1(BYTE bIn, float *pFltOut)
2579 {
2580   return _VarR4FromUI1(bIn, pFltOut);
2581 }
2582
2583 /************************************************************************
2584  * VarR4FromI2 (OLEAUT32.69)
2585  *
2586  * Convert a VT_I2 to a VT_R4.
2587  *
2588  * PARAMS
2589  *  sIn     [I] Source
2590  *  pFltOut [O] Destination
2591  *
2592  * RETURNS
2593  *  S_OK.
2594  */
2595 HRESULT WINAPI VarR4FromI2(SHORT sIn, float *pFltOut)
2596 {
2597   return _VarR4FromI2(sIn, pFltOut);
2598 }
2599
2600 /************************************************************************
2601  * VarR4FromI4 (OLEAUT32.70)
2602  *
2603  * Convert a VT_I4 to a VT_R4.
2604  *
2605  * PARAMS
2606  *  sIn     [I] Source
2607  *  pFltOut [O] Destination
2608  *
2609  * RETURNS
2610  *  S_OK.
2611  */
2612 HRESULT WINAPI VarR4FromI4(LONG lIn, float *pFltOut)
2613 {
2614   return _VarR4FromI4(lIn, pFltOut);
2615 }
2616
2617 /************************************************************************
2618  * VarR4FromR8 (OLEAUT32.71)
2619  *
2620  * Convert a VT_R8 to a VT_R4.
2621  *
2622  * PARAMS
2623  *  dblIn   [I] Source
2624  *  pFltOut [O] Destination
2625  *
2626  * RETURNS
2627  *  Success: S_OK.
2628  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination.
2629  */
2630 HRESULT WINAPI VarR4FromR8(double dblIn, float *pFltOut)
2631 {
2632   return _VarR4FromR8(dblIn, pFltOut);
2633 }
2634
2635 /************************************************************************
2636  * VarR4FromCy (OLEAUT32.72)
2637  *
2638  * Convert a VT_CY to a VT_R4.
2639  *
2640  * PARAMS
2641  *  cyIn    [I] Source
2642  *  pFltOut [O] Destination
2643  *
2644  * RETURNS
2645  *  S_OK.
2646  */
2647 HRESULT WINAPI VarR4FromCy(CY cyIn, float *pFltOut)
2648 {
2649   return _VarR4FromCy(cyIn, pFltOut);
2650 }
2651
2652 /************************************************************************
2653  * VarR4FromDate (OLEAUT32.73)
2654  *
2655  * Convert a VT_DATE to a VT_R4.
2656  *
2657  * PARAMS
2658  *  dateIn  [I] Source
2659  *  pFltOut [O] Destination
2660  *
2661  * RETURNS
2662  *  Success: S_OK.
2663  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination.
2664  */
2665 HRESULT WINAPI VarR4FromDate(DATE dateIn, float *pFltOut)
2666 {
2667   return _VarR4FromDate(dateIn, pFltOut);
2668 }
2669
2670 /************************************************************************
2671  * VarR4FromStr (OLEAUT32.74)
2672  *
2673  * Convert a VT_BSTR to a VT_R4.
2674  *
2675  * PARAMS
2676  *  strIn   [I] Source
2677  *  lcid    [I] LCID for the conversion
2678  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
2679  *  pFltOut [O] Destination
2680  *
2681  * RETURNS
2682  *  Success: S_OK.
2683  *  Failure: E_INVALIDARG, if strIn or pFltOut is invalid.
2684  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2685  */
2686 HRESULT WINAPI VarR4FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
2687 {
2688   return _VarR4FromStr(strIn, lcid, dwFlags, pFltOut);
2689 }
2690
2691 /************************************************************************
2692  * VarR4FromDisp (OLEAUT32.75)
2693  *
2694  * Convert a VT_DISPATCH to a VT_R4.
2695  *
2696  * PARAMS
2697  *  pdispIn  [I] Source
2698  *  lcid     [I] LCID for conversion
2699  *  pFltOut  [O] Destination
2700  *
2701  * RETURNS
2702  *  Success: S_OK.
2703  *  Failure: E_INVALIDARG, if the source value is invalid
2704  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2705  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2706  */
2707 HRESULT WINAPI VarR4FromDisp(IDispatch* pdispIn, LCID lcid, float *pFltOut)
2708 {
2709   return _VarR4FromDisp(pdispIn, lcid, pFltOut);
2710 }
2711
2712 /************************************************************************
2713  * VarR4FromBool (OLEAUT32.76)
2714  *
2715  * Convert a VT_BOOL to a VT_R4.
2716  *
2717  * PARAMS
2718  *  boolIn  [I] Source
2719  *  pFltOut [O] Destination
2720  *
2721  * RETURNS
2722  *  S_OK.
2723  */
2724 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL boolIn, float *pFltOut)
2725 {
2726   return _VarR4FromBool(boolIn, pFltOut);
2727 }
2728
2729 /************************************************************************
2730  * VarR4FromI1 (OLEAUT32.213)
2731  *
2732  * Convert a VT_I1 to a VT_R4.
2733  *
2734  * PARAMS
2735  *  cIn     [I] Source
2736  *  pFltOut [O] Destination
2737  *
2738  * RETURNS
2739  *  Success: S_OK.
2740  *  Failure: E_INVALIDARG, if the source value is invalid
2741  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2742  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2743  */
2744 HRESULT WINAPI VarR4FromI1(signed char cIn, float *pFltOut)
2745 {
2746   return _VarR4FromI1(cIn, pFltOut);
2747 }
2748
2749 /************************************************************************
2750  * VarR4FromUI2 (OLEAUT32.214)
2751  *
2752  * Convert a VT_UI2 to a VT_R4.
2753  *
2754  * PARAMS
2755  *  usIn    [I] Source
2756  *  pFltOut [O] Destination
2757  *
2758  * RETURNS
2759  *  Success: S_OK.
2760  *  Failure: E_INVALIDARG, if the source value is invalid
2761  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2762  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2763  */
2764 HRESULT WINAPI VarR4FromUI2(USHORT usIn, float *pFltOut)
2765 {
2766   return _VarR4FromUI2(usIn, pFltOut);
2767 }
2768
2769 /************************************************************************
2770  * VarR4FromUI4 (OLEAUT32.215)
2771  *
2772  * Convert a VT_UI4 to a VT_R4.
2773  *
2774  * PARAMS
2775  *  ulIn    [I] Source
2776  *  pFltOut [O] Destination
2777  *
2778  * RETURNS
2779  *  Success: S_OK.
2780  *  Failure: E_INVALIDARG, if the source value is invalid
2781  *           DISP_E_OVERFLOW, if the value will not fit in the destination
2782  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
2783  */
2784 HRESULT WINAPI VarR4FromUI4(ULONG ulIn, float *pFltOut)
2785 {
2786   return _VarR4FromUI4(ulIn, pFltOut);
2787 }
2788
2789 /************************************************************************
2790  * VarR4FromDec (OLEAUT32.216)
2791  *
2792  * Convert a VT_DECIMAL to a VT_R4.
2793  *
2794  * PARAMS
2795  *  pDecIn  [I] Source
2796  *  pFltOut [O] Destination
2797  *
2798  * RETURNS
2799  *  Success: S_OK.
2800  *  Failure: E_INVALIDARG, if the source value is invalid.
2801  */
2802 HRESULT WINAPI VarR4FromDec(DECIMAL* pDecIn, float *pFltOut)
2803 {
2804   BYTE scale = DEC_SCALE(pDecIn);
2805   int divisor = 1;
2806   double highPart;
2807
2808   if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
2809     return E_INVALIDARG;
2810
2811   while (scale--)
2812     divisor *= 10;
2813
2814   if (DEC_SIGN(pDecIn))
2815     divisor = -divisor;
2816
2817   if (DEC_HI32(pDecIn))
2818   {
2819     highPart = (double)DEC_HI32(pDecIn) / (double)divisor;
2820     highPart *= 1.0e64;
2821   }
2822   else
2823     highPart = 0.0;
2824
2825   *pFltOut = (double)DEC_LO64(pDecIn) / (double)divisor + highPart;
2826   return S_OK;
2827 }
2828
2829 /************************************************************************
2830  * VarR4FromI8 (OLEAUT32.360)
2831  *
2832  * Convert a VT_I8 to a VT_R4.
2833  *
2834  * PARAMS
2835  *  ullIn   [I] Source
2836  *  pFltOut [O] Destination
2837  *
2838  * RETURNS
2839  *  S_OK.
2840  */
2841 HRESULT WINAPI VarR4FromI8(LONG64 llIn, float *pFltOut)
2842 {
2843   return _VarR4FromI8(llIn, pFltOut);
2844 }
2845
2846 /************************************************************************
2847  * VarR4FromUI8 (OLEAUT32.361)
2848  *
2849  * Convert a VT_UI8 to a VT_R4.
2850  *
2851  * PARAMS
2852  *  ullIn   [I] Source
2853  *  pFltOut [O] Destination
2854  *
2855  * RETURNS
2856  *  S_OK.
2857  */
2858 HRESULT WINAPI VarR4FromUI8(ULONG64 ullIn, float *pFltOut)
2859 {
2860   return _VarR4FromUI8(ullIn, pFltOut);
2861 }
2862
2863 /************************************************************************
2864  * VarR4CmpR8 (OLEAUT32.316)
2865  *
2866  * Compare a VT_R4 to a VT_R8.
2867  *
2868  * PARAMS
2869  *  fltLeft  [I] Source
2870  *  dblRight [I] Value to compare
2871  *
2872  * RETURNS
2873  *  VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that fltLeft is less than,
2874  *  equal to or greater than dblRight respectively.
2875  */
2876 HRESULT WINAPI VarR4CmpR8(float fltLeft, double dblRight)
2877 {
2878   if (fltLeft < dblRight)
2879     return VARCMP_LT;
2880   else if (fltLeft > dblRight)
2881     return VARCMP_GT;
2882   return VARCMP_EQ;
2883 }
2884
2885 /* R8
2886  */
2887
2888 /************************************************************************
2889  * VarR8FromUI1 (OLEAUT32.78)
2890  *
2891  * Convert a VT_UI1 to a VT_R8.
2892  *
2893  * PARAMS
2894  *  bIn     [I] Source
2895  *  pDblOut [O] Destination
2896  *
2897  * RETURNS
2898  *  S_OK.
2899  */
2900 HRESULT WINAPI VarR8FromUI1(BYTE bIn, double *pDblOut)
2901 {
2902   return _VarR8FromUI1(bIn, pDblOut);
2903 }
2904
2905 /************************************************************************
2906  * VarR8FromI2 (OLEAUT32.79)
2907  *
2908  * Convert a VT_I2 to a VT_R8.
2909  *
2910  * PARAMS
2911  *  sIn     [I] Source
2912  *  pDblOut [O] Destination
2913  *
2914  * RETURNS
2915  *  S_OK.
2916  */
2917 HRESULT WINAPI VarR8FromI2(SHORT sIn, double *pDblOut)
2918 {
2919   return _VarR8FromI2(sIn, pDblOut);
2920 }
2921
2922 /************************************************************************
2923  * VarR8FromI4 (OLEAUT32.80)
2924  *
2925  * Convert a VT_I4 to a VT_R8.
2926  *
2927  * PARAMS
2928  *  sIn     [I] Source
2929  *  pDblOut [O] Destination
2930  *
2931  * RETURNS
2932  *  S_OK.
2933  */
2934 HRESULT WINAPI VarR8FromI4(LONG lIn, double *pDblOut)
2935 {
2936   return _VarR8FromI4(lIn, pDblOut);
2937 }
2938
2939 /************************************************************************
2940  * VarR8FromR4 (OLEAUT32.81)
2941  *
2942  * Convert a VT_R4 to a VT_R8.
2943  *
2944  * PARAMS
2945  *  fltIn   [I] Source
2946  *  pDblOut [O] Destination
2947  *
2948  * RETURNS
2949  *  S_OK.
2950  */
2951 HRESULT WINAPI VarR8FromR4(FLOAT fltIn, double *pDblOut)
2952 {
2953   return _VarR8FromR4(fltIn, pDblOut);
2954 }
2955
2956 /************************************************************************
2957  * VarR8FromCy (OLEAUT32.82)
2958  *
2959  * Convert a VT_CY to a VT_R8.
2960  *
2961  * PARAMS
2962  *  cyIn    [I] Source
2963  *  pDblOut [O] Destination
2964  *
2965  * RETURNS
2966  *  S_OK.
2967  */
2968 HRESULT WINAPI VarR8FromCy(CY cyIn, double *pDblOut)
2969 {
2970   return _VarR8FromCy(cyIn, pDblOut);
2971 }
2972
2973 /************************************************************************
2974  * VarR8FromDate (OLEAUT32.83)
2975  *
2976  * Convert a VT_DATE to a VT_R8.
2977  *
2978  * PARAMS
2979  *  dateIn  [I] Source
2980  *  pDblOut [O] Destination
2981  *
2982  * RETURNS
2983  *  S_OK.
2984  */
2985 HRESULT WINAPI VarR8FromDate(DATE dateIn, double *pDblOut)
2986 {
2987   return _VarR8FromDate(dateIn, pDblOut);
2988 }
2989
2990 /************************************************************************
2991  * VarR8FromStr (OLEAUT32.84)
2992  *
2993  * Convert a VT_BSTR to a VT_R8.
2994  *
2995  * PARAMS
2996  *  strIn   [I] Source
2997  *  lcid    [I] LCID for the conversion
2998  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
2999  *  pDblOut [O] Destination
3000  *
3001  * RETURNS
3002  *  Success: S_OK.
3003  *  Failure: E_INVALIDARG, if strIn or pDblOut is invalid.
3004  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3005  */
3006 HRESULT WINAPI VarR8FromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
3007 {
3008   return _VarR8FromStr(strIn, lcid, dwFlags, pDblOut);
3009 }
3010
3011 /************************************************************************
3012  * VarR8FromDisp (OLEAUT32.85)
3013  *
3014  * Convert a VT_DISPATCH to a VT_R8.
3015  *
3016  * PARAMS
3017  *  pdispIn  [I] Source
3018  *  lcid     [I] LCID for conversion
3019  *  pDblOut  [O] Destination
3020  *
3021  * RETURNS
3022  *  Success: S_OK.
3023  *  Failure: E_INVALIDARG, if the source value is invalid
3024  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3025  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3026  */
3027 HRESULT WINAPI VarR8FromDisp(IDispatch* pdispIn, LCID lcid, double *pDblOut)
3028 {
3029   return _VarR8FromDisp(pdispIn, lcid, pDblOut);
3030 }
3031
3032 /************************************************************************
3033  * VarR8FromBool (OLEAUT32.86)
3034  *
3035  * Convert a VT_BOOL to a VT_R8.
3036  *
3037  * PARAMS
3038  *  boolIn  [I] Source
3039  *  pDblOut [O] Destination
3040  *
3041  * RETURNS
3042  *  S_OK.
3043  */
3044 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL boolIn, double *pDblOut)
3045 {
3046   return _VarR8FromBool(boolIn, pDblOut);
3047 }
3048
3049 /************************************************************************
3050  * VarR8FromI1 (OLEAUT32.217)
3051  *
3052  * Convert a VT_I1 to a VT_R8.
3053  *
3054  * PARAMS
3055  *  cIn     [I] Source
3056  *  pDblOut [O] Destination
3057  *
3058  * RETURNS
3059  *  Success: S_OK.
3060  *  Failure: E_INVALIDARG, if the source value is invalid
3061  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3062  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3063  */
3064 HRESULT WINAPI VarR8FromI1(signed char cIn, double *pDblOut)
3065 {
3066   return _VarR8FromI1(cIn, pDblOut);
3067 }
3068
3069 /************************************************************************
3070  * VarR8FromUI2 (OLEAUT32.218)
3071  *
3072  * Convert a VT_UI2 to a VT_R8.
3073  *
3074  * PARAMS
3075  *  usIn    [I] Source
3076  *  pDblOut [O] Destination
3077  *
3078  * RETURNS
3079  *  Success: S_OK.
3080  *  Failure: E_INVALIDARG, if the source value is invalid
3081  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3082  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3083  */
3084 HRESULT WINAPI VarR8FromUI2(USHORT usIn, double *pDblOut)
3085 {
3086   return _VarR8FromUI2(usIn, pDblOut);
3087 }
3088
3089 /************************************************************************
3090  * VarR8FromUI4 (OLEAUT32.219)
3091  *
3092  * Convert a VT_UI4 to a VT_R8.
3093  *
3094  * PARAMS
3095  *  ulIn    [I] Source
3096  *  pDblOut [O] Destination
3097  *
3098  * RETURNS
3099  *  Success: S_OK.
3100  *  Failure: E_INVALIDARG, if the source value is invalid
3101  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3102  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3103  */
3104 HRESULT WINAPI VarR8FromUI4(ULONG ulIn, double *pDblOut)
3105 {
3106   return _VarR8FromUI4(ulIn, pDblOut);
3107 }
3108
3109 /************************************************************************
3110  * VarR8FromDec (OLEAUT32.220)
3111  *
3112  * Convert a VT_DECIMAL to a VT_R8.
3113  *
3114  * PARAMS
3115  *  pDecIn  [I] Source
3116  *  pDblOut [O] Destination
3117  *
3118  * RETURNS
3119  *  Success: S_OK.
3120  *  Failure: E_INVALIDARG, if the source value is invalid.
3121  */
3122 HRESULT WINAPI VarR8FromDec(DECIMAL* pDecIn, double *pDblOut)
3123 {
3124   BYTE scale = DEC_SCALE(pDecIn);
3125   double divisor = 1.0, highPart;
3126
3127   if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
3128     return E_INVALIDARG;
3129
3130   while (scale--)
3131     divisor *= 10;
3132
3133   if (DEC_SIGN(pDecIn))
3134     divisor = -divisor;
3135
3136   if (DEC_HI32(pDecIn))
3137   {
3138     highPart = (double)DEC_HI32(pDecIn) / divisor;
3139     highPart *= 1.0e64;
3140   }
3141   else
3142     highPart = 0.0;
3143
3144   *pDblOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
3145   return S_OK;
3146 }
3147
3148 /************************************************************************
3149  * VarR8FromI8 (OLEAUT32.362)
3150  *
3151  * Convert a VT_I8 to a VT_R8.
3152  *
3153  * PARAMS
3154  *  ullIn   [I] Source
3155  *  pDblOut [O] Destination
3156  *
3157  * RETURNS
3158  *  S_OK.
3159  */
3160 HRESULT WINAPI VarR8FromI8(LONG64 llIn, double *pDblOut)
3161 {
3162   return _VarR8FromI8(llIn, pDblOut);
3163 }
3164
3165 /************************************************************************
3166  * VarR8FromUI8 (OLEAUT32.363)
3167  *
3168  * Convert a VT_UI8 to a VT_R8.
3169  *
3170  * PARAMS
3171  *  ullIn   [I] Source
3172  *  pDblOut [O] Destination
3173  *
3174  * RETURNS
3175  *  S_OK.
3176  */
3177 HRESULT WINAPI VarR8FromUI8(ULONG64 ullIn, double *pDblOut)
3178 {
3179   return _VarR8FromUI8(ullIn, pDblOut);
3180 }
3181
3182 /************************************************************************
3183  * VarR8Pow (OLEAUT32.315)
3184  *
3185  * Raise a VT_R8 to a power.
3186  *
3187  * PARAMS
3188  *  dblLeft [I] Source
3189  *  dblPow  [I] Power to raise dblLeft by
3190  *  pDblOut [O] Destination
3191  *
3192  * RETURNS
3193  *  S_OK. pDblOut contains dblLeft to the power of dblRight.
3194  */
3195 HRESULT WINAPI VarR8Pow(double dblLeft, double dblPow, double *pDblOut)
3196 {
3197   *pDblOut = pow(dblLeft, dblPow);
3198   return S_OK;
3199 }
3200
3201 /************************************************************************
3202  * VarR8Round (OLEAUT32.317)
3203  *
3204  * Round a VT_R8 to a given number of decimal points.
3205  *
3206  * PARAMS
3207  *  dblIn   [I] Source
3208  *  nDig    [I] Number of decimal points to round to
3209  *  pDblOut [O] Destination for rounded number
3210  *
3211  * RETURNS
3212  *  Success: S_OK. pDblOut is rounded to nDig digits.
3213  *  Failure: E_INVALIDARG, if cDecimals is less than 0.
3214  *
3215  * NOTES
3216  *  The native version of this function rounds using the internal
3217  *  binary representation of the number. Wine uses the dutch rounding
3218  *  convention, so therefore small differences can occur in the value returned.
3219  *  MSDN says that you should use your own rounding function if you want
3220  *  rounding to be predictable in your application.
3221  */
3222 HRESULT WINAPI VarR8Round(double dblIn, int nDig, double *pDblOut)
3223 {
3224   double scale, whole, fract;
3225
3226   if (nDig < 0)
3227     return E_INVALIDARG;
3228
3229   scale = pow(10.0, nDig);
3230
3231   dblIn *= scale;
3232   whole = dblIn < 0 ? ceil(dblIn) : floor(dblIn);
3233   fract = dblIn - whole;
3234
3235   if (fract > 0.5)
3236     dblIn = whole + 1.0;
3237   else if (fract == 0.5)
3238     dblIn = whole + fmod(whole, 2.0);
3239   else if (fract >= 0.0)
3240     dblIn = whole;
3241   else if (fract == -0.5)
3242     dblIn = whole - fmod(whole, 2.0);
3243   else if (fract > -0.5)
3244     dblIn = whole;
3245   else
3246     dblIn = whole - 1.0;
3247
3248   *pDblOut = dblIn / scale;
3249   return S_OK;
3250 }
3251
3252 /* CY
3253  */
3254
3255 /* Powers of 10 from 0..4 D.P. */
3256 static const int CY_Divisors[5] = { CY_MULTIPLIER/10000, CY_MULTIPLIER/1000,
3257   CY_MULTIPLIER/100, CY_MULTIPLIER/10, CY_MULTIPLIER };
3258
3259 /************************************************************************
3260  * VarCyFromUI1 (OLEAUT32.98)
3261  *
3262  * Convert a VT_UI1 to a VT_CY.
3263  *
3264  * PARAMS
3265  *  bIn    [I] Source
3266  *  pCyOut [O] Destination
3267  *
3268  * RETURNS
3269  *  Success: S_OK.
3270  *  Failure: E_INVALIDARG, if the source value is invalid
3271  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3272  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3273  */
3274 HRESULT WINAPI VarCyFromUI1(BYTE bIn, CY* pCyOut)
3275 {
3276   return _VarCyFromUI1(bIn, pCyOut);
3277 }
3278
3279 /************************************************************************
3280  * VarCyFromI2 (OLEAUT32.99)
3281  *
3282  * Convert a VT_I2 to a VT_CY.
3283  *
3284  * PARAMS
3285  *  sIn    [I] Source
3286  *  pCyOut [O] Destination
3287  *
3288  * RETURNS
3289  *  Success: S_OK.
3290  *  Failure: E_INVALIDARG, if the source value is invalid
3291  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3292  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3293  */
3294 HRESULT WINAPI VarCyFromI2(SHORT sIn, CY* pCyOut)
3295 {
3296   return _VarCyFromI2(sIn, pCyOut);
3297 }
3298
3299 /************************************************************************
3300  * VarCyFromI4 (OLEAUT32.100)
3301  *
3302  * Convert a VT_I4 to a VT_CY.
3303  *
3304  * PARAMS
3305  *  sIn    [I] Source
3306  *  pCyOut [O] Destination
3307  *
3308  * RETURNS
3309  *  Success: S_OK.
3310  *  Failure: E_INVALIDARG, if the source value is invalid
3311  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3312  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3313  */
3314 HRESULT WINAPI VarCyFromI4(LONG lIn, CY* pCyOut)
3315 {
3316   return _VarCyFromI4(lIn, pCyOut);
3317 }
3318
3319 /************************************************************************
3320  * VarCyFromR4 (OLEAUT32.101)
3321  *
3322  * Convert a VT_R4 to a VT_CY.
3323  *
3324  * PARAMS
3325  *  fltIn  [I] Source
3326  *  pCyOut [O] Destination
3327  *
3328  * RETURNS
3329  *  Success: S_OK.
3330  *  Failure: E_INVALIDARG, if the source value is invalid
3331  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3332  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3333  */
3334 HRESULT WINAPI VarCyFromR4(FLOAT fltIn, CY* pCyOut)
3335 {
3336   return _VarCyFromR4(fltIn, pCyOut);
3337 }
3338
3339 /************************************************************************
3340  * VarCyFromR8 (OLEAUT32.102)
3341  *
3342  * Convert a VT_R8 to a VT_CY.
3343  *
3344  * PARAMS
3345  *  dblIn  [I] Source
3346  *  pCyOut [O] Destination
3347  *
3348  * RETURNS
3349  *  Success: S_OK.
3350  *  Failure: E_INVALIDARG, if the source value is invalid
3351  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3352  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3353  */
3354 HRESULT WINAPI VarCyFromR8(double dblIn, CY* pCyOut)
3355 {
3356 #if defined(__GNUC__) && defined(__i386__)
3357   /* This code gives identical results to Win32 on Intel.
3358    * Here we use fp exceptions to catch overflows when storing the value.
3359    */
3360   static const unsigned short r8_fpcontrol = 0x137f;
3361   static const double r8_multiplier = CY_MULTIPLIER_F;
3362   unsigned short old_fpcontrol, result_fpstatus;
3363
3364   /* Clear exceptions, save the old fp state and load the new state */
3365   __asm__ __volatile__( "fnclex" );
3366   __asm__ __volatile__( "fstcw %0"   :   "=m" (old_fpcontrol) : );
3367   __asm__ __volatile__( "fldcw %0"   : : "m"  (r8_fpcontrol) );
3368   /* Perform the conversion. */
3369   __asm__ __volatile__( "fldl  %0"   : : "m"  (dblIn) );
3370   __asm__ __volatile__( "fmull %0"   : : "m"  (r8_multiplier) );
3371   __asm__ __volatile__( "fistpll %0" : : "m"  (*pCyOut) );
3372   /* Save the resulting fp state, load the old state and clear exceptions */
3373   __asm__ __volatile__( "fstsw %0"   :   "=m" (result_fpstatus) : );
3374   __asm__ __volatile__( "fnclex" );
3375   __asm__ __volatile__( "fldcw %0"   : : "m"  (old_fpcontrol) );
3376
3377   if (result_fpstatus & 0x9) /* Overflow | Invalid */
3378     return DISP_E_OVERFLOW;
3379   return S_OK;
3380 #else
3381   /* This version produces slightly different results for boundary cases */
3382   if (dblIn < -922337203685477.5807 || dblIn >= 922337203685477.5807)
3383     return DISP_E_OVERFLOW;
3384   dblIn *= CY_MULTIPLIER_F;
3385   OLEAUT32_DutchRound(LONG64, dblIn, pCyOut->int64);
3386 #endif
3387   return S_OK;
3388 }
3389
3390 /************************************************************************
3391  * VarCyFromDate (OLEAUT32.103)
3392  *
3393  * Convert a VT_DATE to a VT_CY.
3394  *
3395  * PARAMS
3396  *  dateIn [I] Source
3397  *  pCyOut [O] Destination
3398  *
3399  * RETURNS
3400  *  Success: S_OK.
3401  *  Failure: E_INVALIDARG, if the source value is invalid
3402  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3403  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3404  */
3405 HRESULT WINAPI VarCyFromDate(DATE dateIn, CY* pCyOut)
3406 {
3407   return _VarCyFromDate(dateIn, pCyOut);
3408 }
3409
3410 /************************************************************************
3411  * VarCyFromStr (OLEAUT32.104)
3412  *
3413  * Convert a VT_BSTR to a VT_CY.
3414  *
3415  * PARAMS
3416  *  strIn   [I] Source
3417  *  lcid    [I] LCID for the conversion
3418  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
3419  *  pCyOut  [O] Destination
3420  *
3421  * RETURNS
3422  *  Success: S_OK.
3423  *  Failure: E_INVALIDARG, if the source value is invalid
3424  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3425  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3426  */
3427 HRESULT WINAPI VarCyFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, CY* pCyOut)
3428 {
3429   return _VarCyFromStr(strIn, lcid, dwFlags, pCyOut);
3430 }
3431
3432 /************************************************************************
3433  * VarCyFromDisp (OLEAUT32.105)
3434  *
3435  * Convert a VT_DISPATCH to a VT_CY.
3436  *
3437  * PARAMS
3438  *  pdispIn [I] Source
3439  *  lcid    [I] LCID for conversion
3440  *  pCyOut  [O] Destination
3441  *
3442  * RETURNS
3443  *  Success: S_OK.
3444  *  Failure: E_INVALIDARG, if the source value is invalid
3445  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3446  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3447  */
3448 HRESULT WINAPI VarCyFromDisp(IDispatch* pdispIn, LCID lcid, CY* pCyOut)
3449 {
3450   return _VarCyFromDisp(pdispIn, lcid, pCyOut);
3451 }
3452
3453 /************************************************************************
3454  * VarCyFromBool (OLEAUT32.106)
3455  *
3456  * Convert a VT_BOOL to a VT_CY.
3457  *
3458  * PARAMS
3459  *  boolIn [I] Source
3460  *  pCyOut [O] Destination
3461  *
3462  * RETURNS
3463  *  Success: S_OK.
3464  *  Failure: E_INVALIDARG, if the source value is invalid
3465  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3466  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3467  *
3468  * NOTES
3469  *  While the sign of the boolean is stored in the currency, the value is
3470  *  converted to either 0 or 1.
3471  */
3472 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL boolIn, CY* pCyOut)
3473 {
3474   return _VarCyFromBool(boolIn, pCyOut);
3475 }
3476
3477 /************************************************************************
3478  * VarCyFromI1 (OLEAUT32.225)
3479  *
3480  * Convert a VT_I1 to a VT_CY.
3481  *
3482  * PARAMS
3483  *  cIn    [I] Source
3484  *  pCyOut [O] Destination
3485  *
3486  * RETURNS
3487  *  Success: S_OK.
3488  *  Failure: E_INVALIDARG, if the source value is invalid
3489  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3490  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3491  */
3492 HRESULT WINAPI VarCyFromI1(signed char cIn, CY* pCyOut)
3493 {
3494   return _VarCyFromI1(cIn, pCyOut);
3495 }
3496
3497 /************************************************************************
3498  * VarCyFromUI2 (OLEAUT32.226)
3499  *
3500  * Convert a VT_UI2 to a VT_CY.
3501  *
3502  * PARAMS
3503  *  usIn   [I] Source
3504  *  pCyOut [O] Destination
3505  *
3506  * RETURNS
3507  *  Success: S_OK.
3508  *  Failure: E_INVALIDARG, if the source value is invalid
3509  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3510  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3511  */
3512 HRESULT WINAPI VarCyFromUI2(USHORT usIn, CY* pCyOut)
3513 {
3514   return _VarCyFromUI2(usIn, pCyOut);
3515 }
3516
3517 /************************************************************************
3518  * VarCyFromUI4 (OLEAUT32.227)
3519  *
3520  * Convert a VT_UI4 to a VT_CY.
3521  *
3522  * PARAMS
3523  *  ulIn   [I] Source
3524  *  pCyOut [O] Destination
3525  *
3526  * RETURNS
3527  *  Success: S_OK.
3528  *  Failure: E_INVALIDARG, if the source value is invalid
3529  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3530  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3531  */
3532 HRESULT WINAPI VarCyFromUI4(ULONG ulIn, CY* pCyOut)
3533 {
3534   return _VarCyFromUI4(ulIn, pCyOut);
3535 }
3536
3537 /************************************************************************
3538  * VarCyFromDec (OLEAUT32.228)
3539  *
3540  * Convert a VT_DECIMAL to a VT_CY.
3541  *
3542  * PARAMS
3543  *  pdecIn  [I] Source
3544  *  pCyOut  [O] Destination
3545  *
3546  * RETURNS
3547  *  Success: S_OK.
3548  *  Failure: E_INVALIDARG, if the source value is invalid
3549  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3550  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3551  */
3552 HRESULT WINAPI VarCyFromDec(DECIMAL* pdecIn, CY* pCyOut)
3553 {
3554   DECIMAL rounded;
3555   HRESULT hRet;
3556
3557   hRet = VarDecRound(pdecIn, 4, &rounded);
3558
3559   if (SUCCEEDED(hRet))
3560   {
3561     double d;
3562
3563     if (DEC_HI32(&rounded))
3564       return DISP_E_OVERFLOW;
3565
3566     /* Note: Without the casts this promotes to int64 which loses precision */
3567     d = (double)DEC_LO64(&rounded) / (double)CY_Divisors[DEC_SCALE(&rounded)];
3568     if (DEC_SIGN(&rounded))
3569       d = -d;
3570     return _VarCyFromR8(d, pCyOut);
3571   }
3572   return hRet;
3573 }
3574
3575 /************************************************************************
3576  * VarCyFromI8 (OLEAUT32.366)
3577  *
3578  * Convert a VT_I8 to a VT_CY.
3579  *
3580  * PARAMS
3581  *  ullIn  [I] Source
3582  *  pCyOut [O] Destination
3583  *
3584  * RETURNS
3585  *  Success: S_OK.
3586  *  Failure: E_INVALIDARG, if the source value is invalid
3587  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3588  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3589  */
3590 HRESULT WINAPI VarCyFromI8(LONG64 llIn, CY* pCyOut)
3591 {
3592   return _VarCyFromI8(llIn, pCyOut);
3593 }
3594
3595 /************************************************************************
3596  * VarCyFromUI8 (OLEAUT32.375)
3597  *
3598  * Convert a VT_UI8 to a VT_CY.
3599  *
3600  * PARAMS
3601  *  ullIn  [I] Source
3602  *  pCyOut [O] Destination
3603  *
3604  * RETURNS
3605  *  Success: S_OK.
3606  *  Failure: E_INVALIDARG, if the source value is invalid
3607  *           DISP_E_OVERFLOW, if the value will not fit in the destination
3608  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
3609  */
3610 HRESULT WINAPI VarCyFromUI8(ULONG64 ullIn, CY* pCyOut)
3611 {
3612   return _VarCyFromUI8(ullIn, pCyOut);
3613 }
3614
3615 /************************************************************************
3616  * VarCyAdd (OLEAUT32.299)
3617  *
3618  * Add one CY to another.
3619  *
3620  * PARAMS
3621  *  cyLeft  [I] Source
3622  *  cyRight [I] Value to add
3623  *  pCyOut  [O] Destination
3624  *
3625  * RETURNS
3626  *  Success: S_OK.
3627  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3628  */
3629 HRESULT WINAPI VarCyAdd(const CY cyLeft, const CY cyRight, CY* pCyOut)
3630 {
3631   double l,r;
3632   _VarR8FromCy(cyLeft, &l);
3633   _VarR8FromCy(cyRight, &r);
3634   l = l + r;
3635   return _VarCyFromR8(l, pCyOut);
3636 }
3637
3638 /************************************************************************
3639  * VarCyMul (OLEAUT32.303)
3640  *
3641  * Multiply one CY by another.
3642  *
3643  * PARAMS
3644  *  cyLeft  [I] Source
3645  *  cyRight [I] Value to multiply by
3646  *  pCyOut  [O] Destination
3647  *
3648  * RETURNS
3649  *  Success: S_OK.
3650  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3651  */
3652 HRESULT WINAPI VarCyMul(const CY cyLeft, const CY cyRight, CY* pCyOut)
3653 {
3654   double l,r;
3655   _VarR8FromCy(cyLeft, &l);
3656   _VarR8FromCy(cyRight, &r);
3657   l = l * r;
3658   return _VarCyFromR8(l, pCyOut);
3659 }
3660
3661 /************************************************************************
3662  * VarCyMulI4 (OLEAUT32.304)
3663  *
3664  * Multiply one CY by a VT_I4.
3665  *
3666  * PARAMS
3667  *  cyLeft  [I] Source
3668  *  lRight  [I] Value to multiply by
3669  *  pCyOut  [O] Destination
3670  *
3671  * RETURNS
3672  *  Success: S_OK.
3673  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3674  */
3675 HRESULT WINAPI VarCyMulI4(const CY cyLeft, LONG lRight, CY* pCyOut)
3676 {
3677   double d;
3678
3679   _VarR8FromCy(cyLeft, &d);
3680   d = d * lRight;
3681   return _VarCyFromR8(d, pCyOut);
3682 }
3683
3684 /************************************************************************
3685  * VarCySub (OLEAUT32.305)
3686  *
3687  * Subtract one CY from another.
3688  *
3689  * PARAMS
3690  *  cyLeft  [I] Source
3691  *  cyRight [I] Value to subtract
3692  *  pCyOut  [O] Destination
3693  *
3694  * RETURNS
3695  *  Success: S_OK.
3696  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3697  */
3698 HRESULT WINAPI VarCySub(const CY cyLeft, const CY cyRight, CY* pCyOut)
3699 {
3700   double l,r;
3701   _VarR8FromCy(cyLeft, &l);
3702   _VarR8FromCy(cyRight, &r);
3703   l = l - r;
3704   return _VarCyFromR8(l, pCyOut);
3705 }
3706
3707 /************************************************************************
3708  * VarCyAbs (OLEAUT32.306)
3709  *
3710  * Convert a VT_CY into its absolute value.
3711  *
3712  * PARAMS
3713  *  cyIn   [I] Source
3714  *  pCyOut [O] Destination
3715  *
3716  * RETURNS
3717  *  Success: S_OK. pCyOut contains the absolute value.
3718  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3719  */
3720 HRESULT WINAPI VarCyAbs(const CY cyIn, CY* pCyOut)
3721 {
3722   if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
3723     return DISP_E_OVERFLOW;
3724
3725   pCyOut->int64 = cyIn.int64 < 0 ? -cyIn.int64 : cyIn.int64;
3726   return S_OK;
3727 }
3728
3729 /************************************************************************
3730  * VarCyFix (OLEAUT32.307)
3731  *
3732  * Return the integer part of a VT_CY.
3733  *
3734  * PARAMS
3735  *  cyIn   [I] Source
3736  *  pCyOut [O] Destination
3737  *
3738  * RETURNS
3739  *  Success: S_OK.
3740  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3741  *
3742  * NOTES
3743  *  - The difference between this function and VarCyInt() is that VarCyInt() rounds
3744  *    negative numbers away from 0, while this function rounds them towards zero.
3745  */
3746 HRESULT WINAPI VarCyFix(const CY cyIn, CY* pCyOut)
3747 {
3748   pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
3749   pCyOut->int64 *= CY_MULTIPLIER;
3750   return S_OK;
3751 }
3752
3753 /************************************************************************
3754  * VarCyInt (OLEAUT32.308)
3755  *
3756  * Return the integer part of a VT_CY.
3757  *
3758  * PARAMS
3759  *  cyIn   [I] Source
3760  *  pCyOut [O] Destination
3761  *
3762  * RETURNS
3763  *  Success: S_OK.
3764  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3765  *
3766  * NOTES
3767  *  - The difference between this function and VarCyFix() is that VarCyFix() rounds
3768  *    negative numbers towards 0, while this function rounds them away from zero.
3769  */
3770 HRESULT WINAPI VarCyInt(const CY cyIn, CY* pCyOut)
3771 {
3772   pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
3773   pCyOut->int64 *= CY_MULTIPLIER;
3774
3775   if (cyIn.int64 < 0 && cyIn.int64 % CY_MULTIPLIER != 0)
3776   {
3777     pCyOut->int64 -= CY_MULTIPLIER;
3778   }
3779   return S_OK;
3780 }
3781
3782 /************************************************************************
3783  * VarCyNeg (OLEAUT32.309)
3784  *
3785  * Change the sign of a VT_CY.
3786  *
3787  * PARAMS
3788  *  cyIn   [I] Source
3789  *  pCyOut [O] Destination
3790  *
3791  * RETURNS
3792  *  Success: S_OK.
3793  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3794  */
3795 HRESULT WINAPI VarCyNeg(const CY cyIn, CY* pCyOut)
3796 {
3797   if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
3798     return DISP_E_OVERFLOW;
3799
3800   pCyOut->int64 = -cyIn.int64;
3801   return S_OK;
3802 }
3803
3804 /************************************************************************
3805  * VarCyRound (OLEAUT32.310)
3806  *
3807  * Change the precision of a VT_CY.
3808  *
3809  * PARAMS
3810  *  cyIn      [I] Source
3811  *  cDecimals [I] New number of decimals to keep
3812  *  pCyOut    [O] Destination
3813  *
3814  * RETURNS
3815  *  Success: S_OK.
3816  *  Failure: E_INVALIDARG, if cDecimals is less than 0.
3817  */
3818 HRESULT WINAPI VarCyRound(const CY cyIn, int cDecimals, CY* pCyOut)
3819 {
3820   if (cDecimals < 0)
3821     return E_INVALIDARG;
3822
3823   if (cDecimals > 3)
3824   {
3825     /* Rounding to more precision than we have */
3826     *pCyOut = cyIn;
3827     return S_OK;
3828   }
3829   else
3830   {
3831     double d, div = CY_Divisors[cDecimals];
3832
3833     _VarR8FromCy(cyIn, &d);
3834     d = d * div;
3835     OLEAUT32_DutchRound(LONGLONG, d, pCyOut->int64)
3836     d = (double)pCyOut->int64 / div * CY_MULTIPLIER_F;
3837     OLEAUT32_DutchRound(LONGLONG, d, pCyOut->int64)
3838     return S_OK;
3839   }
3840 }
3841
3842 /************************************************************************
3843  * VarCyCmp (OLEAUT32.311)
3844  *
3845  * Compare two VT_CY values.
3846  *
3847  * PARAMS
3848  *  cyLeft  [I] Source
3849  *  cyRight [I] Value to compare
3850  *
3851  * RETURNS
3852  *  Success: VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that the value to
3853  *           compare is less, equal or greater than source respectively.
3854  *  Failure: DISP_E_OVERFLOW, if overflow occurs during the comparison
3855  */
3856 HRESULT WINAPI VarCyCmp(const CY cyLeft, const CY cyRight)
3857 {
3858   HRESULT hRet;
3859   CY result;
3860
3861   /* Subtract right from left, and compare the result to 0 */
3862   hRet = VarCySub(cyLeft, cyRight, &result);
3863
3864   if (SUCCEEDED(hRet))
3865   {
3866     if (result.int64 < 0)
3867       hRet = (HRESULT)VARCMP_LT;
3868     else if (result.int64 > 0)
3869       hRet = (HRESULT)VARCMP_GT;
3870     else
3871       hRet = (HRESULT)VARCMP_EQ;
3872   }
3873   return hRet;
3874 }
3875
3876 /************************************************************************
3877  * VarCyCmpR8 (OLEAUT32.312)
3878  *
3879  * Compare a VT_CY to a double
3880  *
3881  * PARAMS
3882  *  cyLeft   [I] Currency Source
3883  *  dblRight [I] double to compare to cyLeft
3884  *
3885  * RETURNS
3886  *  Success: VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that dblRight is
3887  *           less than, equal to or greater than cyLeft respectively.
3888  *  Failure: DISP_E_OVERFLOW, if overflow occurs during the comparison
3889  */
3890 HRESULT WINAPI VarCyCmpR8(const CY cyLeft, double dblRight)
3891 {
3892   HRESULT hRet;
3893   CY cyRight;
3894
3895   hRet = _VarCyFromR8(dblRight, &cyRight);
3896
3897   if (SUCCEEDED(hRet))
3898     hRet = VarCyCmp(cyLeft, cyRight);
3899
3900   return hRet;
3901 }
3902
3903 /************************************************************************
3904  * VarCyMulI8 (OLEAUT32.329)
3905  *
3906  * Multiply a VT_CY by a VT_I8.
3907  *
3908  * PARAMS
3909  *  cyLeft  [I] Source
3910  *  llRight [I] Value to multiply by
3911  *  pCyOut  [O] Destination
3912  *
3913  * RETURNS
3914  *  Success: S_OK.
3915  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
3916  */
3917 HRESULT WINAPI VarCyMulI8(const CY cyLeft, LONG64 llRight, CY* pCyOut)
3918 {
3919   double d;
3920
3921   _VarR8FromCy(cyLeft, &d);
3922   d = d  * (double)llRight;
3923   return _VarCyFromR8(d, pCyOut);
3924 }
3925
3926 /* DECIMAL
3927  */
3928
3929 /************************************************************************
3930  * VarDecFromUI1 (OLEAUT32.190)
3931  *
3932  * Convert a VT_UI1 to a DECIMAL.
3933  *
3934  * PARAMS
3935  *  bIn     [I] Source
3936  *  pDecOut [O] Destination
3937  *
3938  * RETURNS
3939  *  S_OK.
3940  */
3941 HRESULT WINAPI VarDecFromUI1(BYTE bIn, DECIMAL* pDecOut)
3942 {
3943   return _VarDecFromUI1(bIn, pDecOut);
3944 }
3945
3946 /************************************************************************
3947  * VarDecFromI2 (OLEAUT32.191)
3948  *
3949  * Convert a VT_I2 to a DECIMAL.
3950  *
3951  * PARAMS
3952  *  sIn     [I] Source
3953  *  pDecOut [O] Destination
3954  *
3955  * RETURNS
3956  *  S_OK.
3957  */
3958 HRESULT WINAPI VarDecFromI2(SHORT sIn, DECIMAL* pDecOut)
3959 {
3960   return _VarDecFromI2(sIn, pDecOut);
3961 }
3962
3963 /************************************************************************
3964  * VarDecFromI4 (OLEAUT32.192)
3965  *
3966  * Convert a VT_I4 to a DECIMAL.
3967  *
3968  * PARAMS
3969  *  sIn     [I] Source
3970  *  pDecOut [O] Destination
3971  *
3972  * RETURNS
3973  *  S_OK.
3974  */
3975 HRESULT WINAPI VarDecFromI4(LONG lIn, DECIMAL* pDecOut)
3976 {
3977   DEC_HI32(pDecOut) = 0;
3978   DEC_MID32(pDecOut) = 0;
3979
3980   if (lIn < 0)
3981   {
3982     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
3983     DEC_LO32(pDecOut) = -lIn;
3984   }
3985   else
3986   {
3987     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
3988     DEC_LO32(pDecOut) = lIn;
3989   }
3990   return S_OK;
3991 }
3992
3993 #define LOCALE_EN_US            (MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT))
3994
3995 /************************************************************************
3996  * VarDecFromR4 (OLEAUT32.193)
3997  *
3998  * Convert a VT_R4 to a DECIMAL.
3999  *
4000  * PARAMS
4001  *  fltIn   [I] Source
4002  *  pDecOut [O] Destination
4003  *
4004  * RETURNS
4005  *  S_OK.
4006  */
4007 HRESULT WINAPI VarDecFromR4(FLOAT fltIn, DECIMAL* pDecOut)
4008 {
4009   WCHAR buff[256];
4010
4011   sprintfW( buff, szFloatFormatW, fltIn );
4012   return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
4013 }
4014
4015 /************************************************************************
4016  * VarDecFromR8 (OLEAUT32.194)
4017  *
4018  * Convert a VT_R8 to a DECIMAL.
4019  *
4020  * PARAMS
4021  *  dblIn   [I] Source
4022  *  pDecOut [O] Destination
4023  *
4024  * RETURNS
4025  *  S_OK.
4026  */
4027 HRESULT WINAPI VarDecFromR8(double dblIn, DECIMAL* pDecOut)
4028 {
4029   WCHAR buff[256];
4030
4031   sprintfW( buff, szDoubleFormatW, dblIn );
4032   return _VarDecFromStr(buff, LOCALE_EN_US, 0, pDecOut);
4033 }
4034
4035 /************************************************************************
4036  * VarDecFromDate (OLEAUT32.195)
4037  *
4038  * Convert a VT_DATE to a DECIMAL.
4039  *
4040  * PARAMS
4041  *  dateIn  [I] Source
4042  *  pDecOut [O] Destination
4043  *
4044  * RETURNS
4045  *  S_OK.
4046  */
4047 HRESULT WINAPI VarDecFromDate(DATE dateIn, DECIMAL* pDecOut)
4048 {
4049   return _VarDecFromDate(dateIn, pDecOut);
4050 }
4051
4052 /************************************************************************
4053  * VarDecFromCy (OLEAUT32.196)
4054  *
4055  * Convert a VT_CY to a DECIMAL.
4056  *
4057  * PARAMS
4058  *  cyIn    [I] Source
4059  *  pDecOut [O] Destination
4060  *
4061  * RETURNS
4062  *  S_OK.
4063  */
4064 HRESULT WINAPI VarDecFromCy(CY cyIn, DECIMAL* pDecOut)
4065 {
4066   DEC_HI32(pDecOut) = 0;
4067
4068   /* Note: This assumes 2s complement integer representation */
4069   if (cyIn.s.Hi & 0x80000000)
4070   {
4071     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,4);
4072     DEC_LO64(pDecOut) = -cyIn.int64;
4073   }
4074   else
4075   {
4076     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,4);
4077     DEC_MID32(pDecOut) = cyIn.s.Hi;
4078     DEC_LO32(pDecOut) = cyIn.s.Lo;
4079   }
4080   return S_OK;
4081 }
4082
4083 /************************************************************************
4084  * VarDecFromStr (OLEAUT32.197)
4085  *
4086  * Convert a VT_BSTR to a DECIMAL.
4087  *
4088  * PARAMS
4089  *  strIn   [I] Source
4090  *  lcid    [I] LCID for the conversion
4091  *  dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
4092  *  pDecOut [O] Destination
4093  *
4094  * RETURNS
4095  *  Success: S_OK.
4096  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4097  */
4098 HRESULT WINAPI VarDecFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DECIMAL* pDecOut)
4099 {
4100   return _VarDecFromStr(strIn, lcid, dwFlags, pDecOut);
4101 }
4102
4103 /************************************************************************
4104  * VarDecFromDisp (OLEAUT32.198)
4105  *
4106  * Convert a VT_DISPATCH to a DECIMAL.
4107  *
4108  * PARAMS
4109  *  pdispIn  [I] Source
4110  *  lcid     [I] LCID for conversion
4111  *  pDecOut  [O] Destination
4112  *
4113  * RETURNS
4114  *  Success: S_OK.
4115  *  Failure: DISP_E_TYPEMISMATCH, if the type cannot be converted
4116  */
4117 HRESULT WINAPI VarDecFromDisp(IDispatch* pdispIn, LCID lcid, DECIMAL* pDecOut)
4118 {
4119   return _VarDecFromDisp(pdispIn, lcid, pDecOut);
4120 }
4121
4122 /************************************************************************
4123  * VarDecFromBool (OLEAUT32.199)
4124  *
4125  * Convert a VT_BOOL to a DECIMAL.
4126  *
4127  * PARAMS
4128  *  bIn     [I] Source
4129  *  pDecOut [O] Destination
4130  *
4131  * RETURNS
4132  *  S_OK.
4133  *
4134  * NOTES
4135  *  The value is converted to either 0 (if bIn is FALSE) or -1 (TRUE).
4136  */
4137 HRESULT WINAPI VarDecFromBool(VARIANT_BOOL bIn, DECIMAL* pDecOut)
4138 {
4139   DEC_HI32(pDecOut) = 0;
4140   DEC_MID32(pDecOut) = 0;
4141   if (bIn)
4142   {
4143     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
4144     DEC_LO32(pDecOut) = 1;
4145   }
4146   else
4147   {
4148     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
4149     DEC_LO32(pDecOut) = 0;
4150   }
4151   return S_OK;
4152 }
4153
4154 /************************************************************************
4155  * VarDecFromI1 (OLEAUT32.241)
4156  *
4157  * Convert a VT_I1 to a DECIMAL.
4158  *
4159  * PARAMS
4160  *  cIn     [I] Source
4161  *  pDecOut [O] Destination
4162  *
4163  * RETURNS
4164  *  S_OK.
4165  */
4166 HRESULT WINAPI VarDecFromI1(signed char cIn, DECIMAL* pDecOut)
4167 {
4168   return _VarDecFromI1(cIn, pDecOut);
4169 }
4170
4171 /************************************************************************
4172  * VarDecFromUI2 (OLEAUT32.242)
4173  *
4174  * Convert a VT_UI2 to a DECIMAL.
4175  *
4176  * PARAMS
4177  *  usIn    [I] Source
4178  *  pDecOut [O] Destination
4179  *
4180  * RETURNS
4181  *  S_OK.
4182  */
4183 HRESULT WINAPI VarDecFromUI2(USHORT usIn, DECIMAL* pDecOut)
4184 {
4185   return _VarDecFromUI2(usIn, pDecOut);
4186 }
4187
4188 /************************************************************************
4189  * VarDecFromUI4 (OLEAUT32.243)
4190  *
4191  * Convert a VT_UI4 to a DECIMAL.
4192  *
4193  * PARAMS
4194  *  ulIn    [I] Source
4195  *  pDecOut [O] Destination
4196  *
4197  * RETURNS
4198  *  S_OK.
4199  */
4200 HRESULT WINAPI VarDecFromUI4(ULONG ulIn, DECIMAL* pDecOut)
4201 {
4202   DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
4203   DEC_HI32(pDecOut) = 0;
4204   DEC_MID32(pDecOut) = 0;
4205   DEC_LO32(pDecOut) = ulIn;
4206   return S_OK;
4207 }
4208
4209 /************************************************************************
4210  * VarDecFromI8 (OLEAUT32.374)
4211  *
4212  * Convert a VT_I8 to a DECIMAL.
4213  *
4214  * PARAMS
4215  *  llIn    [I] Source
4216  *  pDecOut [O] Destination
4217  *
4218  * RETURNS
4219  *  S_OK.
4220  */
4221 HRESULT WINAPI VarDecFromI8(LONG64 llIn, DECIMAL* pDecOut)
4222 {
4223   PULARGE_INTEGER pLi = (PULARGE_INTEGER)&llIn;
4224
4225   DEC_HI32(pDecOut) = 0;
4226
4227   /* Note: This assumes 2s complement integer representation */
4228   if (pLi->u.HighPart & 0x80000000)
4229   {
4230     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
4231     DEC_LO64(pDecOut) = -pLi->QuadPart;
4232   }
4233   else
4234   {
4235     DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
4236     DEC_MID32(pDecOut) = pLi->u.HighPart;
4237     DEC_LO32(pDecOut) = pLi->u.LowPart;
4238   }
4239   return S_OK;
4240 }
4241
4242 /************************************************************************
4243  * VarDecFromUI8 (OLEAUT32.375)
4244  *
4245  * Convert a VT_UI8 to a DECIMAL.
4246  *
4247  * PARAMS
4248  *  ullIn   [I] Source
4249  *  pDecOut [O] Destination
4250  *
4251  * RETURNS
4252  *  S_OK.
4253  */
4254 HRESULT WINAPI VarDecFromUI8(ULONG64 ullIn, DECIMAL* pDecOut)
4255 {
4256   DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
4257   DEC_HI32(pDecOut) = 0;
4258   DEC_LO64(pDecOut) = ullIn;
4259   return S_OK;
4260 }
4261
4262 /* Make two DECIMALS the same scale; used by math functions below */
4263 static HRESULT VARIANT_DecScale(const DECIMAL** ppDecLeft,
4264                                 const DECIMAL** ppDecRight,
4265                                 DECIMAL* pDecOut)
4266 {
4267   static DECIMAL scaleFactor;
4268   DECIMAL decTemp;
4269   int scaleAmount, i;
4270   HRESULT hRet = S_OK;
4271
4272   if (DEC_SIGN(*ppDecLeft) & ~DECIMAL_NEG || DEC_SIGN(*ppDecRight) & ~DECIMAL_NEG)
4273     return E_INVALIDARG;
4274
4275   DEC_LO32(&scaleFactor) = 10;
4276
4277   i = scaleAmount = DEC_SCALE(*ppDecLeft) - DEC_SCALE(*ppDecRight);
4278
4279   if (!scaleAmount)
4280     return S_OK; /* Same scale */
4281
4282   if (scaleAmount > 0)
4283   {
4284     decTemp = *(*ppDecRight); /* Left is bigger - scale the right hand side */
4285     *ppDecRight = pDecOut;
4286   }
4287   else
4288   {
4289     decTemp = *(*ppDecLeft); /* Right is bigger - scale the left hand side */
4290     *ppDecLeft = pDecOut;
4291     i = scaleAmount = -scaleAmount;
4292   }
4293
4294   if (DEC_SCALE(&decTemp) + scaleAmount > DEC_MAX_SCALE)
4295     return DISP_E_OVERFLOW; /* Can't scale up */
4296
4297   /* Multiply up the value to be scaled by the correct amount */
4298   while (SUCCEEDED(hRet) && i--)
4299   {
4300     /* Note we are multiplying by a value with a scale of 0, so we don't recurse */
4301     hRet = VarDecMul(&decTemp, &scaleFactor, pDecOut);
4302     decTemp = *pDecOut;
4303   }
4304   DEC_SCALE(pDecOut) += scaleAmount; /* Set the new scale */
4305   return hRet;
4306 }
4307
4308 /* Add two unsigned 32 bit values with overflow */
4309 static ULONG VARIANT_Add(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
4310 {
4311   ULARGE_INTEGER ul64;
4312
4313   ul64.QuadPart = (ULONG64)ulLeft + (ULONG64)ulRight + (ULONG64)*pulHigh;
4314   *pulHigh = ul64.u.HighPart;
4315   return ul64.u.LowPart;
4316 }
4317
4318 /* Subtract two unsigned 32 bit values with underflow */
4319 static ULONG VARIANT_Sub(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
4320 {
4321   int invert = 0;
4322   ULARGE_INTEGER ul64;
4323
4324   ul64.QuadPart = (LONG64)ulLeft - (ULONG64)ulRight;
4325   if (ulLeft < ulRight)
4326     invert = 1;
4327
4328   if (ul64.QuadPart > (ULONG64)*pulHigh)
4329     ul64.QuadPart -= (ULONG64)*pulHigh;
4330   else
4331   {
4332     ul64.QuadPart -= (ULONG64)*pulHigh;
4333     invert = 1;
4334   }
4335   if (invert)
4336     ul64.u.HighPart = -ul64.u.HighPart ;
4337
4338   *pulHigh = ul64.u.HighPart;
4339   return ul64.u.LowPart;
4340 }
4341
4342 /* Multiply two unsigned 32 bit values with overflow */
4343 static ULONG VARIANT_Mul(ULONG ulLeft, ULONG ulRight, ULONG* pulHigh)
4344 {
4345   ULARGE_INTEGER ul64;
4346
4347   ul64.QuadPart = (ULONG64)ulLeft * (ULONG64)ulRight + (ULONG64)*pulHigh;
4348   *pulHigh = ul64.u.HighPart;
4349   return ul64.u.LowPart;
4350 }
4351
4352 /* Compare two decimals that have the same scale */
4353 static inline int VARIANT_DecCmp(const DECIMAL *pDecLeft, const DECIMAL *pDecRight)
4354 {
4355   if ( DEC_HI32(pDecLeft) < DEC_HI32(pDecRight) ||
4356       (DEC_HI32(pDecLeft) <= DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) < DEC_LO64(pDecRight)))
4357     return -1;
4358   else if (DEC_HI32(pDecLeft) == DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) == DEC_LO64(pDecRight))
4359     return 0;
4360   return 1;
4361 }
4362
4363 /************************************************************************
4364  * VarDecAdd (OLEAUT32.177)
4365  *
4366  * Add one DECIMAL to another.
4367  *
4368  * PARAMS
4369  *  pDecLeft  [I] Source
4370  *  pDecRight [I] Value to add
4371  *  pDecOut   [O] Destination
4372  *
4373  * RETURNS
4374  *  Success: S_OK.
4375  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4376  */
4377 HRESULT WINAPI VarDecAdd(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECIMAL* pDecOut)
4378 {
4379   HRESULT hRet;
4380   DECIMAL scaled;
4381
4382   hRet = VARIANT_DecScale(&pDecLeft, &pDecRight, &scaled);
4383
4384   if (SUCCEEDED(hRet))
4385   {
4386     /* Our decimals now have the same scale, we can add them as 96 bit integers */
4387     ULONG overflow = 0;
4388     BYTE sign = DECIMAL_POS;
4389
4390     /* Correct for the sign of the result */
4391     if (DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
4392     {
4393       /* -x + -y : Negative */
4394       sign = DECIMAL_NEG;
4395       goto VarDecAdd_AsPositive;
4396     }
4397     else if (DEC_SIGN(pDecLeft) && !DEC_SIGN(pDecRight))
4398     {
4399       int cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
4400
4401       /* -x + y : Negative if x > y */
4402       if (cmp > 0)
4403       {
4404         sign = DECIMAL_NEG;
4405 VarDecAdd_AsNegative:
4406         DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
4407         DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
4408         DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
4409       }
4410       else
4411       {
4412 VarDecAdd_AsInvertedNegative:
4413         DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecRight),  DEC_LO32(pDecLeft),  &overflow);
4414         DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecRight), DEC_MID32(pDecLeft), &overflow);
4415         DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecRight),  DEC_HI32(pDecLeft),  &overflow);
4416       }
4417     }
4418     else if (!DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
4419     {
4420       int cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
4421
4422       /* x + -y : Negative if x <= y */
4423       if (cmp <= 0)
4424       {
4425         sign = DECIMAL_NEG;
4426         goto VarDecAdd_AsInvertedNegative;
4427       }
4428       goto VarDecAdd_AsNegative;
4429     }
4430     else
4431     {
4432       /* x + y : Positive */
4433 VarDecAdd_AsPositive:
4434       DEC_LO32(pDecOut)  = VARIANT_Add(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
4435       DEC_MID32(pDecOut) = VARIANT_Add(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
4436       DEC_HI32(pDecOut)  = VARIANT_Add(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
4437     }
4438
4439     if (overflow)
4440       return DISP_E_OVERFLOW; /* overflowed */
4441
4442     DEC_SCALE(pDecOut) = DEC_SCALE(pDecLeft);
4443     DEC_SIGN(pDecOut) = sign;
4444   }
4445   return hRet;
4446 }
4447
4448 /************************************************************************
4449  * VarDecDiv (OLEAUT32.178)
4450  *
4451  * Divide one DECIMAL by another.
4452  *
4453  * PARAMS
4454  *  pDecLeft  [I] Source
4455  *  pDecRight [I] Value to divide by
4456  *  pDecOut   [O] Destination
4457  *
4458  * RETURNS
4459  *  Success: S_OK.
4460  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4461  */
4462 HRESULT WINAPI VarDecDiv(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECIMAL* pDecOut)
4463 {
4464   FIXME("(%p,%p,%p)-stub!\n",pDecLeft,pDecRight,pDecOut);
4465   return DISP_E_OVERFLOW;
4466 }
4467
4468 /************************************************************************
4469  * VarDecMul (OLEAUT32.179)
4470  *
4471  * Multiply one DECIMAL by another.
4472  *
4473  * PARAMS
4474  *  pDecLeft  [I] Source
4475  *  pDecRight [I] Value to multiply by
4476  *  pDecOut   [O] Destination
4477  *
4478  * RETURNS
4479  *  Success: S_OK.
4480  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4481  */
4482 HRESULT WINAPI VarDecMul(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECIMAL* pDecOut)
4483 {
4484   /* FIXME: This only allows multiplying by a fixed integer <= 0xffffffff */
4485
4486   if (!DEC_SCALE(pDecLeft) || !DEC_SCALE(pDecRight))
4487   {
4488     /* At least one term is an integer */
4489     const DECIMAL* pDecInteger = DEC_SCALE(pDecLeft) ? pDecRight : pDecLeft;
4490     const DECIMAL* pDecOperand = DEC_SCALE(pDecLeft) ? pDecLeft  : pDecRight;
4491     HRESULT hRet = S_OK;
4492     unsigned int multiplier = DEC_LO32(pDecInteger);
4493     ULONG overflow = 0;
4494
4495     if (DEC_HI32(pDecInteger) || DEC_MID32(pDecInteger))
4496     {
4497       FIXME("(%p,%p,%p) semi-stub!\n",pDecLeft,pDecRight,pDecOut);
4498       return DISP_E_OVERFLOW;
4499     }
4500
4501     DEC_LO32(pDecOut)  = VARIANT_Mul(DEC_LO32(pDecOperand),  multiplier, &overflow);
4502     DEC_MID32(pDecOut) = VARIANT_Mul(DEC_MID32(pDecOperand), multiplier, &overflow);
4503     DEC_HI32(pDecOut)  = VARIANT_Mul(DEC_HI32(pDecOperand),  multiplier, &overflow);
4504
4505     if (overflow)
4506        hRet = DISP_E_OVERFLOW;
4507     else
4508     {
4509       BYTE sign = DECIMAL_POS;
4510
4511       if (DEC_SIGN(pDecLeft) != DEC_SIGN(pDecRight))
4512         sign = DECIMAL_NEG; /* pos * neg => negative */
4513       DEC_SIGN(pDecOut) = sign;
4514       DEC_SCALE(pDecOut) = DEC_SCALE(pDecOperand);
4515     }
4516     return hRet;
4517   }
4518   FIXME("(%p,%p,%p) semi-stub!\n",pDecLeft,pDecRight,pDecOut);
4519   return DISP_E_OVERFLOW;
4520 }
4521
4522 /************************************************************************
4523  * VarDecSub (OLEAUT32.181)
4524  *
4525  * Subtract one DECIMAL from another.
4526  *
4527  * PARAMS
4528  *  pDecLeft  [I] Source
4529  *  pDecRight [I] DECIMAL to subtract from pDecLeft
4530  *  pDecOut   [O] Destination
4531  *
4532  * RETURNS
4533  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4534  */
4535 HRESULT WINAPI VarDecSub(const DECIMAL* pDecLeft, const DECIMAL* pDecRight, DECIMAL* pDecOut)
4536 {
4537   DECIMAL decRight;
4538
4539   /* Implement as addition of the negative */
4540   VarDecNeg(pDecRight, &decRight);
4541   return VarDecAdd(pDecLeft, &decRight, pDecOut);
4542 }
4543
4544 /************************************************************************
4545  * VarDecAbs (OLEAUT32.182)
4546  *
4547  * Convert a DECIMAL into its absolute value.
4548  *
4549  * PARAMS
4550  *  pDecIn  [I] Source
4551  *  pDecOut [O] Destination
4552  *
4553  * RETURNS
4554  *  S_OK. This function does not fail.
4555  */
4556 HRESULT WINAPI VarDecAbs(const DECIMAL* pDecIn, DECIMAL* pDecOut)
4557 {
4558   *pDecOut = *pDecIn;
4559   DEC_SIGN(pDecOut) &= ~DECIMAL_NEG;
4560   return S_OK;
4561 }
4562
4563 /************************************************************************
4564  * VarDecFix (OLEAUT32.187)
4565  *
4566  * Return the integer portion of a DECIMAL.
4567  *
4568  * PARAMS
4569  *  pDecIn  [I] Source
4570  *  pDecOut [O] Destination
4571  *
4572  * RETURNS
4573  *  Success: S_OK.
4574  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4575  *
4576  * NOTES
4577  *  - The difference between this function and VarDecInt() is that VarDecInt() rounds
4578  *    negative numbers away from 0, while this function rounds them towards zero.
4579  */
4580 HRESULT WINAPI VarDecFix(const DECIMAL* pDecIn, DECIMAL* pDecOut)
4581 {
4582   if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
4583     return E_INVALIDARG;
4584
4585   if (!DEC_SCALE(pDecIn))
4586   {
4587     *pDecOut = *pDecIn; /* Already an integer */
4588     return S_OK;
4589   }
4590
4591   FIXME("semi-stub!\n");
4592   return DISP_E_OVERFLOW;
4593 }
4594
4595 /************************************************************************
4596  * VarDecInt (OLEAUT32.188)
4597  *
4598  * Return the integer portion of a DECIMAL.
4599  *
4600  * PARAMS
4601  *  pDecIn  [I] Source
4602  *  pDecOut [O] Destination
4603  *
4604  * RETURNS
4605  *  Success: S_OK.
4606  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
4607  *
4608  * NOTES
4609  *  - The difference between this function and VarDecFix() is that VarDecFix() rounds
4610  *    negative numbers towards 0, while this function rounds them away from zero.
4611  */
4612 HRESULT WINAPI VarDecInt(const DECIMAL* pDecIn, DECIMAL* pDecOut)
4613 {
4614   if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
4615     return E_INVALIDARG;
4616
4617   if (!(DEC_SIGN(pDecIn) & DECIMAL_NEG) || !DEC_SCALE(pDecIn))
4618     return VarDecFix(pDecIn, pDecOut); /* The same, if +ve or no fractionals */
4619
4620   FIXME("semi-stub!\n");
4621   return DISP_E_OVERFLOW;
4622 }
4623
4624 /************************************************************************
4625  * VarDecNeg (OLEAUT32.189)
4626  *
4627  * Change the sign of a DECIMAL.
4628  *
4629  * PARAMS
4630  *  pDecIn  [I] Source
4631  *  pDecOut [O] Destination
4632  *
4633  * RETURNS
4634  *  S_OK. This function does not fail.
4635  */
4636 HRESULT WINAPI VarDecNeg(const DECIMAL* pDecIn, DECIMAL* pDecOut)
4637 {
4638   *pDecOut = *pDecIn;
4639   DEC_SIGN(pDecOut) ^= DECIMAL_NEG;
4640   return S_OK;
4641 }
4642
4643 /************************************************************************
4644  * VarDecRound (OLEAUT32.203)
4645  *
4646  * Change the precision of a DECIMAL.
4647  *
4648  * PARAMS
4649  *  pDecIn    [I] Source
4650  *  cDecimals [I] New number of decimals to keep
4651  *  pDecOut   [O] Destination
4652  *
4653  * RETURNS
4654  *  Success: S_OK. pDecOut contains the rounded value.
4655  *  Failure: E_INVALIDARG if any argument is invalid.
4656  */
4657 HRESULT WINAPI VarDecRound(const DECIMAL* pDecIn, int cDecimals, DECIMAL* pDecOut)
4658 {
4659   if (cDecimals < 0 || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG) || DEC_SCALE(pDecIn) > DEC_MAX_SCALE)
4660     return E_INVALIDARG;
4661
4662   if (cDecimals >= DEC_SCALE(pDecIn))
4663   {
4664     *pDecOut = *pDecIn; /* More precision than we have */
4665     return S_OK;
4666   }
4667
4668   FIXME("semi-stub!\n");
4669
4670   return DISP_E_OVERFLOW;
4671 }
4672
4673 /************************************************************************
4674  * VarDecCmp (OLEAUT32.204)
4675  *
4676  * Compare two DECIMAL values.
4677  *
4678  * PARAMS
4679  *  pDecLeft  [I] Source
4680  *  pDecRight [I] Value to compare
4681  *
4682  * RETURNS
4683  *  Success: VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that pDecLeft
4684  *           is less than, equal to or greater than pDecRight respectively.
4685  *  Failure: DISP_E_OVERFLOW, if overflow occurs during the comparison
4686  */
4687 HRESULT WINAPI VarDecCmp(const DECIMAL* pDecLeft, const DECIMAL* pDecRight)
4688 {
4689   HRESULT hRet;
4690   DECIMAL result;
4691
4692   /* Subtract right from left, and compare the result to 0 */
4693   hRet = VarDecSub(pDecLeft, pDecRight, &result);
4694
4695   if (SUCCEEDED(hRet))
4696   {
4697     int non_zero = DEC_HI32(&result) | DEC_MID32(&result) | DEC_LO32(&result);
4698
4699     if ((DEC_SIGN(&result) & DECIMAL_NEG) && non_zero)
4700       hRet = (HRESULT)VARCMP_LT;
4701     else if (non_zero)
4702       hRet = (HRESULT)VARCMP_GT;
4703     else
4704       hRet = (HRESULT)VARCMP_EQ;
4705   }
4706   return hRet;
4707 }
4708
4709 /************************************************************************
4710  * VarDecCmpR8 (OLEAUT32.298)
4711  *
4712  * Compare a DECIMAL to a double
4713  *
4714  * PARAMS
4715  *  pDecLeft [I] DECIMAL Source
4716  *  dblRight [I] double to compare to pDecLeft
4717  *
4718  * RETURNS
4719  *  Success: VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that dblRight
4720  *           is less than, equal to or greater than pDecLeft respectively.
4721  *  Failure: DISP_E_OVERFLOW, if overflow occurs during the comparison
4722  */
4723 HRESULT WINAPI VarDecCmpR8(const DECIMAL* pDecLeft, double dblRight)
4724 {
4725   HRESULT hRet;
4726   DECIMAL decRight;
4727
4728   hRet = VarDecFromR8(dblRight, &decRight);
4729
4730   if (SUCCEEDED(hRet))
4731     hRet = VarDecCmp(pDecLeft, &decRight);
4732
4733   return hRet;
4734 }
4735
4736 /* BOOL
4737  */
4738
4739 /************************************************************************
4740  * VarBoolFromUI1 (OLEAUT32.118)
4741  *
4742  * Convert a VT_UI1 to a VT_BOOL.
4743  *
4744  * PARAMS
4745  *  bIn      [I] Source
4746  *  pBoolOut [O] Destination
4747  *
4748  * RETURNS
4749  *  S_OK.
4750  */
4751 HRESULT WINAPI VarBoolFromUI1(BYTE bIn, VARIANT_BOOL *pBoolOut)
4752 {
4753   return _VarBoolFromUI1(bIn, pBoolOut);
4754 }
4755
4756 /************************************************************************
4757  * VarBoolFromI2 (OLEAUT32.119)
4758  *
4759  * Convert a VT_I2 to a VT_BOOL.
4760  *
4761  * PARAMS
4762  *  sIn      [I] Source
4763  *  pBoolOut [O] Destination
4764  *
4765  * RETURNS
4766  *  S_OK.
4767  */
4768 HRESULT WINAPI VarBoolFromI2(SHORT sIn, VARIANT_BOOL *pBoolOut)
4769 {
4770   return _VarBoolFromI2(sIn, pBoolOut);
4771 }
4772
4773 /************************************************************************
4774  * VarBoolFromI4 (OLEAUT32.120)
4775  *
4776  * Convert a VT_I4 to a VT_BOOL.
4777  *
4778  * PARAMS
4779  *  sIn      [I] Source
4780  *  pBoolOut [O] Destination
4781  *
4782  * RETURNS
4783  *  S_OK.
4784  */
4785 HRESULT WINAPI VarBoolFromI4(LONG lIn, VARIANT_BOOL *pBoolOut)
4786 {
4787   return _VarBoolFromI4(lIn, pBoolOut);
4788 }
4789
4790 /************************************************************************
4791  * VarBoolFromR4 (OLEAUT32.121)
4792  *
4793  * Convert a VT_R4 to a VT_BOOL.
4794  *
4795  * PARAMS
4796  *  fltIn    [I] Source
4797  *  pBoolOut [O] Destination
4798  *
4799  * RETURNS
4800  *  S_OK.
4801  */
4802 HRESULT WINAPI VarBoolFromR4(FLOAT fltIn, VARIANT_BOOL *pBoolOut)
4803 {
4804   return _VarBoolFromR4(fltIn, pBoolOut);
4805 }
4806
4807 /************************************************************************
4808  * VarBoolFromR8 (OLEAUT32.122)
4809  *
4810  * Convert a VT_R8 to a VT_BOOL.
4811  *
4812  * PARAMS
4813  *  dblIn    [I] Source
4814  *  pBoolOut [O] Destination
4815  *
4816  * RETURNS
4817  *  S_OK.
4818  */
4819 HRESULT WINAPI VarBoolFromR8(double dblIn, VARIANT_BOOL *pBoolOut)
4820 {
4821   return _VarBoolFromR8(dblIn, pBoolOut);
4822 }
4823
4824 /************************************************************************
4825  * VarBoolFromDate (OLEAUT32.123)
4826  *
4827  * Convert a VT_DATE to a VT_BOOL.
4828  *
4829  * PARAMS
4830  *  dateIn   [I] Source
4831  *  pBoolOut [O] Destination
4832  *
4833  * RETURNS
4834  *  S_OK.
4835  */
4836 HRESULT WINAPI VarBoolFromDate(DATE dateIn, VARIANT_BOOL *pBoolOut)
4837 {
4838   return _VarBoolFromDate(dateIn, pBoolOut);
4839 }
4840
4841 /************************************************************************
4842  * VarBoolFromCy (OLEAUT32.124)
4843  *
4844  * Convert a VT_CY to a VT_BOOL.
4845  *
4846  * PARAMS
4847  *  cyIn     [I] Source
4848  *  pBoolOut [O] Destination
4849  *
4850  * RETURNS
4851  *  S_OK.
4852  */
4853 HRESULT WINAPI VarBoolFromCy(CY cyIn, VARIANT_BOOL *pBoolOut)
4854 {
4855   return _VarBoolFromCy(cyIn, pBoolOut);
4856 }
4857
4858 static BOOL VARIANT_GetLocalisedText(LANGID langId, DWORD dwId, WCHAR *lpszDest)
4859 {
4860   HRSRC hrsrc;
4861
4862   hrsrc = FindResourceExW( OLEAUT32_hModule, (LPWSTR)RT_STRING,
4863                            (LPCWSTR)((dwId >> 4) + 1), langId );
4864   if (hrsrc)
4865   {
4866     HGLOBAL hmem = LoadResource( OLEAUT32_hModule, hrsrc );
4867
4868     if (hmem)
4869     {
4870       const WCHAR *p;
4871       unsigned int i;
4872
4873       p = LockResource( hmem );
4874       for (i = 0; i < (dwId & 0x0f); i++) p += *p + 1;
4875
4876       memcpy( lpszDest, p + 1, *p * sizeof(WCHAR) );
4877       lpszDest[*p] = '\0';
4878       TRACE("got %s for LANGID %08x\n", debugstr_w(lpszDest), langId);
4879       return TRUE;
4880     }
4881   }
4882   return FALSE;
4883 }
4884
4885 /************************************************************************
4886  * VarBoolFromStr (OLEAUT32.125)
4887  *
4888  * Convert a VT_BSTR to a VT_BOOL.
4889  *
4890  * PARAMS
4891  *  strIn    [I] Source
4892  *  lcid     [I] LCID for the conversion
4893  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
4894  *  pBoolOut [O] Destination
4895  *
4896  * RETURNS
4897  *  Success: S_OK.
4898  *  Failure: E_INVALIDARG, if pBoolOut is invalid.
4899  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
4900  *
4901  * NOTES
4902  *  - strIn will be recognised if it contains "#TRUE#" or "#FALSE#". Additionally,
4903  *  it may contain (in any case mapping) the text "true" or "false".
4904  *  - If dwFlags includes VAR_LOCALBOOL, then the text may also match the
4905  *  localised text of "True" or "False" in the language specified by lcid.
4906  *  - If none of these matches occur, the string is treated as a numeric string
4907  *  and the boolean pBoolOut will be set according to whether the number is zero
4908  *  or not. The dwFlags parameter is passed to VarR8FromStr() for this conversion.
4909  *  - If the text is not numeric and does not match any of the above, then
4910  *  DISP_E_TYPEMISMATCH is returned.
4911  */
4912 HRESULT WINAPI VarBoolFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL *pBoolOut)
4913 {
4914   /* Any VB/VBA programmers out there should recognise these strings... */
4915   static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
4916   static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
4917   WCHAR szBuff[64];
4918   LANGID langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
4919   HRESULT hRes = S_OK;
4920
4921   if (!strIn || !pBoolOut)
4922     return DISP_E_TYPEMISMATCH;
4923
4924   /* Check if we should be comparing against localised text */
4925   if (dwFlags & VAR_LOCALBOOL)
4926   {
4927     /* Convert our LCID into a usable value */
4928     lcid = ConvertDefaultLocale(lcid);
4929
4930     langId = LANGIDFROMLCID(lcid);
4931
4932     if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
4933       langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
4934
4935     /* Note: Native oleaut32 always copies strIn and maps halfwidth characters.
4936      * I don't think this is needed unless any of the localised text strings
4937      * contain characters that can be so mapped. In the event that this is
4938      * true for a given language (possibly some Asian languages), then strIn
4939      * should be mapped here _only_ if langId is an Id for which this can occur.
4940      */
4941   }
4942
4943   /* Note that if we are not comparing against localised strings, langId
4944    * will have its default value of LANG_ENGLISH. This allows us to mimic
4945    * the native behaviour of always checking against English strings even
4946    * after we've checked for localised ones.
4947    */
4948 VarBoolFromStr_CheckLocalised:
4949   if (VARIANT_GetLocalisedText(langId, IDS_TRUE, szBuff))
4950   {
4951     /* Compare against localised strings, ignoring case */
4952     if (!strcmpiW(strIn, szBuff))
4953     {
4954       *pBoolOut = VARIANT_TRUE; /* Matched localised 'true' text */
4955       return hRes;
4956     }
4957     VARIANT_GetLocalisedText(langId, IDS_FALSE, szBuff);
4958     if (!strcmpiW(strIn, szBuff))
4959     {
4960       *pBoolOut = VARIANT_FALSE; /* Matched localised 'false' text */
4961       return hRes;
4962     }
4963   }
4964
4965   if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
4966   {
4967     /* We have checked the localised text, now check English */
4968     langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
4969     goto VarBoolFromStr_CheckLocalised;
4970   }
4971
4972   /* All checks against localised text have failed, try #TRUE#/#FALSE# */
4973   if (!strcmpW(strIn, szFalse))
4974     *pBoolOut = VARIANT_FALSE;
4975   else if (!strcmpW(strIn, szTrue))
4976     *pBoolOut = VARIANT_TRUE;
4977   else
4978   {
4979     double d;
4980
4981     /* If this string is a number, convert it as one */
4982     hRes = _VarR8FromStr(strIn, lcid, dwFlags, &d);
4983     if (SUCCEEDED(hRes))
4984       hRes = _VarBoolFromR8(d, pBoolOut);
4985   }
4986   return hRes;
4987 }
4988
4989 /************************************************************************
4990  * VarBoolFromDisp (OLEAUT32.126)
4991  *
4992  * Convert a VT_DISPATCH to a VT_BOOL.
4993  *
4994  * PARAMS
4995  *  pdispIn   [I] Source
4996  *  lcid      [I] LCID for conversion
4997  *  pBoolOut  [O] Destination
4998  *
4999  * RETURNS
5000  *  Success: S_OK.
5001  *  Failure: E_INVALIDARG, if the source value is invalid
5002  *           DISP_E_OVERFLOW, if the value will not fit in the destination
5003  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
5004  */
5005 HRESULT WINAPI VarBoolFromDisp(IDispatch* pdispIn, LCID lcid, VARIANT_BOOL *pBoolOut)
5006 {
5007   return _VarBoolFromDisp(pdispIn, lcid, pBoolOut);
5008 }
5009
5010 /************************************************************************
5011  * VarBoolFromI1 (OLEAUT32.233)
5012  *
5013  * Convert a VT_I1 to a VT_BOOL.
5014  *
5015  * PARAMS
5016  *  cIn      [I] Source
5017  *  pBoolOut [O] Destination
5018  *
5019  * RETURNS
5020  *  S_OK.
5021  */
5022 HRESULT WINAPI VarBoolFromI1(signed char cIn, VARIANT_BOOL *pBoolOut)
5023 {
5024   return _VarBoolFromI1(cIn, pBoolOut);
5025 }
5026
5027 /************************************************************************
5028  * VarBoolFromUI2 (OLEAUT32.234)
5029  *
5030  * Convert a VT_UI2 to a VT_BOOL.
5031  *
5032  * PARAMS
5033  *  usIn     [I] Source
5034  *  pBoolOut [O] Destination
5035  *
5036  * RETURNS
5037  *  S_OK.
5038  */
5039 HRESULT WINAPI VarBoolFromUI2(USHORT usIn, VARIANT_BOOL *pBoolOut)
5040 {
5041   return _VarBoolFromUI2(usIn, pBoolOut);
5042 }
5043
5044 /************************************************************************
5045  * VarBoolFromUI4 (OLEAUT32.235)
5046  *
5047  * Convert a VT_UI4 to a VT_BOOL.
5048  *
5049  * PARAMS
5050  *  ulIn     [I] Source
5051  *  pBoolOut [O] Destination
5052  *
5053  * RETURNS
5054  *  S_OK.
5055  */
5056 HRESULT WINAPI VarBoolFromUI4(ULONG ulIn, VARIANT_BOOL *pBoolOut)
5057 {
5058   return _VarBoolFromUI4(ulIn, pBoolOut);
5059 }
5060
5061 /************************************************************************
5062  * VarBoolFromDec (OLEAUT32.236)
5063  *
5064  * Convert a VT_DECIMAL to a VT_BOOL.
5065  *
5066  * PARAMS
5067  *  pDecIn   [I] Source
5068  *  pBoolOut [O] Destination
5069  *
5070  * RETURNS
5071  *  Success: S_OK.
5072  *  Failure: E_INVALIDARG, if pDecIn is invalid.
5073  */
5074 HRESULT WINAPI VarBoolFromDec(DECIMAL* pDecIn, VARIANT_BOOL *pBoolOut)
5075 {
5076   if (DEC_SCALE(pDecIn) > DEC_MAX_SCALE || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG))
5077     return E_INVALIDARG;
5078
5079   if (DEC_HI32(pDecIn) || DEC_MID32(pDecIn) || DEC_LO32(pDecIn))
5080     *pBoolOut = VARIANT_TRUE;
5081   else
5082     *pBoolOut = VARIANT_FALSE;
5083   return S_OK;
5084 }
5085
5086 /************************************************************************
5087  * VarBoolFromI8 (OLEAUT32.370)
5088  *
5089  * Convert a VT_I8 to a VT_BOOL.
5090  *
5091  * PARAMS
5092  *  ullIn    [I] Source
5093  *  pBoolOut [O] Destination
5094  *
5095  * RETURNS
5096  *  S_OK.
5097  */
5098 HRESULT WINAPI VarBoolFromI8(LONG64 llIn, VARIANT_BOOL *pBoolOut)
5099 {
5100   return _VarBoolFromI8(llIn, pBoolOut);
5101 }
5102
5103 /************************************************************************
5104  * VarBoolFromUI8 (OLEAUT32.371)
5105  *
5106  * Convert a VT_UI8 to a VT_BOOL.
5107  *
5108  * PARAMS
5109  *  ullIn    [I] Source
5110  *  pBoolOut [O] Destination
5111  *
5112  * RETURNS
5113  *  S_OK.
5114  */
5115 HRESULT WINAPI VarBoolFromUI8(ULONG64 ullIn, VARIANT_BOOL *pBoolOut)
5116 {
5117   return _VarBoolFromUI8(ullIn, pBoolOut);
5118 }
5119
5120 /* BSTR
5121  */
5122
5123 /* Write a number from a UI8 and sign */
5124 static WCHAR *VARIANT_WriteNumber(ULONG64 ulVal, WCHAR* szOut)
5125 {
5126   do
5127   {
5128     WCHAR ulNextDigit = ulVal % 10;
5129
5130     *szOut-- = '0' + ulNextDigit;
5131     ulVal = (ulVal - ulNextDigit) / 10;
5132   } while (ulVal);
5133
5134   szOut++;
5135   return szOut;
5136 }
5137
5138 /* Create a (possibly localised) BSTR from a UI8 and sign */
5139 static BSTR VARIANT_MakeBstr(LCID lcid, DWORD dwFlags, WCHAR *szOut)
5140 {
5141   WCHAR szConverted[256];
5142
5143   if (dwFlags & VAR_NEGATIVE)
5144     *--szOut = '-';
5145
5146   if (dwFlags & LOCALE_USE_NLS)
5147   {
5148     /* Format the number for the locale */
5149     szConverted[0] = '\0';
5150     GetNumberFormatW(lcid,
5151                      dwFlags & LOCALE_NOUSEROVERRIDE,
5152                      szOut, NULL, szConverted, sizeof(szConverted)/sizeof(WCHAR));
5153     szOut = szConverted;
5154   }
5155   return SysAllocStringByteLen((LPCSTR)szOut, strlenW(szOut) * sizeof(WCHAR));
5156 }
5157
5158 /* Create a (possibly localised) BSTR from a UI8 and sign */
5159 static HRESULT VARIANT_BstrFromUInt(ULONG64 ulVal, LCID lcid, DWORD dwFlags, BSTR *pbstrOut)
5160 {
5161   WCHAR szBuff[64], *szOut = szBuff + sizeof(szBuff)/sizeof(WCHAR) - 1;
5162
5163   if (!pbstrOut)
5164     return E_INVALIDARG;
5165
5166   /* Create the basic number string */
5167   *szOut-- = '\0';
5168   szOut = VARIANT_WriteNumber(ulVal, szOut);
5169
5170   *pbstrOut = VARIANT_MakeBstr(lcid, dwFlags, szOut);
5171   TRACE("returning %s\n", debugstr_w(*pbstrOut));
5172   return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5173 }
5174
5175 /******************************************************************************
5176  * VarBstrFromUI1 (OLEAUT32.108)
5177  *
5178  * Convert a VT_UI1 to a VT_BSTR.
5179  *
5180  * PARAMS
5181  *  bIn      [I] Source
5182  *  lcid     [I] LCID for the conversion
5183  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5184  *  pbstrOut [O] Destination
5185  *
5186  * RETURNS
5187  *  Success: S_OK.
5188  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5189  *           E_OUTOFMEMORY, if memory allocation fails.
5190  */
5191 HRESULT WINAPI VarBstrFromUI1(BYTE bIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5192 {
5193   return VARIANT_BstrFromUInt(bIn, lcid, dwFlags, pbstrOut);
5194 }
5195
5196 /******************************************************************************
5197  * VarBstrFromI2 (OLEAUT32.109)
5198  *
5199  * Convert a VT_I2 to a VT_BSTR.
5200  *
5201  * PARAMS
5202  *  sIn      [I] Source
5203  *  lcid     [I] LCID for the conversion
5204  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5205  *  pbstrOut [O] Destination
5206  *
5207  * RETURNS
5208  *  Success: S_OK.
5209  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5210  *           E_OUTOFMEMORY, if memory allocation fails.
5211  */
5212 HRESULT WINAPI VarBstrFromI2(short sIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5213 {
5214   ULONG64 ul64 = sIn;
5215
5216   if (sIn < 0)
5217   {
5218     ul64 = -sIn;
5219     dwFlags |= VAR_NEGATIVE;
5220   }
5221   return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
5222 }
5223
5224 /******************************************************************************
5225  * VarBstrFromI4 (OLEAUT32.110)
5226  *
5227  * Convert a VT_I4 to a VT_BSTR.
5228  *
5229  * PARAMS
5230  *  lIn      [I] Source
5231  *  lcid     [I] LCID for the conversion
5232  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5233  *  pbstrOut [O] Destination
5234  *
5235  * RETURNS
5236  *  Success: S_OK.
5237  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5238  *           E_OUTOFMEMORY, if memory allocation fails.
5239  */
5240 HRESULT WINAPI VarBstrFromI4(LONG lIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5241 {
5242   ULONG64 ul64 = lIn;
5243
5244   if (lIn < 0)
5245   {
5246     ul64 = (ULONG)-lIn;
5247     dwFlags |= VAR_NEGATIVE;
5248   }
5249   return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
5250 }
5251
5252 static HRESULT VARIANT_BstrFromReal(DOUBLE dblIn, LCID lcid, ULONG dwFlags,
5253                                     BSTR* pbstrOut, LPCWSTR lpszFormat)
5254 {
5255   WCHAR buff[256];
5256
5257   if (!pbstrOut)
5258     return E_INVALIDARG;
5259
5260   sprintfW( buff, lpszFormat, dblIn );
5261   TRACE("created string %s\n", debugstr_w(buff));
5262   if (dwFlags & LOCALE_USE_NLS)
5263   {
5264     WCHAR numbuff[256];
5265
5266     /* Format the number for the locale */
5267     numbuff[0] = '\0';
5268     GetNumberFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
5269                      buff, NULL, numbuff, sizeof(numbuff) / sizeof(WCHAR));
5270     TRACE("created NLS string %s\n", debugstr_w(numbuff));
5271     *pbstrOut = SysAllocString(numbuff);
5272   }
5273   else
5274     *pbstrOut = SysAllocString(buff);
5275   return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5276 }
5277
5278 /******************************************************************************
5279  * VarBstrFromR4 (OLEAUT32.111)
5280  *
5281  * Convert a VT_R4 to a VT_BSTR.
5282  *
5283  * PARAMS
5284  *  fltIn    [I] Source
5285  *  lcid     [I] LCID for the conversion
5286  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5287  *  pbstrOut [O] Destination
5288  *
5289  * RETURNS
5290  *  Success: S_OK.
5291  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5292  *           E_OUTOFMEMORY, if memory allocation fails.
5293  */
5294 HRESULT WINAPI VarBstrFromR4(FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5295 {
5296   return VARIANT_BstrFromReal(fltIn, lcid, dwFlags, pbstrOut, szFloatFormatW);
5297 }
5298
5299 /******************************************************************************
5300  * VarBstrFromR8 (OLEAUT32.112)
5301  *
5302  * Convert a VT_R8 to a VT_BSTR.
5303  *
5304  * PARAMS
5305  *  dblIn    [I] Source
5306  *  lcid     [I] LCID for the conversion
5307  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5308  *  pbstrOut [O] Destination
5309  *
5310  * RETURNS
5311  *  Success: S_OK.
5312  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5313  *           E_OUTOFMEMORY, if memory allocation fails.
5314  */
5315 HRESULT WINAPI VarBstrFromR8(double dblIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5316 {
5317   return VARIANT_BstrFromReal(dblIn, lcid, dwFlags, pbstrOut, szDoubleFormatW);
5318 }
5319
5320 /******************************************************************************
5321  *    VarBstrFromCy   [OLEAUT32.113]
5322  *
5323  * Convert a VT_CY to a VT_BSTR.
5324  *
5325  * PARAMS
5326  *  cyIn     [I] Source
5327  *  lcid     [I] LCID for the conversion
5328  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5329  *  pbstrOut [O] Destination
5330  *
5331  * RETURNS
5332  *  Success: S_OK.
5333  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5334  *           E_OUTOFMEMORY, if memory allocation fails.
5335  */
5336 HRESULT WINAPI VarBstrFromCy(CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
5337 {
5338   WCHAR buff[256];
5339   double dblVal;
5340
5341   if (!pbstrOut)
5342     return E_INVALIDARG;
5343
5344   VarR8FromCy(cyIn, &dblVal);
5345   sprintfW(buff, szDoubleFormatW, dblVal);
5346
5347   if (dwFlags & LOCALE_USE_NLS)
5348   {
5349     WCHAR cybuff[256];
5350
5351     /* Format the currency for the locale */
5352     cybuff[0] = '\0';
5353     GetCurrencyFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
5354                        buff, NULL, cybuff, sizeof(cybuff) / sizeof(WCHAR));
5355     *pbstrOut = SysAllocString(cybuff);
5356   }
5357   else
5358     *pbstrOut = SysAllocString(buff);
5359
5360   return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5361 }
5362
5363 /******************************************************************************
5364  *    VarBstrFromDate    [OLEAUT32.114]
5365  *
5366  * Convert a VT_DATE to a VT_BSTR.
5367  *
5368  * PARAMS
5369  *  dateIn   [I] Source
5370  *  lcid     [I] LCID for the conversion
5371  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5372  *  pbstrOut [O] Destination
5373  *
5374  * RETURNS
5375  *  Success: S_OK.
5376  *  Failure: E_INVALIDARG, if pbstrOut or dateIn is invalid.
5377  *           E_OUTOFMEMORY, if memory allocation fails.
5378  */
5379 HRESULT WINAPI VarBstrFromDate(DATE dateIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5380 {
5381   SYSTEMTIME st;
5382   DWORD dwFormatFlags = dwFlags & LOCALE_NOUSEROVERRIDE;
5383   WCHAR date[128], *time;
5384
5385   TRACE("(%g,0x%08lx,0x%08lx,%p)\n", dateIn, lcid, dwFlags, pbstrOut);
5386
5387   if (!pbstrOut || !VariantTimeToSystemTime(dateIn, &st))
5388     return E_INVALIDARG;
5389
5390   *pbstrOut = NULL;
5391
5392   if (dwFlags & VAR_CALENDAR_THAI)
5393       st.wYear += 553; /* Use the Thai buddhist calendar year */
5394   else if (dwFlags & (VAR_CALENDAR_HIJRI|VAR_CALENDAR_GREGORIAN))
5395       FIXME("VAR_CALENDAR_HIJRI/VAR_CALENDAR_GREGORIAN not handled\n");
5396
5397   if (dwFlags & LOCALE_USE_NLS)
5398     dwFlags &= ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY);
5399   else
5400   {
5401     double whole = dateIn < 0 ? ceil(dateIn) : floor(dateIn);
5402     double partial = dateIn - whole;
5403
5404     if (whole == 0.0)
5405       dwFlags |= VAR_TIMEVALUEONLY;
5406     else if (partial < 1e-12)
5407       dwFlags |= VAR_DATEVALUEONLY;
5408   }
5409
5410   if (dwFlags & VAR_TIMEVALUEONLY)
5411     date[0] = '\0';
5412   else
5413     if (!GetDateFormatW(lcid, dwFormatFlags|DATE_SHORTDATE, &st, NULL, date,
5414                         sizeof(date)/sizeof(WCHAR)))
5415       return E_INVALIDARG;
5416
5417   if (!(dwFlags & VAR_DATEVALUEONLY))
5418   {
5419     time = date + strlenW(date);
5420     if (time != date)
5421       *time++ = ' ';
5422     if (!GetTimeFormatW(lcid, dwFormatFlags, &st, NULL, time,
5423                         sizeof(date)/sizeof(WCHAR)-(time-date)))
5424       return E_INVALIDARG;
5425   }
5426
5427   *pbstrOut = SysAllocString(date);
5428   if (*pbstrOut)
5429     TRACE("returning %s\n", debugstr_w(*pbstrOut));
5430   return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5431 }
5432
5433 /******************************************************************************
5434  * VarBstrFromBool (OLEAUT32.116)
5435  *
5436  * Convert a VT_BOOL to a VT_BSTR.
5437  *
5438  * PARAMS
5439  *  boolIn   [I] Source
5440  *  lcid     [I] LCID for the conversion
5441  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5442  *  pbstrOut [O] Destination
5443  *
5444  * RETURNS
5445  *  Success: S_OK.
5446  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5447  *           E_OUTOFMEMORY, if memory allocation fails.
5448  *
5449  * NOTES
5450  *  If dwFlags includes VARIANT_LOCALBOOL, this function converts to the
5451  *  localised text of "True" or "False". To convert a bool into a
5452  *  numeric string of "0" or "-1", use VariantChangeTypeTypeEx().
5453  */
5454 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5455 {
5456   WCHAR szBuff[64];
5457   DWORD dwResId = IDS_TRUE;
5458   LANGID langId;
5459
5460   TRACE("%d,0x%08lx,0x%08lx,%p\n", boolIn, lcid, dwFlags, pbstrOut);
5461
5462   if (!pbstrOut)
5463     return E_INVALIDARG;
5464
5465   /* VAR_BOOLONOFF and VAR_BOOLYESNO are internal flags used
5466    * for variant formatting */
5467   switch (dwFlags & (VAR_LOCALBOOL|VAR_BOOLONOFF|VAR_BOOLYESNO))
5468   {
5469   case VAR_BOOLONOFF:
5470       dwResId = IDS_ON;
5471       break;
5472   case VAR_BOOLYESNO:
5473       dwResId = IDS_YES;
5474       break;
5475   case VAR_LOCALBOOL:
5476       break;
5477   default:
5478     lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),SORT_DEFAULT);
5479   }
5480
5481   lcid = ConvertDefaultLocale(lcid);
5482   langId = LANGIDFROMLCID(lcid);
5483   if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
5484     langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
5485
5486   if (boolIn == VARIANT_FALSE)
5487     dwResId++; /* Use negative form */
5488
5489 VarBstrFromBool_GetLocalised:
5490   if (VARIANT_GetLocalisedText(langId, dwResId, szBuff))
5491   {
5492     *pbstrOut = SysAllocString(szBuff);
5493     return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5494   }
5495
5496   if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
5497   {
5498     langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
5499     goto VarBstrFromBool_GetLocalised;
5500   }
5501
5502   /* Should never get here */
5503   WARN("Failed to load bool text!\n");
5504   return E_OUTOFMEMORY;
5505 }
5506
5507 /******************************************************************************
5508  * VarBstrFromI1 (OLEAUT32.229)
5509  *
5510  * Convert a VT_I1 to a VT_BSTR.
5511  *
5512  * PARAMS
5513  *  cIn      [I] Source
5514  *  lcid     [I] LCID for the conversion
5515  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5516  *  pbstrOut [O] Destination
5517  *
5518  * RETURNS
5519  *  Success: S_OK.
5520  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5521  *           E_OUTOFMEMORY, if memory allocation fails.
5522  */
5523 HRESULT WINAPI VarBstrFromI1(signed char cIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5524 {
5525   ULONG64 ul64 = cIn;
5526
5527   if (cIn < 0)
5528   {
5529     ul64 = -cIn;
5530     dwFlags |= VAR_NEGATIVE;
5531   }
5532   return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
5533 }
5534
5535 /******************************************************************************
5536  * VarBstrFromUI2 (OLEAUT32.230)
5537  *
5538  * Convert a VT_UI2 to a VT_BSTR.
5539  *
5540  * PARAMS
5541  *  usIn     [I] Source
5542  *  lcid     [I] LCID for the conversion
5543  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5544  *  pbstrOut [O] Destination
5545  *
5546  * RETURNS
5547  *  Success: S_OK.
5548  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5549  *           E_OUTOFMEMORY, if memory allocation fails.
5550  */
5551 HRESULT WINAPI VarBstrFromUI2(USHORT usIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5552 {
5553   return VARIANT_BstrFromUInt(usIn, lcid, dwFlags, pbstrOut);
5554 }
5555
5556 /******************************************************************************
5557  * VarBstrFromUI4 (OLEAUT32.231)
5558  *
5559  * Convert a VT_UI4 to a VT_BSTR.
5560  *
5561  * PARAMS
5562  *  ulIn     [I] Source
5563  *  lcid     [I] LCID for the conversion
5564  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5565  *  pbstrOut [O] Destination
5566  *
5567  * RETURNS
5568  *  Success: S_OK.
5569  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5570  *           E_OUTOFMEMORY, if memory allocation fails.
5571  */
5572 HRESULT WINAPI VarBstrFromUI4(ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5573 {
5574   return VARIANT_BstrFromUInt(ulIn, lcid, dwFlags, pbstrOut);
5575 }
5576
5577 /******************************************************************************
5578  * VarBstrFromDec (OLEAUT32.232)
5579  *
5580  * Convert a VT_DECIMAL to a VT_BSTR.
5581  *
5582  * PARAMS
5583  *  pDecIn   [I] Source
5584  *  lcid     [I] LCID for the conversion
5585  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5586  *  pbstrOut [O] Destination
5587  *
5588  * RETURNS
5589  *  Success: S_OK.
5590  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5591  *           E_OUTOFMEMORY, if memory allocation fails.
5592  */
5593 HRESULT WINAPI VarBstrFromDec(DECIMAL* pDecIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5594 {
5595   if (!pbstrOut)
5596     return E_INVALIDARG;
5597
5598   if (!DEC_SCALE(pDecIn) && !DEC_HI32(pDecIn))
5599   {
5600     WCHAR szBuff[256], *szOut = szBuff + sizeof(szBuff)/sizeof(WCHAR) - 1;
5601
5602     /* Create the basic number string */
5603     *szOut-- = '\0';
5604     szOut = VARIANT_WriteNumber(DEC_LO64(pDecIn), szOut);
5605     if (DEC_SIGN(pDecIn))
5606       dwFlags |= VAR_NEGATIVE;
5607
5608     *pbstrOut = VARIANT_MakeBstr(lcid, dwFlags, szOut);
5609     TRACE("returning %s\n", debugstr_w(*pbstrOut));
5610     return *pbstrOut ? S_OK : E_OUTOFMEMORY;
5611   }
5612   FIXME("semi-stub\n");
5613   return E_INVALIDARG;
5614 }
5615
5616 /************************************************************************
5617  * VarBstrFromI8 (OLEAUT32.370)
5618  *
5619  * Convert a VT_I8 to a VT_BSTR.
5620  *
5621  * PARAMS
5622  *  llIn     [I] Source
5623  *  lcid     [I] LCID for the conversion
5624  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5625  *  pbstrOut [O] Destination
5626  *
5627  * RETURNS
5628  *  Success: S_OK.
5629  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5630  *           E_OUTOFMEMORY, if memory allocation fails.
5631  */
5632 HRESULT WINAPI VarBstrFromI8(LONG64 llIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5633 {
5634   ULONG64 ul64 = llIn;
5635
5636   if (llIn < 0)
5637   {
5638     ul64 = -llIn;
5639     dwFlags |= VAR_NEGATIVE;
5640   }
5641   return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
5642 }
5643
5644 /************************************************************************
5645  * VarBstrFromUI8 (OLEAUT32.371)
5646  *
5647  * Convert a VT_UI8 to a VT_BSTR.
5648  *
5649  * PARAMS
5650  *  ullIn    [I] Source
5651  *  lcid     [I] LCID for the conversion
5652  *  dwFlags  [I] Flags controlling the conversion (VAR_ flags from "oleauto.h")
5653  *  pbstrOut [O] Destination
5654  *
5655  * RETURNS
5656  *  Success: S_OK.
5657  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5658  *           E_OUTOFMEMORY, if memory allocation fails.
5659  */
5660 HRESULT WINAPI VarBstrFromUI8(ULONG64 ullIn, LCID lcid, ULONG dwFlags, BSTR* pbstrOut)
5661 {
5662   return VARIANT_BstrFromUInt(ullIn, lcid, dwFlags, pbstrOut);
5663 }
5664
5665 /**********************************************************************
5666  * VarBstrCat (OLEAUT32.313)
5667  *
5668  * Concatenate two BSTR values.
5669  *
5670  * PARAMS
5671  *  pbstrLeft  [I] Source
5672  *  pbstrRight [I] Value to concatenate
5673  *  pbstrOut   [O] Destination
5674  *
5675  * RETURNS
5676  *  Success: S_OK.
5677  *  Failure: E_INVALIDARG, if pbstrOut is invalid.
5678  *           E_OUTOFMEMORY, if memory allocation fails.
5679  */
5680 HRESULT WINAPI VarBstrCat(BSTR pbstrLeft, BSTR pbstrRight, BSTR *pbstrOut)
5681 {
5682   unsigned int len;
5683
5684   if (!pbstrOut)
5685     return E_INVALIDARG;
5686
5687   len = pbstrLeft ? strlenW(pbstrLeft) : 0;
5688   if (pbstrRight)
5689     len += strlenW(pbstrRight);
5690
5691   *pbstrOut = SysAllocStringLen(NULL, len);
5692   if (!*pbstrOut)
5693     return E_OUTOFMEMORY;
5694
5695   (*pbstrOut)[0] = '\0';
5696
5697   if (pbstrLeft)
5698     strcpyW(*pbstrOut, pbstrLeft);
5699
5700   if (pbstrRight)
5701     strcatW(*pbstrOut, pbstrRight);
5702
5703   return S_OK;
5704 }
5705
5706 /**********************************************************************
5707  * VarBstrCmp (OLEAUT32.314)
5708  *
5709  * Compare two BSTR values.
5710  *
5711  * PARAMS
5712  *  pbstrLeft  [I] Source
5713  *  pbstrRight [I] Value to compare
5714  *  lcid       [I] LCID for the comparison
5715  *  dwFlags    [I] Flags to pass directly to CompareStringW().
5716  *
5717  * RETURNS
5718  *  VARCMP_LT, VARCMP_EQ or VARCMP_GT indicating that pbstrLeft is less
5719  *  than, equal to or greater than pbstrRight respectively.
5720  *  VARCMP_NULL is returned if either string is NULL, unless both are NULL
5721  *  in which case VARCMP_EQ is returned.
5722  */
5723 HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFlags)
5724 {
5725     if (!pbstrLeft)
5726     {
5727       if (!pbstrRight || !*pbstrRight)
5728         return VARCMP_EQ;
5729       return VARCMP_NULL;
5730     }
5731     else if (!pbstrRight)
5732     {
5733       if (!*pbstrLeft)
5734         return VARCMP_EQ;
5735       return VARCMP_NULL;
5736     }
5737
5738     return CompareStringW(lcid, dwFlags, pbstrLeft, -1, pbstrRight, -1) - 1;
5739 }
5740
5741 /*
5742  * DATE
5743  */
5744
5745 /******************************************************************************
5746  * VarDateFromUI1 (OLEAUT32.88)
5747  *
5748  * Convert a VT_UI1 to a VT_DATE.
5749  *
5750  * PARAMS
5751  *  bIn      [I] Source
5752  *  pdateOut [O] Destination
5753  *
5754  * RETURNS
5755  *  S_OK.
5756  */
5757 HRESULT WINAPI VarDateFromUI1(BYTE bIn, DATE* pdateOut)
5758 {
5759   return _VarDateFromUI1(bIn, pdateOut);
5760 }
5761
5762 /******************************************************************************
5763  * VarDateFromI2 (OLEAUT32.89)
5764  *
5765  * Convert a VT_I2 to a VT_DATE.
5766  *
5767  * PARAMS
5768  *  sIn      [I] Source
5769  *  pdateOut [O] Destination
5770  *
5771  * RETURNS
5772  *  S_OK.
5773  */
5774 HRESULT WINAPI VarDateFromI2(short sIn, DATE* pdateOut)
5775 {
5776   return _VarDateFromI2(sIn, pdateOut);
5777 }
5778
5779 /******************************************************************************
5780  * VarDateFromI4 (OLEAUT32.90)
5781  *
5782  * Convert a VT_I4 to a VT_DATE.
5783  *
5784  * PARAMS
5785  *  lIn      [I] Source
5786  *  pdateOut [O] Destination
5787  *
5788  * RETURNS
5789  *  S_OK.
5790  */
5791 HRESULT WINAPI VarDateFromI4(LONG lIn, DATE* pdateOut)
5792 {
5793   return _VarDateFromI4(lIn, pdateOut);
5794 }
5795
5796 /******************************************************************************
5797  * VarDateFromR4 (OLEAUT32.91)
5798  *
5799  * Convert a VT_R4 to a VT_DATE.
5800  *
5801  * PARAMS
5802  *  fltIn    [I] Source
5803  *  pdateOut [O] Destination
5804  *
5805  * RETURNS
5806  *  S_OK.
5807  */
5808 HRESULT WINAPI VarDateFromR4(FLOAT fltIn, DATE* pdateOut)
5809 {
5810   return _VarDateFromR4(fltIn, pdateOut);
5811 }
5812
5813 /******************************************************************************
5814  * VarDateFromR8 (OLEAUT32.92)
5815  *
5816  * Convert a VT_R8 to a VT_DATE.
5817  *
5818  * PARAMS
5819  *  dblIn    [I] Source
5820  *  pdateOut [O] Destination
5821  *
5822  * RETURNS
5823  *  S_OK.
5824  */
5825 HRESULT WINAPI VarDateFromR8(double dblIn, DATE* pdateOut)
5826 {
5827   return _VarDateFromR8(dblIn, pdateOut);
5828 }
5829
5830 /**********************************************************************
5831  * VarDateFromDisp (OLEAUT32.95)
5832  *
5833  * Convert a VT_DISPATCH to a VT_DATE.
5834  *
5835  * PARAMS
5836  *  pdispIn  [I] Source
5837  *  lcid     [I] LCID for conversion
5838  *  pdateOut [O] Destination
5839  *
5840  * RETURNS
5841  *  Success: S_OK.
5842  *  Failure: E_INVALIDARG, if the source value is invalid
5843  *           DISP_E_OVERFLOW, if the value will not fit in the destination
5844  *           DISP_E_TYPEMISMATCH, if the type cannot be converted
5845  */
5846 HRESULT WINAPI VarDateFromDisp(IDispatch* pdispIn, LCID lcid, DATE* pdateOut)
5847 {
5848   return _VarDateFromDisp(pdispIn, lcid, pdateOut);
5849 }
5850
5851 /******************************************************************************
5852  * VarDateFromBool (OLEAUT32.96)
5853  *
5854  * Convert a VT_BOOL to a VT_DATE.
5855  *
5856  * PARAMS
5857  *  boolIn   [I] Source
5858  *  pdateOut [O] Destination
5859  *
5860  * RETURNS
5861  *  S_OK.
5862  */
5863 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL boolIn, DATE* pdateOut)
5864 {
5865   return _VarDateFromBool(boolIn, pdateOut);
5866 }
5867
5868 /**********************************************************************
5869  * VarDateFromCy (OLEAUT32.93)
5870  *
5871  * Convert a VT_CY to a VT_DATE.
5872  *
5873  * PARAMS
5874  *  lIn      [I] Source
5875  *  pdateOut [O] Destination
5876  *
5877  * RETURNS
5878  *  S_OK.
5879  */
5880 HRESULT WINAPI VarDateFromCy(CY cyIn, DATE* pdateOut)
5881 {
5882   return _VarDateFromCy(cyIn, pdateOut);
5883 }
5884
5885 /* Date string parsing */
5886 #define DP_TIMESEP 0x01 /* Time separator ( _must_ remain 0x1, used as a bitmask) */
5887 #define DP_DATESEP 0x02 /* Date separator */
5888 #define DP_MONTH   0x04 /* Month name */
5889 #define DP_AM      0x08 /* AM */
5890 #define DP_PM      0x10 /* PM */
5891
5892 typedef struct tagDATEPARSE
5893 {
5894     DWORD dwCount;      /* Number of fields found so far (maximum 6) */
5895     DWORD dwParseFlags; /* Global parse flags (DP_ Flags above) */
5896     DWORD dwFlags[6];   /* Flags for each field */
5897     DWORD dwValues[6];  /* Value of each field */
5898 } DATEPARSE;
5899
5900 #define TIMEFLAG(i) ((dp.dwFlags[i] & DP_TIMESEP) << i)
5901
5902 #define IsLeapYear(y) (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
5903
5904 /* Determine if a day is valid in a given month of a given year */
5905 static BOOL VARIANT_IsValidMonthDay(DWORD day, DWORD month, DWORD year)
5906 {
5907   static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
5908
5909   if (day && month && month < 13)
5910   {
5911     if (day <= days[month] || (month == 2 && day == 29 && IsLeapYear(year)))
5912       return TRUE;
5913   }
5914   return FALSE;
5915 }
5916
5917 /* Possible orders for 3 numbers making up a date */
5918 #define ORDER_MDY 0x01
5919 #define ORDER_YMD 0x02
5920 #define ORDER_YDM 0x04
5921 #define ORDER_DMY 0x08
5922 #define ORDER_MYD 0x10 /* Synthetic order, used only for funky 2 digit dates */
5923
5924 /* Determine a date for a particular locale, from 3 numbers */
5925 static inline HRESULT VARIANT_MakeDate(DATEPARSE *dp, DWORD iDate,
5926                                        DWORD offset, SYSTEMTIME *st)
5927 {
5928   DWORD dwAllOrders, dwTry, dwCount = 0, v1, v2, v3;
5929
5930   if (!dp->dwCount)
5931   {
5932     v1 = 30; /* Default to (Variant) 0 date part */
5933     v2 = 12;
5934     v3 = 1899;
5935     goto VARIANT_MakeDate_OK;
5936   }
5937
5938   v1 = dp->dwValues[offset + 0];
5939   v2 = dp->dwValues[offset + 1];
5940   if (dp->dwCount == 2)
5941   {
5942     SYSTEMTIME current;
5943     GetSystemTime(&current);
5944     v3 = current.wYear;
5945   }
5946   else
5947     v3 = dp->dwValues[offset + 2];
5948
5949   TRACE("(%ld,%ld,%ld,%ld,%ld)\n", v1, v2, v3, iDate, offset);
5950
5951   /* If one number must be a month (Because a month name was given), then only
5952    * consider orders with the month in that position.
5953    * If we took the current year as 'v3', then only allow a year in that position.
5954    */
5955   if (dp->dwFlags[offset + 0] & DP_MONTH)
5956   {
5957     dwAllOrders = ORDER_MDY;
5958   }
5959   else if (dp->dwFlags[offset + 1] & DP_MONTH)
5960   {
5961     dwAllOrders = ORDER_DMY;
5962     if (dp->dwCount > 2)
5963       dwAllOrders |= ORDER_YMD;
5964   }
5965   else if (dp->dwCount > 2 && dp->dwFlags[offset + 2] & DP_MONTH)
5966   {
5967     dwAllOrders = ORDER_YDM;
5968   }
5969   else
5970   {
5971     dwAllOrders = ORDER_MDY|ORDER_DMY;
5972     if (dp->dwCount > 2)
5973       dwAllOrders |= (ORDER_YMD|ORDER_YDM);
5974   }
5975
5976 VARIANT_MakeDate_Start:
5977   TRACE("dwAllOrders is 0x%08lx\n", dwAllOrders);
5978
5979   while (dwAllOrders)
5980   {
5981     DWORD dwTemp;
5982
5983     if (dwCount == 0)
5984     {
5985       /* First: Try the order given by iDate */
5986       switch (iDate)
5987       {
5988       case 0:  dwTry = dwAllOrders & ORDER_MDY; break;
5989       case 1:  dwTry = dwAllOrders & ORDER_DMY; break;
5990       default: dwTry = dwAllOrders & ORDER_YMD; break;
5991       }
5992     }
5993     else if (dwCount == 1)
5994     {
5995       /* Second: Try all the orders compatible with iDate */
5996       switch (iDate)
5997       {
5998       case 0:  dwTry = dwAllOrders & ~(ORDER_DMY|ORDER_YDM); break;
5999       case 1:  dwTry = dwAllOrders & ~(ORDER_MDY|ORDER_YMD|ORDER_MYD); break;
6000       default: dwTry = dwAllOrders & ~(ORDER_DMY|ORDER_YDM); break;
6001       }
6002     }
6003     else
6004     {
6005       /* Finally: Try any remaining orders */
6006       dwTry = dwAllOrders;
6007     }
6008
6009     TRACE("Attempt %ld, dwTry is 0x%08lx\n", dwCount, dwTry);
6010
6011     dwCount++;
6012     if (!dwTry)
6013       continue;
6014
6015 #define DATE_SWAP(x,y) do { dwTemp = x; x = y; y = dwTemp; } while (0)
6016
6017     if (dwTry & ORDER_MDY)
6018     {
6019       if (VARIANT_IsValidMonthDay(v2,v1,v3))
6020       {
6021         DATE_SWAP(v1,v2);
6022         goto VARIANT_MakeDate_OK;
6023       }
6024       dwAllOrders &= ~ORDER_MDY;
6025     }
6026     if (dwTry & ORDER_YMD)
6027     {
6028       if (VARIANT_IsValidMonthDay(v3,v2,v1))
6029       {
6030         DATE_SWAP(v1,v3);
6031         goto VARIANT_MakeDate_OK;
6032       }
6033       dwAllOrders &= ~ORDER_YMD;
6034     }
6035     if (dwTry & ORDER_YDM)
6036     {
6037       if (VARIANT_IsValidMonthDay(v2,v3,v1))
6038       {
6039         DATE_SWAP(v1,v2);
6040         DATE_SWAP(v2,v3);
6041         goto VARIANT_MakeDate_OK;
6042       }
6043       dwAllOrders &= ~ORDER_YDM;
6044     }
6045     if (dwTry & ORDER_DMY)
6046     {
6047       if (VARIANT_IsValidMonthDay(v1,v2,v3))
6048         goto VARIANT_MakeDate_OK;
6049       dwAllOrders &= ~ORDER_DMY;
6050     }
6051     if (dwTry & ORDER_MYD)
6052     {
6053       /* Only occurs if we are trying a 2 year date as M/Y not D/M */
6054       if (VARIANT_IsValidMonthDay(v3,v1,v2))
6055       {
6056         DATE_SWAP(v1,v3);
6057         DATE_SWAP(v2,v3);
6058         goto VARIANT_MakeDate_OK;
6059       }
6060       dwAllOrders &= ~ORDER_MYD;
6061     }
6062   }
6063
6064   if (dp->dwCount == 2)
6065   {
6066     /* We couldn't make a date as D/M or M/D, so try M/Y or Y/M */
6067     v3 = 1; /* 1st of the month */
6068     dwAllOrders = ORDER_YMD|ORDER_MYD;
6069     dp->dwCount = 0; /* Don't return to this code path again */
6070     dwCount = 0;
6071     goto VARIANT_MakeDate_Start;
6072   }
6073
6074   /* No valid dates were able to be constructed */
6075   return DISP_E_TYPEMISMATCH;
6076
6077 VARIANT_MakeDate_OK:
6078
6079   /* Check that the time part is ok */
6080   if (st->wHour > 23 || st->wMinute > 59 || st->wSecond > 59)
6081     return DISP_E_TYPEMISMATCH;
6082
6083   TRACE("Time %d %d %d\n", st->wHour, st->wMinute, st->wSecond);
6084   if (st->wHour < 12 && (dp->dwParseFlags & DP_PM))
6085     st->wHour += 12;
6086   else if (st->wHour == 12 && (dp->dwParseFlags & DP_AM))
6087     st->wHour = 0;
6088   TRACE("Time %d %d %d\n", st->wHour, st->wMinute, st->wSecond);
6089
6090   st->wDay = v1;
6091   st->wMonth = v2;
6092   /* FIXME: For 2 digit dates, I'm not sure if 30 is hard coded or not. It may
6093    * be retrieved from:
6094    * HKCU\Control Panel\International\Calendars\TwoDigitYearMax
6095    * But Wine doesn't have/use that key as at the time of writing.
6096    */
6097   st->wYear = v3 < 30 ? 2000 + v3 : v3 < 100 ? 1900 + v3 : v3;
6098   TRACE("Returning date %ld/%ld/%d\n", v1, v2, st->wYear);
6099   return S_OK;
6100 }
6101
6102 /******************************************************************************
6103  * VarDateFromStr [OLEAUT32.94]
6104  *
6105  * Convert a VT_BSTR to at VT_DATE.
6106  *
6107  * PARAMS
6108  *  strIn    [I] String to convert
6109  *  lcid     [I] Locale identifier for the conversion
6110  *  dwFlags  [I] Flags affecting the conversion (VAR_ flags from "oleauto.h")
6111  *  pdateOut [O] Destination for the converted value
6112  *
6113  * RETURNS
6114  *  Success: S_OK. pdateOut contains the converted value.
6115  *  FAILURE: An HRESULT error code indicating the prolem.
6116  *
6117  * NOTES
6118  *  Any date format that can be created using the date formats from lcid
6119  *  (Either from kernel Nls functions, variant conversion or formatting) is a
6120  *  valid input to this function. In addition, a few more esoteric formats are
6121  *  also supported for compatibility with the native version. The date is
6122  *  interpreted according to the date settings in the control panel, unless
6123  *  the date is invalid in that format, in which the most compatible format
6124  *  that produces a valid date will be used.
6125  */
6126 HRESULT WINAPI VarDateFromStr(OLECHAR* strIn, LCID lcid, ULONG dwFlags, DATE* pdateOut)
6127 {
6128   static const USHORT ParseDateTokens[] =
6129   {
6130     LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME4,
6131     LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8,
6132     LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12,
6133     LOCALE_SMONTHNAME13,
6134     LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
6135     LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
6136     LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
6137     LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12,
6138     LOCALE_SABBREVMONTHNAME13,
6139     LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
6140     LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
6141     LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3,
6142     LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6,
6143     LOCALE_SABBREVDAYNAME7,
6144     LOCALE_S1159, LOCALE_S2359
6145   };
6146   static const BYTE ParseDateMonths[] =
6147   {
6148     1,2,3,4,5,6,7,8,9,10,11,12,13,
6149     1,2,3,4,5,6,7,8,9,10,11,12,13
6150   };
6151   size_t i;
6152   BSTR tokens[sizeof(ParseDateTokens)/sizeof(ParseDateTokens[0])];
6153   DATEPARSE dp;
6154   DWORD dwDateSeps = 0, iDate = 0;
6155   HRESULT hRet = S_OK;
6156
6157   if ((dwFlags & (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY)) ==
6158       (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
6159     return E_INVALIDARG;
6160
6161   if (!strIn)
6162     return DISP_E_TYPEMISMATCH;
6163
6164   *pdateOut = 0.0;
6165
6166   TRACE("(%s,0x%08lx,0x%08lx,%p)\n", debugstr_w(strIn), lcid, dwFlags, pdateOut);
6167
6168   memset(&dp, 0, sizeof(dp));
6169
6170   GetLocaleInfoW(lcid, LOCALE_IDATE|LOCALE_RETURN_NUMBER|(dwFlags & LOCALE_NOUSEROVERRIDE),
6171                  (LPWSTR)&iDate, sizeof(iDate)/sizeof(WCHAR));
6172   TRACE("iDate is %ld\n", iDate);
6173
6174   /* Get the month/day/am/pm tokens for this locale */
6175   for (i = 0; i < sizeof(tokens)/sizeof(tokens[0]); i++)
6176   {
6177     WCHAR buff[128];
6178     LCTYPE lctype =  ParseDateTokens[i] | (dwFlags & LOCALE_NOUSEROVERRIDE);
6179
6180     /* FIXME: Alternate calendars - should use GetCalendarInfo() and/or
6181      *        GetAltMonthNames(). We should really cache these strings too.
6182      */
6183     buff[0] = '\0';
6184     GetLocaleInfoW(lcid, lctype, buff, sizeof(buff)/sizeof(WCHAR));
6185     tokens[i] = SysAllocString(buff);
6186     TRACE("token %d is %s\n", i, debugstr_w(tokens[i]));
6187   }
6188
6189   /* Parse the string into our structure */
6190   while (*strIn)
6191   {
6192     if (dp.dwCount > 6)
6193       break;
6194
6195     if (isdigitW(*strIn))
6196     {
6197       dp.dwValues[dp.dwCount] = strtoulW(strIn, &strIn, 10);
6198       dp.dwCount++;
6199       strIn--;
6200     }
6201     else if (isalpha(*strIn))
6202     {
6203       BOOL bFound = FALSE;
6204
6205       for (i = 0; i < sizeof(tokens)/sizeof(tokens[0]); i++)
6206       {
6207         DWORD dwLen = strlenW(tokens[i]);
6208         if (dwLen && !strncmpiW(strIn, tokens[i], dwLen))
6209         {
6210           if (i <= 25)
6211           {
6212             dp.dwValues[dp.dwCount] = ParseDateMonths[i];
6213             dp.dwFlags[dp.dwCount] |= (DP_MONTH|DP_DATESEP);
6214             dp.dwCount++;
6215           }
6216           else if (i > 39)
6217           {
6218             if (!dp.dwCount || dp.dwParseFlags & (DP_AM|DP_PM))
6219               hRet = DISP_E_TYPEMISMATCH;
6220             else
6221             {
6222               dp.dwFlags[dp.dwCount - 1] |= (i == 40 ? DP_AM : DP_PM);
6223               dp.dwParseFlags |= (i == 40 ? DP_AM : DP_PM);
6224             }
6225           }
6226           strIn += (dwLen - 1);
6227           bFound = TRUE;
6228           break;
6229         }
6230       }
6231
6232       if (!bFound)
6233       {
6234         if ((*strIn == 'a' || *strIn == 'A' || *strIn == 'p' || *strIn == 'P') &&
6235             (dp.dwCount && !(dp.dwParseFlags & (DP_AM|DP_PM))))
6236         {
6237           /* Special case - 'a' and 'p' are recognised as short for am/pm */
6238           if (*strIn == 'a' || *strIn == 'A')
6239           {
6240             dp.dwFlags[dp.dwCount - 1] |= DP_AM;
6241             dp.dwParseFlags |=  DP_AM;
6242           }
6243           else
6244           {
6245             dp.dwFlags[dp.dwCount - 1] |= DP_PM;
6246             dp.dwParseFlags |=  DP_PM;
6247           }
6248           strIn++;
6249         }
6250         else
6251         {
6252           TRACE("No matching token for %s\n", debugstr_w(strIn));
6253           hRet = DISP_E_TYPEMISMATCH;
6254           break;
6255         }
6256       }
6257     }
6258     else if (*strIn == ':' ||  *strIn == '.')
6259     {
6260       if (!dp.dwCount || !strIn[1])
6261         hRet = DISP_E_TYPEMISMATCH;
6262       else
6263         dp.dwFlags[dp.dwCount - 1] |= DP_TIMESEP;
6264     }
6265     else if (*strIn == '-' || *strIn == '/')
6266     {
6267       dwDateSeps++;
6268       if (dwDateSeps > 2 || !dp.dwCount || !strIn[1])
6269         hRet = DISP_E_TYPEMISMATCH;
6270       else
6271         dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP;
6272     }
6273     else if (*strIn == ',' || isspaceW(*strIn))
6274     {
6275       if (*strIn == ',' && !strIn[1])
6276         hRet = DISP_E_TYPEMISMATCH;
6277     }
6278     else
6279     {
6280       hRet = DISP_E_TYPEMISMATCH;
6281     }
6282     strIn++;
6283   }
6284
6285   if (!dp.dwCount || dp.dwCount > 6 ||
6286       (dp.dwCount == 1 && !(dp.dwParseFlags & (DP_AM|DP_PM))))
6287     hRet = DISP_E_TYPEMISMATCH;
6288
6289   if (SUCCEEDED(hRet))
6290   {
6291     SYSTEMTIME st;
6292     DWORD dwOffset = 0; /* Start of date fields in dp.dwValues */
6293
6294     st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
6295
6296     /* Figure out which numbers correspond to which fields.
6297      *
6298      * This switch statement works based on the fact that native interprets any
6299      * fields that are not joined with a time separator ('.' or ':') as date
6300      * fields. Thus we construct a value from 0-32 where each set bit indicates
6301      * a time field. This encapsulates the hundreds of permutations of 2-6 fields.
6302      * For valid permutations, we set dwOffset to point to the first date field
6303      * and shorten dp.dwCount by the number of time fields found. The real
6304      * magic here occurs in VARIANT_MakeDate() above, where we determine what
6305      * each date number must represent in the context of iDate.
6306      */
6307     TRACE("0x%08lx\n", TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4));
6308
6309     switch (TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4))
6310     {
6311     case 0x1: /* TT TTDD TTDDD */
6312       if (dp.dwCount > 3 &&
6313           ((dp.dwFlags[2] & (DP_AM|DP_PM)) || (dp.dwFlags[3] & (DP_AM|DP_PM)) ||
6314           (dp.dwFlags[4] & (DP_AM|DP_PM))))
6315         hRet = DISP_E_TYPEMISMATCH;
6316       else if (dp.dwCount != 2 && dp.dwCount != 4 && dp.dwCount != 5)
6317         hRet = DISP_E_TYPEMISMATCH;
6318       st.wHour = dp.dwValues[0];
6319       st.wMinute  = dp.dwValues[1];
6320       dp.dwCount -= 2;
6321       dwOffset = 2;
6322       break;
6323
6324     case 0x3: /* TTT TTTDD TTTDDD */
6325       if (dp.dwCount > 4 &&
6326           ((dp.dwFlags[3] & (DP_AM|DP_PM)) || (dp.dwFlags[4] & (DP_AM|DP_PM)) ||
6327           (dp.dwFlags[5] & (DP_AM|DP_PM))))
6328         hRet = DISP_E_TYPEMISMATCH;
6329       else if (dp.dwCount != 3 && dp.dwCount != 5 && dp.dwCount != 6)
6330         hRet = DISP_E_TYPEMISMATCH;
6331       st.wHour   = dp.dwValues[0];
6332       st.wMinute = dp.dwValues[1];
6333       st.wSecond = dp.dwValues[2];
6334       dwOffset = 3;
6335       dp.dwCount -= 3;
6336       break;
6337
6338     case 0x4: /* DDTT */
6339       if (dp.dwCount != 4 ||
6340           (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
6341         hRet = DISP_E_TYPEMISMATCH;
6342
6343       st.wHour = dp.dwValues[2];
6344       st.wMinute  = dp.dwValues[3];
6345       dp.dwCount -= 2;
6346       break;
6347
6348    case 0x0: /* T DD DDD TDDD TDDD */
6349       if (dp.dwCount == 1 && (dp.dwParseFlags & (DP_AM|DP_PM)))
6350       {
6351         st.wHour = dp.dwValues[0]; /* T */
6352         dp.dwCount = 0;
6353         break;
6354       }
6355       else if (dp.dwCount > 4 || (dp.dwCount < 3 && dp.dwParseFlags & (DP_AM|DP_PM)))
6356       {
6357         hRet = DISP_E_TYPEMISMATCH;
6358       }
6359       else if (dp.dwCount == 3)
6360       {
6361         if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDD */
6362         {
6363           dp.dwCount = 2;
6364           st.wHour = dp.dwValues[0];
6365           dwOffset = 1;
6366           break;
6367         }
6368         if (dp.dwFlags[2] & (DP_AM|DP_PM)) /* DDT */
6369         {
6370           dp.dwCount = 2;
6371           st.wHour = dp.dwValues[2];
6372           break;
6373         }
6374         else if (dp.dwParseFlags & (DP_AM|DP_PM))
6375           hRet = DISP_E_TYPEMISMATCH;
6376       }
6377       else if (dp.dwCount == 4)
6378       {
6379         dp.dwCount = 3;
6380         if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDDD */
6381         {
6382           st.wHour = dp.dwValues[0];
6383           dwOffset = 1;
6384         }
6385         else if (dp.dwFlags[3] & (DP_AM|DP_PM)) /* DDDT */
6386         {
6387           st.wHour = dp.dwValues[3];
6388         }
6389         else
6390           hRet = DISP_E_TYPEMISMATCH;
6391         break;
6392       }
6393       /* .. fall through .. */
6394
6395     case 0x8: /* DDDTT */
6396       if ((dp.dwCount == 2 && (dp.dwParseFlags & (DP_AM|DP_PM))) ||
6397           (dp.dwCount == 5 && ((dp.dwFlags[0] & (DP_AM|DP_PM)) ||
6398            (dp.dwFlags[1] & (DP_AM|DP_PM)) || (dp.dwFlags[2] & (DP_AM|DP_PM)))) ||
6399            dp.dwCount == 4 || dp.dwCount == 6)
6400         hRet = DISP_E_TYPEMISMATCH;
6401       st.wHour   = dp.dwValues[3];
6402       st.wMinute = dp.dwValues[4];
6403       if (dp.dwCount == 5)
6404         dp.dwCount -= 2;
6405       break;
6406
6407     case 0xC: /* DDTTT */
6408       if (dp.dwCount != 5 ||
6409           (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
6410         hRet = DISP_E_TYPEMISMATCH;
6411       st.wHour   = dp.dwValues[2];
6412       st.wMinute = dp.dwValues[3];
6413       st.wSecond = dp.dwValues[4];
6414       dp.dwCount -= 3;
6415       break;
6416
6417     case 0x18: /* DDDTTT */
6418       if ((dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)) ||
6419           (dp.dwFlags[2] & (DP_AM|DP_PM)))
6420         hRet = DISP_E_TYPEMISMATCH;
6421       st.wHour   = dp.dwValues[3];
6422       st.wMinute = dp.dwValues[4];
6423       st.wSecond = dp.dwValues[5];
6424       dp.dwCount -= 3;
6425       break;
6426
6427     default:
6428       hRet = DISP_E_TYPEMISMATCH;
6429       break;
6430     }
6431
6432     if (SUCCEEDED(hRet))
6433     {
6434       hRet = VARIANT_MakeDate(&dp, iDate, dwOffset, &st);
6435
6436       if (dwFlags & VAR_TIMEVALUEONLY)
6437       {
6438         st.wYear = 1899;
6439         st.wMonth = 12;
6440         st.wDay = 30;
6441       }
6442       else if (dwFlags & VAR_DATEVALUEONLY)
6443        st.wHour = st.wMinute = st.wSecond = 0;
6444
6445       /* Finally, convert the value to a VT_DATE */
6446       if (SUCCEEDED(hRet))
6447         hRet = SystemTimeToVariantTime(&st, pdateOut) ? S_OK : DISP_E_TYPEMISMATCH;
6448     }
6449   }
6450
6451   for (i = 0; i < sizeof(tokens)/sizeof(tokens[0]); i++)
6452     SysFreeString(tokens[i]);
6453   return hRet;
6454 }
6455
6456 /******************************************************************************
6457  * VarDateFromI1 (OLEAUT32.221)
6458  *
6459  * Convert a VT_I1 to a VT_DATE.
6460  *
6461  * PARAMS
6462  *  cIn      [I] Source
6463  *  pdateOut [O] Destination
6464  *
6465  * RETURNS
6466  *  S_OK.
6467  */
6468 HRESULT WINAPI VarDateFromI1(signed char cIn, DATE* pdateOut)
6469 {
6470   return _VarDateFromI1(cIn, pdateOut);
6471 }
6472
6473 /******************************************************************************
6474  * VarDateFromUI2 (OLEAUT32.222)
6475  *
6476  * Convert a VT_UI2 to a VT_DATE.
6477  *
6478  * PARAMS
6479  *  uiIn     [I] Source
6480  *  pdateOut [O] Destination
6481  *
6482  * RETURNS
6483  *  S_OK.
6484  */
6485 HRESULT WINAPI VarDateFromUI2(USHORT uiIn, DATE* pdateOut)
6486 {
6487   return _VarDateFromUI2(uiIn, pdateOut);
6488 }
6489
6490 /******************************************************************************
6491  * VarDateFromUI4 (OLEAUT32.223)
6492  *
6493  * Convert a VT_UI4 to a VT_DATE.
6494  *
6495  * PARAMS
6496  *  ulIn     [I] Source
6497  *  pdateOut [O] Destination
6498  *
6499  * RETURNS
6500  *  S_OK.
6501  */
6502 HRESULT WINAPI VarDateFromUI4(ULONG ulIn, DATE* pdateOut)
6503 {
6504   return _VarDateFromUI4(ulIn, pdateOut);
6505 }
6506
6507 /**********************************************************************
6508  * VarDateFromDec (OLEAUT32.224)
6509  *
6510  * Convert a VT_DECIMAL to a VT_DATE.
6511  *
6512  * PARAMS
6513  *  pdecIn   [I] Source
6514  *  pdateOut [O] Destination
6515  *
6516  * RETURNS
6517  *  S_OK.
6518  */
6519 HRESULT WINAPI VarDateFromDec(DECIMAL *pdecIn, DATE* pdateOut)
6520 {
6521   return _VarDateFromDec(pdecIn, pdateOut);
6522 }
6523
6524 /******************************************************************************
6525  * VarDateFromI8 (OLEAUT32.364)
6526  *
6527  * Convert a VT_I8 to a VT_DATE.
6528  *
6529  * PARAMS
6530  *  llIn     [I] Source
6531  *  pdateOut [O] Destination
6532  *
6533  * RETURNS
6534  *  Success: S_OK.
6535  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
6536  */
6537 HRESULT WINAPI VarDateFromI8(LONG64 llIn, DATE* pdateOut)
6538 {
6539   return _VarDateFromI8(llIn, pdateOut);
6540 }
6541
6542 /******************************************************************************
6543  * VarDateFromUI8 (OLEAUT32.365)
6544  *
6545  * Convert a VT_UI8 to a VT_DATE.
6546  *
6547  * PARAMS
6548  *  ullIn    [I] Source
6549  *  pdateOut [O] Destination
6550  *
6551  * RETURNS
6552  *  Success: S_OK.
6553  *  Failure: DISP_E_OVERFLOW, if the value will not fit in the destination
6554  */
6555 HRESULT WINAPI VarDateFromUI8(ULONG64 ullIn, DATE* pdateOut)
6556 {
6557   return _VarDateFromUI8(ullIn, pdateOut);
6558 }