dlls/propsys/propvar.c

   1 /*
   2  * PropVariant implementation
   3  *
   4  * Copyright 2008 James Hawkins for CodeWeavers
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27
  28 #define NONAMELESSUNION
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "winreg.h"
  34 #include "winuser.h"
  35 #include "shlobj.h"
  36 #include "propvarutil.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(propsys);
  42
  43 static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
  44 {
  45     SYSTEMTIME time;
  46
  47     FileTimeToSystemTime(ft, &time);
  48
  49     switch (vt)
  50     {
  51         case VT_LPSTR:
  52         {
  53             static const char format[] = "%04d/%02d/%02d:%02d:%02d:%02d.%03d";
  54
  55             ppropvarDest->u.pszVal = HeapAlloc(GetProcessHeap(), 0,
  56                                              sizeof(format));
  57             if (!ppropvarDest->u.pszVal)
  58                 return E_OUTOFMEMORY;
  59
  60             snprintf( ppropvarDest->u.pszVal, sizeof(format),
  61                       format,
  62                       time.wYear, time.wMonth, time.wDay,
  63                       time.wHour, time.wMinute, time.wSecond,
  64                       time.wMilliseconds );
  65
  66             return S_OK;
  67         }
  68
  69         default:
  70             FIXME("Unhandled target type: %d\n", vt);
  71     }
  72
  73     return E_FAIL;
  74 }
  75
  76 static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
  77                                      BOOL dest_signed, LONGLONG *res)
  78 {
  79     BOOL src_signed;
  80
  81     switch (pv->vt)
  82     {
  83     case VT_I1:
  84         src_signed = TRUE;
  85         *res = pv->u.cVal;
  86         break;
  87     case VT_UI1:
  88         src_signed = FALSE;
  89         *res = pv->u.bVal;
  90         break;
  91     case VT_I2:
  92         src_signed = TRUE;
  93         *res = pv->u.iVal;
  94         break;
  95     case VT_UI2:
  96         src_signed = FALSE;
  97         *res = pv->u.uiVal;
  98         break;
  99     case VT_I4:
 100         src_signed = TRUE;
 101         *res = pv->u.lVal;
 102         break;
 103     case VT_UI4:
 104         src_signed = FALSE;
 105         *res = pv->u.ulVal;
 106         break;
 107     case VT_I8:
 108         src_signed = TRUE;
 109         *res = pv->u.hVal.QuadPart;
 110         break;
 111     case VT_UI8:
 112         src_signed = FALSE;
 113         *res = pv->u.uhVal.QuadPart;
 114         break;
 115     case VT_EMPTY:
 116         src_signed = FALSE;
 117         *res = 0;
 118         break;
 119     case VT_LPSTR:
 120     {
 121         char *end;
 122         *res = strtoll(pv->u.pszVal, &end, 0);
 123         if (pv->u.pszVal == end)
 124             return DISP_E_TYPEMISMATCH;
 125         src_signed = *res < 0;
 126         break;
 127     }
 128     case VT_LPWSTR:
 129     case VT_BSTR:
 130     {
 131         WCHAR *end;
 132         *res = strtolW(pv->u.pwszVal, &end, 0);
 133         if (pv->u.pwszVal == end)
 134             return DISP_E_TYPEMISMATCH;
 135         src_signed = *res < 0;
 136         break;
 137     }
 138     default:
 139         FIXME("unhandled vt %d\n", pv->vt);
 140         return E_NOTIMPL;
 141     }
 142
 143     if (*res < 0 && src_signed != dest_signed)
 144         return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 145
 146     if (dest_bits < 64)
 147     {
 148         if (dest_signed)
 149         {
 150             if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
 151                 *res < ((LONGLONG)-1 << (dest_bits-1)))
 152                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 153         }
 154         else
 155         {
 156             if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
 157                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 158         }
 159     }
 160
 161     return S_OK;
 162 }
 163
 164 HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
 165 {
 166     LONGLONG res;
 167     HRESULT hr;
 168
 169     TRACE("%p,%p\n", propvarIn, ret);
 170
 171     hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
 172     if (SUCCEEDED(hr)) *ret = (SHORT)res;
 173     return hr;
 174 }
 175
 176 HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
 177 {
 178     LONGLONG res;
 179     HRESULT hr;
 180
 181     TRACE("%p,%p\n", propvarIn, ret);
 182
 183     hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
 184     if (SUCCEEDED(hr)) *ret = (LONG)res;
 185     return hr;
 186 }
 187
 188 HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
 189 {
 190     LONGLONG res;
 191     HRESULT hr;
 192
 193     TRACE("%p,%p\n", propvarIn, ret);
 194
 195     hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
 196     if (SUCCEEDED(hr)) *ret = (LONGLONG)res;
 197     return hr;
 198 }
 199
 200 HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
 201 {
 202     LONGLONG res;
 203     HRESULT hr;
 204
 205     TRACE("%p,%p\n", propvarIn, ret);
 206
 207     hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
 208     if (SUCCEEDED(hr)) *ret = (USHORT)res;
 209     return hr;
 210 }
 211
 212 HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
 213 {
 214     LONGLONG res;
 215     HRESULT hr;
 216
 217     TRACE("%p,%p\n", propvarIn, ret);
 218
 219     hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
 220     if (SUCCEEDED(hr)) *ret = (ULONG)res;
 221     return hr;
 222 }
 223
 224 HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
 225 {
 226     LONGLONG res;
 227     HRESULT hr;
 228
 229     TRACE("%p,%p\n", propvarIn, ret);
 230
 231     hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
 232     if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
 233     return hr;
 234 }
 235
 236 HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
 237 {
 238     WCHAR *res = NULL;
 239     HRESULT hr = S_OK;
 240
 241     TRACE("%p,%p semi-stub\n", propvarIn, ret);
 242
 243     switch(propvarIn->vt)
 244     {
 245         case VT_NULL:
 246             res = CoTaskMemAlloc(1*sizeof(WCHAR));
 247             res[0] = '\0';
 248             break;
 249
 250         case VT_LPSTR:
 251             if(propvarIn->u.pszVal)
 252             {
 253                 DWORD len;
 254
 255                 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, NULL, 0);
 256                 res = CoTaskMemAlloc(len*sizeof(WCHAR));
 257                 if(!res)
 258                     return E_OUTOFMEMORY;
 259
 260                 MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, res, len);
 261             }
 262             break;
 263
 264         case VT_LPWSTR:
 265         case VT_BSTR:
 266             if (propvarIn->u.pwszVal)
 267             {
 268                 DWORD size = (lstrlenW(propvarIn->u.pwszVal) + 1) * sizeof(WCHAR);
 269                 res = CoTaskMemAlloc(size);
 270                 if(!res) return E_OUTOFMEMORY;
 271                 memcpy(res, propvarIn->u.pwszVal, size);
 272             }
 273             break;
 274
 275         default:
 276             FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
 277             hr = E_FAIL;
 278             break;
 279     }
 280
 281     *ret = res;
 282
 283     return hr;
 284 }
 285
 286 /******************************************************************
 287  *  PropVariantChangeType   (PROPSYS.@)
 288  */
 289 HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
 290                                      PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
 291 {
 292     HRESULT hr;
 293
 294     FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
 295           propvarSrc->vt, flags, vt);
 296
 297     if (vt == propvarSrc->vt)
 298         return PropVariantCopy(ppropvarDest, propvarSrc);
 299
 300     if (propvarSrc->vt == VT_FILETIME)
 301         return PROPVAR_ConvertFILETIME(&propvarSrc->u.filetime, ppropvarDest, vt);
 302
 303     switch (vt)
 304     {
 305     case VT_I1:
 306     {
 307         LONGLONG res;
 308
 309         hr = PROPVAR_ConvertNumber(propvarSrc, 8, TRUE, &res);
 310         if (SUCCEEDED(hr))
 311         {
 312             ppropvarDest->vt = VT_I1;
 313             ppropvarDest->u.cVal = (char)res;
 314         }
 315         return hr;
 316     }
 317
 318     case VT_UI1:
 319     {
 320         LONGLONG res;
 321
 322         hr = PROPVAR_ConvertNumber(propvarSrc, 8, FALSE, &res);
 323         if (SUCCEEDED(hr))
 324         {
 325             ppropvarDest->vt = VT_UI1;
 326             ppropvarDest->u.bVal = (UCHAR)res;
 327         }
 328         return hr;
 329     }
 330
 331     case VT_I2:
 332     {
 333         SHORT res;
 334         hr = PropVariantToInt16(propvarSrc, &res);
 335         if (SUCCEEDED(hr))
 336         {
 337             ppropvarDest->vt = VT_I2;
 338             ppropvarDest->u.iVal = res;
 339         }
 340         return hr;
 341     }
 342     case VT_UI2:
 343     {
 344         USHORT res;
 345         hr = PropVariantToUInt16(propvarSrc, &res);
 346         if (SUCCEEDED(hr))
 347         {
 348             ppropvarDest->vt = VT_UI2;
 349             ppropvarDest->u.uiVal = res;
 350         }
 351         return hr;
 352     }
 353     case VT_I4:
 354     {
 355         LONG res;
 356         hr = PropVariantToInt32(propvarSrc, &res);
 357         if (SUCCEEDED(hr))
 358         {
 359             ppropvarDest->vt = VT_I4;
 360             ppropvarDest->u.lVal = res;
 361         }
 362         return hr;
 363     }
 364     case VT_UI4:
 365     {
 366         ULONG res;
 367         hr = PropVariantToUInt32(propvarSrc, &res);
 368         if (SUCCEEDED(hr))
 369         {
 370             ppropvarDest->vt = VT_UI4;
 371             ppropvarDest->u.ulVal = res;
 372         }
 373         return hr;
 374     }
 375     case VT_I8:
 376     {
 377         LONGLONG res;
 378         hr = PropVariantToInt64(propvarSrc, &res);
 379         if (SUCCEEDED(hr))
 380         {
 381             ppropvarDest->vt = VT_I8;
 382             ppropvarDest->u.hVal.QuadPart = res;
 383         }
 384         return hr;
 385     }
 386     case VT_UI8:
 387     {
 388         ULONGLONG res;
 389         hr = PropVariantToUInt64(propvarSrc, &res);
 390         if (SUCCEEDED(hr))
 391         {
 392             ppropvarDest->vt = VT_UI8;
 393             ppropvarDest->u.uhVal.QuadPart = res;
 394         }
 395         return hr;
 396     }
 397
 398     case VT_LPWSTR:
 399     case VT_BSTR:
 400     {
 401         WCHAR *res;
 402         hr = PropVariantToStringAlloc(propvarSrc, &res);
 403         if (SUCCEEDED(hr))
 404         {
 405             ppropvarDest->vt = VT_LPWSTR;
 406             ppropvarDest->u.pwszVal = res;
 407         }
 408         return hr;
 409     }
 410
 411     case VT_LPSTR:
 412     {
 413         WCHAR *resW;
 414         hr = PropVariantToStringAlloc(propvarSrc, &resW);
 415         if (SUCCEEDED(hr))
 416         {
 417             char *res;
 418             DWORD len;
 419
 420             len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
 421             res = CoTaskMemAlloc(len);
 422             if (res)
 423             {
 424                 WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
 425                 ppropvarDest->vt = VT_LPSTR;
 426                 ppropvarDest->u.pszVal = res;
 427             }
 428             else
 429                 hr = E_OUTOFMEMORY;
 430
 431             CoTaskMemFree(resW);
 432         }
 433         return hr;
 434     }
 435
 436     default:
 437         FIXME("Unhandled dest type: %d\n", vt);
 438         return E_FAIL;
 439     }
 440 }
 441
 442 static void PROPVAR_GUIDToWSTR(REFGUID guid, WCHAR *str)
 443 {
 444     static const WCHAR format[] = {'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X',
 445         '-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X',
 446         '%','0','2','X','%','0','2','X','%','0','2','X','}',0};
 447
 448     sprintfW(str, format, guid->Data1, guid->Data2, guid->Data3,
 449             guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 450             guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 451 }
 452
 453 HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
 454 {
 455     TRACE("(%p %p)\n", guid, ppropvar);
 456
 457     if(!guid)
 458         return E_FAIL;
 459
 460     ppropvar->vt = VT_LPWSTR;
 461     ppropvar->u.pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR));
 462     if(!ppropvar->u.pwszVal)
 463         return E_OUTOFMEMORY;
 464
 465     PROPVAR_GUIDToWSTR(guid, ppropvar->u.pwszVal);
 466     return S_OK;
 467 }
 468
 469 HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
 470 {
 471     TRACE("(%p %p)\n", guid, pvar);
 472
 473     if(!guid) {
 474         FIXME("guid == NULL\n");
 475         return E_FAIL;
 476     }
 477
 478     V_VT(pvar) = VT_BSTR;
 479     V_BSTR(pvar) = SysAllocStringLen(NULL, 38);
 480     if(!V_BSTR(pvar))
 481         return E_OUTOFMEMORY;
 482
 483     PROPVAR_GUIDToWSTR(guid, V_BSTR(pvar));
 484     return S_OK;
 485 }
 486
 487 HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
 488 {
 489     TRACE("(%p %u %p)\n", pv, cb, ppropvar);
 490
 491     ppropvar->u.caub.pElems = CoTaskMemAlloc(cb);
 492     if(!ppropvar->u.caub.pElems)
 493         return E_OUTOFMEMORY;
 494
 495     ppropvar->vt = VT_VECTOR|VT_UI1;
 496     ppropvar->u.caub.cElems = cb;
 497     memcpy(ppropvar->u.caub.pElems, pv, cb);
 498     return S_OK;
 499 }
 500
 501 HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
 502 {
 503     SAFEARRAY *arr;
 504     void *data;
 505     HRESULT hres;
 506
 507     TRACE("(%p %u %p)\n", pv, cb, pvar);
 508
 509     arr = SafeArrayCreateVector(VT_UI1, 0, cb);
 510     if(!arr)
 511         return E_OUTOFMEMORY;
 512
 513     hres = SafeArrayAccessData(arr, &data);
 514     if(FAILED(hres)) {
 515         SafeArrayDestroy(arr);
 516         return hres;
 517     }
 518
 519     memcpy(data, pv, cb);
 520
 521     hres = SafeArrayUnaccessData(arr);
 522     if(FAILED(hres)) {
 523         SafeArrayDestroy(arr);
 524         return hres;
 525     }
 526
 527     V_VT(pvar) = VT_ARRAY|VT_UI1;
 528     V_ARRAY(pvar) = arr;
 529     return S_OK;
 530 }
 531
 532 static inline DWORD PROPVAR_HexToNum(const WCHAR *hex)
 533 {
 534     DWORD ret;
 535
 536     if(hex[0]>='0' && hex[0]<='9')
 537         ret = hex[0]-'0';
 538     else if(hex[0]>='a' && hex[0]<='f')
 539         ret = hex[0]-'a'+10;
 540     else if(hex[0]>='A' && hex[0]<='F')
 541         ret = hex[0]-'A'+10;
 542     else
 543         return -1;
 544
 545     ret <<= 4;
 546     if(hex[1]>='0' && hex[1]<='9')
 547         return ret + hex[1]-'0';
 548     else if(hex[1]>='a' && hex[1]<='f')
 549         return ret + hex[1]-'a'+10;
 550     else if(hex[1]>='A' && hex[1]<='F')
 551         return ret + hex[1]-'A'+10;
 552     else
 553         return -1;
 554 }
 555
 556 static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
 557 {
 558     DWORD i, val=0;
 559     const WCHAR *p;
 560
 561     memset(guid, 0, sizeof(GUID));
 562
 563     if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
 564             || str[19]!='-' || str[24]!='-' || str[37]!='}') {
 565         WARN("Error parsing %s\n", debugstr_w(str));
 566         return E_INVALIDARG;
 567     }
 568
 569     p = str+1;
 570     for(i=0; i<4 && val!=-1; i++) {
 571         val = PROPVAR_HexToNum(p);
 572         guid->Data1 = (guid->Data1<<8) + val;
 573         p += 2;
 574     }
 575     p++;
 576     for(i=0; i<2 && val!=-1; i++) {
 577         val = PROPVAR_HexToNum(p);
 578         guid->Data2 = (guid->Data2<<8) + val;
 579         p += 2;
 580     }
 581     p++;
 582     for(i=0; i<2 && val!=-1; i++) {
 583         val = PROPVAR_HexToNum(p);
 584         guid->Data3 = (guid->Data3<<8) + val;
 585         p += 2;
 586     }
 587     p++;
 588     for(i=0; i<8 && val!=-1; i++) {
 589         if(i == 2)
 590             p++;
 591
 592         val = guid->Data4[i] = PROPVAR_HexToNum(p);
 593         p += 2;
 594     }
 595
 596     if(val == -1) {
 597         WARN("Error parsing %s\n", debugstr_w(str));
 598         memset(guid, 0, sizeof(GUID));
 599         return E_INVALIDARG;
 600     }
 601     return S_OK;
 602 }
 603
 604 HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
 605 {
 606     TRACE("%p %p)\n", ppropvar, guid);
 607
 608     switch(ppropvar->vt) {
 609     case VT_BSTR:
 610         return PROPVAR_WCHARToGUID(ppropvar->u.bstrVal, SysStringLen(ppropvar->u.bstrVal), guid);
 611     case VT_LPWSTR:
 612         return PROPVAR_WCHARToGUID(ppropvar->u.pwszVal, strlenW(ppropvar->u.pwszVal), guid);
 613
 614     default:
 615         FIXME("unsupported vt: %d\n", ppropvar->vt);
 616         return E_NOTIMPL;
 617     }
 618 }
 619
 620 HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
 621 {
 622     TRACE("(%p %p)\n", pvar, guid);
 623
 624     switch(V_VT(pvar)) {
 625     case VT_BSTR: {
 626         HRESULT hres = PROPVAR_WCHARToGUID(V_BSTR(pvar), SysStringLen(V_BSTR(pvar)), guid);
 627         if(hres == E_INVALIDARG)
 628             return E_FAIL;
 629         return hres;
 630     }
 631
 632     default:
 633         FIXME("unsupported vt: %d\n", V_VT(pvar));
 634         return E_NOTIMPL;
 635     }
 636 }
 637
 638 static BOOL isemptyornull(const PROPVARIANT *propvar)
 639 {
 640     if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
 641         return TRUE;
 642     if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
 643     {
 644         int i;
 645         for (i=0; i<propvar->u.parray->cDims; i++)
 646         {
 647             if (propvar->u.parray->rgsabound[i].cElements != 0)
 648                 break;
 649         }
 650         return i == propvar->u.parray->cDims;
 651     }
 652     /* FIXME: vectors, byrefs, errors? */
 653     return FALSE;
 654 }
 655
 656 INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2,
 657     PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
 658 {
 659     const PROPVARIANT *propvar2_converted;
 660     PROPVARIANT propvar2_static;
 661     HRESULT hr;
 662     INT res=-1;
 663
 664     TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);
 665
 666     if (isemptyornull(propvar1))
 667     {
 668         if (isemptyornull(propvar2))
 669             return 0;
 670         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
 671     }
 672
 673     if (isemptyornull(propvar2))
 674         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;
 675
 676     if (propvar1->vt != propvar2->vt)
 677     {
 678         hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);
 679
 680         if (FAILED(hr))
 681             return -1;
 682
 683         propvar2_converted = &propvar2_static;
 684     }
 685     else
 686         propvar2_converted = propvar2;
 687
 688 #define CMP_INT_VALUE(var) do { \
 689     if (propvar1->u.var > propvar2_converted->u.var) \
 690         res = 1; \
 691     else if (propvar1->u.var < propvar2_converted->u.var) \
 692         res = -1; \
 693     else \
 694         res = 0; \
 695     } while (0)
 696
 697     switch (propvar1->vt)
 698     {
 699     case VT_I1:
 700         CMP_INT_VALUE(cVal);
 701         break;
 702     case VT_UI1:
 703         CMP_INT_VALUE(bVal);
 704         break;
 705     case VT_I2:
 706         CMP_INT_VALUE(iVal);
 707         break;
 708     case VT_UI2:
 709         CMP_INT_VALUE(uiVal);
 710         break;
 711     case VT_I4:
 712         CMP_INT_VALUE(lVal);
 713         break;
 714     case VT_UI4:
 715         CMP_INT_VALUE(uiVal);
 716         break;
 717     case VT_I8:
 718         CMP_INT_VALUE(hVal.QuadPart);
 719         break;
 720     case VT_UI8:
 721         CMP_INT_VALUE(uhVal.QuadPart);
 722         break;
 723     case VT_BSTR:
 724     case VT_LPWSTR:
 725         /* FIXME: Use other string flags. */
 726         if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
 727             res = lstrcmpiW(propvar1->u.bstrVal, propvar2_converted->u.bstrVal);
 728         else
 729             res = lstrcmpW(propvar1->u.bstrVal, propvar2_converted->u.bstrVal);
 730         break;
 731     case VT_LPSTR:
 732         /* FIXME: Use other string flags. */
 733         if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
 734             res = lstrcmpiA(propvar1->u.pszVal, propvar2_converted->u.pszVal);
 735         else
 736             res = lstrcmpA(propvar1->u.pszVal, propvar2_converted->u.pszVal);
 737         break;
 738     default:
 739         FIXME("vartype %d not handled\n", propvar1->vt);
 740         res = -1;
 741         break;
 742     }
 743
 744     if (propvar2_converted == &propvar2_static)
 745         PropVariantClear(&propvar2_static);
 746
 747     return res;
 748 }