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