propvar.c 22.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * PropVariant implementation
 *
 * Copyright 2008 James Hawkins for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

21

22 23
#include <stdarg.h>
#include <stdio.h>
24
#include <stdlib.h>
25 26 27 28 29 30 31 32 33 34

#define NONAMELESSUNION

#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winreg.h"
#include "winuser.h"
#include "shlobj.h"
#include "propvarutil.h"
35
#include "strsafe.h"
36 37 38 39 40

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(propsys);

41
static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
42 43 44
{
    SYSTEMTIME time;

45
    FileTimeToSystemTime(ft, &time);
46 47 48 49

    switch (vt)
    {
        case VT_LPSTR:
50 51
            ppropvarDest->pszVal = HeapAlloc(GetProcessHeap(), 0, 64);
            if (!ppropvarDest->pszVal)
52 53
                return E_OUTOFMEMORY;

54
            sprintf( ppropvarDest->pszVal, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
55 56 57
                      time.wYear, time.wMonth, time.wDay,
                      time.wHour, time.wMinute, time.wSecond,
                      time.wMilliseconds );
58 59 60 61 62 63 64 65 66 67

            return S_OK;

        default:
            FIXME("Unhandled target type: %d\n", vt);
    }

    return E_FAIL;
}

68
static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
69
                                     BOOL dest_signed, LONGLONG *res)
70
{
71
    BOOL src_signed;
72 73 74 75

    switch (pv->vt)
    {
    case VT_I1:
76
        src_signed = TRUE;
77
        *res = pv->cVal;
78 79
        break;
    case VT_UI1:
80
        src_signed = FALSE;
81
        *res = pv->bVal;
82 83
        break;
    case VT_I2:
84
        src_signed = TRUE;
85
        *res = pv->iVal;
86 87
        break;
    case VT_UI2:
88
        src_signed = FALSE;
89
        *res = pv->uiVal;
90 91
        break;
    case VT_I4:
92
        src_signed = TRUE;
93
        *res = pv->lVal;
94 95
        break;
    case VT_UI4:
96
        src_signed = FALSE;
97
        *res = pv->ulVal;
98 99
        break;
    case VT_I8:
100
        src_signed = TRUE;
101
        *res = pv->hVal.QuadPart;
102 103
        break;
    case VT_UI8:
104
        src_signed = FALSE;
105
        *res = pv->uhVal.QuadPart;
106 107
        break;
    case VT_EMPTY:
108
        src_signed = FALSE;
109 110
        *res = 0;
        break;
111 112 113
    case VT_LPSTR:
    {
        char *end;
114 115
        *res = strtoll(pv->pszVal, &end, 0);
        if (pv->pszVal == end)
116 117 118 119 120 121 122 123
            return DISP_E_TYPEMISMATCH;
        src_signed = *res < 0;
        break;
    }
    case VT_LPWSTR:
    case VT_BSTR:
    {
        WCHAR *end;
124 125
        *res = wcstol(pv->pwszVal, &end, 0);
        if (pv->pwszVal == end)
126 127 128 129
            return DISP_E_TYPEMISMATCH;
        src_signed = *res < 0;
        break;
    }
130 131 132
    case VT_R8:
    {
        src_signed = TRUE;
133
        *res = pv->dblVal;
134 135
        break;
    }
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
    default:
        FIXME("unhandled vt %d\n", pv->vt);
        return E_NOTIMPL;
    }

    if (*res < 0 && src_signed != dest_signed)
        return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);

    if (dest_bits < 64)
    {
        if (dest_signed)
        {
            if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
                *res < ((LONGLONG)-1 << (dest_bits-1)))
                return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
        }
        else
        {
            if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
                return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
        }
    }

    return S_OK;
}

162 163 164 165 166 167 168 169 170 171 172 173
HRESULT WINAPI PropVariantToDouble(REFPROPVARIANT propvarIn, double *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("(%p, %p)\n", propvarIn, ret);

    hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
    if (SUCCEEDED(hr)) *ret = (double)res;
    return hr;
}

174 175 176 177 178 179 180
HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

181
    hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
182 183 184 185 186 187 188 189 190 191 192
    if (SUCCEEDED(hr)) *ret = (SHORT)res;
    return hr;
}

HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

193
    hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
194 195 196 197 198 199 200 201 202 203 204
    if (SUCCEEDED(hr)) *ret = (LONG)res;
    return hr;
}

HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

205
    hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
206
    if (SUCCEEDED(hr)) *ret = res;
207 208 209 210 211 212 213 214 215 216
    return hr;
}

HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

217
    hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
218 219 220 221 222 223 224 225 226 227 228
    if (SUCCEEDED(hr)) *ret = (USHORT)res;
    return hr;
}

HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

229
    hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
230 231 232 233 234 235 236 237 238 239 240
    if (SUCCEEDED(hr)) *ret = (ULONG)res;
    return hr;
}

HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

241
    hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
242 243 244 245
    if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
    return hr;
}

246 247 248 249 250 251 252 253 254 255 256 257
HRESULT WINAPI PropVariantToBoolean(REFPROPVARIANT propvarIn, BOOL *ret)
{
    LONGLONG res;
    HRESULT hr;

    TRACE("%p,%p\n", propvarIn, ret);

    *ret = FALSE;

    switch (propvarIn->vt)
    {
        case VT_BOOL:
258
            *ret = propvarIn->boolVal == VARIANT_TRUE;
259 260 261 262
            return S_OK;

        case VT_LPWSTR:
        case VT_BSTR:
263
            if (!propvarIn->pwszVal)
264 265
                return DISP_E_TYPEMISMATCH;

266
            if (!lstrcmpiW(propvarIn->pwszVal, L"true") || !lstrcmpW(propvarIn->pwszVal, L"#TRUE#"))
267 268 269 270 271
            {
                *ret = TRUE;
                return S_OK;
            }

272
            if (!lstrcmpiW(propvarIn->pwszVal, L"false") || !lstrcmpW(propvarIn->pwszVal, L"#FALSE#"))
273 274 275 276 277 278 279
            {
                *ret = FALSE;
                return S_OK;
            }
            break;

         case VT_LPSTR:
280
            if (!propvarIn->pszVal)
281 282
                return DISP_E_TYPEMISMATCH;

283
            if (!lstrcmpiA(propvarIn->pszVal, "true") || !lstrcmpA(propvarIn->pszVal, "#TRUE#"))
284 285 286 287 288
            {
                *ret = TRUE;
                return S_OK;
            }

289
            if (!lstrcmpiA(propvarIn->pszVal, "false") || !lstrcmpA(propvarIn->pszVal, "#FALSE#"))
290 291 292 293 294 295 296
            {
                *ret = FALSE;
                return S_OK;
            }
            break;
    }

297
    hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
298 299 300 301
    *ret = !!res;
    return hr;
}

302 303 304 305 306 307 308 309 310
HRESULT WINAPI PropVariantToBuffer(REFPROPVARIANT propvarIn, void *ret, UINT cb)
{
    HRESULT hr = S_OK;

    TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);

    switch(propvarIn->vt)
    {
        case VT_VECTOR|VT_UI1:
311
            if(cb > propvarIn->caub.cElems)
312
                return E_FAIL;
313
            memcpy(ret, propvarIn->caub.pElems, cb);
314 315 316 317 318 319 320 321 322 323 324 325 326 327
            break;
        case VT_ARRAY|VT_UI1:
            FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
            hr = E_NOTIMPL;
            break;
        default:
            WARN("Unexpected type: %x\n", propvarIn->vt);
            hr = E_INVALIDARG;
    }

    return hr;
}


328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
HRESULT WINAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
{
    HRESULT hr;
    WCHAR *stringW = NULL;

    TRACE("(%p, %p, %d)\n", propvarIn, ret, cch);

    ret[0] = '\0';

    if(!cch)
        return E_INVALIDARG;

    hr = PropVariantToStringAlloc(propvarIn, &stringW);
    if(SUCCEEDED(hr))
    {
        if(lstrlenW(stringW) >= cch)
            hr = STRSAFE_E_INSUFFICIENT_BUFFER;
        lstrcpynW(ret, stringW, cch);
        CoTaskMemFree(stringW);
    }

    return hr;
}

352 353 354 355 356 357 358 359 360
HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
{
    WCHAR *res = NULL;
    HRESULT hr = S_OK;

    TRACE("%p,%p semi-stub\n", propvarIn, ret);

    switch(propvarIn->vt)
    {
361
        case VT_EMPTY:
362 363 364 365
        case VT_NULL:
            res = CoTaskMemAlloc(1*sizeof(WCHAR));
            res[0] = '\0';
            break;
366

367
        case VT_LPSTR:
368
            if(propvarIn->pszVal)
369 370 371
            {
                DWORD len;

372
                len = MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, NULL, 0);
373 374 375 376
                res = CoTaskMemAlloc(len*sizeof(WCHAR));
                if(!res)
                    return E_OUTOFMEMORY;

377
                MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, res, len);
378 379
            }
            break;
380 381 382

        case VT_LPWSTR:
        case VT_BSTR:
383
            if (propvarIn->pwszVal)
384
            {
385
                DWORD size = (lstrlenW(propvarIn->pwszVal) + 1) * sizeof(WCHAR);
386 387
                res = CoTaskMemAlloc(size);
                if(!res) return E_OUTOFMEMORY;
388
                memcpy(res, propvarIn->pwszVal, size);
389 390 391
            }
            break;

392 393 394 395 396 397 398 399 400 401 402
        default:
            FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
            hr = E_FAIL;
            break;
    }

    *ret = res;

    return hr;
}

403 404 405 406
PCWSTR WINAPI PropVariantToStringWithDefault(REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
{
    if (propvarIn->vt == VT_BSTR)
    {
407
        if (propvarIn->bstrVal == NULL)
408
            return L"";
409

410
        return propvarIn->bstrVal;
411 412
    }

413 414
    if (propvarIn->vt == VT_LPWSTR && propvarIn->pwszVal != NULL)
        return propvarIn->pwszVal;
415 416 417 418 419

    return pszDefault;
}


420 421 422 423 424 425
/******************************************************************
 *  PropVariantChangeType   (PROPSYS.@)
 */
HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
                                     PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
{
426 427
    HRESULT hr;

428 429 430
    FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
          propvarSrc->vt, flags, vt);

431
    if (vt == propvarSrc->vt)
432 433
        return PropVariantCopy(ppropvarDest, propvarSrc);

434
    if (propvarSrc->vt == VT_FILETIME)
435
        return PROPVAR_ConvertFILETIME(&propvarSrc->filetime, ppropvarDest, vt);
436

437 438
    switch (vt)
    {
439 440 441 442 443 444 445 446
    case VT_I1:
    {
        LONGLONG res;

        hr = PROPVAR_ConvertNumber(propvarSrc, 8, TRUE, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I1;
447
            ppropvarDest->cVal = (char)res;
448 449 450 451 452 453 454 455 456 457 458 459
        }
        return hr;
    }

    case VT_UI1:
    {
        LONGLONG res;

        hr = PROPVAR_ConvertNumber(propvarSrc, 8, FALSE, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI1;
460
            ppropvarDest->bVal = (UCHAR)res;
461 462 463 464
        }
        return hr;
    }

465 466 467 468 469 470 471
    case VT_I2:
    {
        SHORT res;
        hr = PropVariantToInt16(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I2;
472
            ppropvarDest->iVal = res;
473 474 475 476 477 478 479 480 481 482
        }
        return hr;
    }
    case VT_UI2:
    {
        USHORT res;
        hr = PropVariantToUInt16(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI2;
483
            ppropvarDest->uiVal = res;
484 485 486 487 488 489 490 491 492 493
        }
        return hr;
    }
    case VT_I4:
    {
        LONG res;
        hr = PropVariantToInt32(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I4;
494
            ppropvarDest->lVal = res;
495 496 497 498 499 500 501 502 503 504
        }
        return hr;
    }
    case VT_UI4:
    {
        ULONG res;
        hr = PropVariantToUInt32(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI4;
505
            ppropvarDest->ulVal = res;
506 507 508 509 510 511 512 513 514 515
        }
        return hr;
    }
    case VT_I8:
    {
        LONGLONG res;
        hr = PropVariantToInt64(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I8;
516
            ppropvarDest->hVal.QuadPart = res;
517 518 519 520 521 522 523 524 525 526
        }
        return hr;
    }
    case VT_UI8:
    {
        ULONGLONG res;
        hr = PropVariantToUInt64(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI8;
527
            ppropvarDest->uhVal.QuadPart = res;
528 529 530
        }
        return hr;
    }
531

532
    case VT_LPWSTR:
533
    case VT_BSTR:
534 535 536 537 538 539
    {
        WCHAR *res;
        hr = PropVariantToStringAlloc(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_LPWSTR;
540
            ppropvarDest->pwszVal = res;
541 542 543
        }
        return hr;
    }
544

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559
    case VT_LPSTR:
    {
        WCHAR *resW;
        hr = PropVariantToStringAlloc(propvarSrc, &resW);
        if (SUCCEEDED(hr))
        {
            char *res;
            DWORD len;

            len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
            res = CoTaskMemAlloc(len);
            if (res)
            {
                WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
                ppropvarDest->vt = VT_LPSTR;
560
                ppropvarDest->pszVal = res;
561 562 563 564 565 566 567 568 569
            }
            else
                hr = E_OUTOFMEMORY;

            CoTaskMemFree(resW);
        }
        return hr;
    }

570 571 572
    default:
        FIXME("Unhandled dest type: %d\n", vt);
        return E_FAIL;
573 574
    }
}
575 576 577

static void PROPVAR_GUIDToWSTR(REFGUID guid, WCHAR *str)
{
578 579 580
    swprintf(str, 39, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid->Data1,
            guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2],
            guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
581 582 583 584 585 586 587 588 589 590
}

HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
{
    TRACE("(%p %p)\n", guid, ppropvar);

    if(!guid)
        return E_FAIL;

    ppropvar->vt = VT_LPWSTR;
591 592
    ppropvar->pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR));
    if(!ppropvar->pwszVal)
593 594
        return E_OUTOFMEMORY;

595
    PROPVAR_GUIDToWSTR(guid, ppropvar->pwszVal);
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    return S_OK;
}

HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
{
    TRACE("(%p %p)\n", guid, pvar);

    if(!guid) {
        FIXME("guid == NULL\n");
        return E_FAIL;
    }

    V_VT(pvar) = VT_BSTR;
    V_BSTR(pvar) = SysAllocStringLen(NULL, 38);
    if(!V_BSTR(pvar))
        return E_OUTOFMEMORY;

    PROPVAR_GUIDToWSTR(guid, V_BSTR(pvar));
    return S_OK;
}
616 617 618 619 620

HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
{
    TRACE("(%p %u %p)\n", pv, cb, ppropvar);

621 622
    ppropvar->caub.pElems = CoTaskMemAlloc(cb);
    if(!ppropvar->caub.pElems)
623 624 625
        return E_OUTOFMEMORY;

    ppropvar->vt = VT_VECTOR|VT_UI1;
626 627
    ppropvar->caub.cElems = cb;
    memcpy(ppropvar->caub.pElems, pv, cb);
628 629 630
    return S_OK;
}

631 632 633 634
HRESULT WINAPI InitPropVariantFromCLSID(REFCLSID clsid, PROPVARIANT *ppropvar)
{
    TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);

635 636
    ppropvar->puuid = CoTaskMemAlloc(sizeof(*ppropvar->puuid));
    if(!ppropvar->puuid)
637 638 639
        return E_OUTOFMEMORY;

    ppropvar->vt = VT_CLSID;
640
    memcpy(ppropvar->puuid, clsid, sizeof(*ppropvar->puuid));
641 642 643
    return S_OK;
}

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
{
    SAFEARRAY *arr;
    void *data;
    HRESULT hres;

    TRACE("(%p %u %p)\n", pv, cb, pvar);

    arr = SafeArrayCreateVector(VT_UI1, 0, cb);
    if(!arr)
        return E_OUTOFMEMORY;

    hres = SafeArrayAccessData(arr, &data);
    if(FAILED(hres)) {
        SafeArrayDestroy(arr);
        return hres;
    }

    memcpy(data, pv, cb);

    hres = SafeArrayUnaccessData(arr);
    if(FAILED(hres)) {
        SafeArrayDestroy(arr);
        return hres;
    }

    V_VT(pvar) = VT_ARRAY|VT_UI1;
    V_ARRAY(pvar) = arr;
    return S_OK;
}
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752

static inline DWORD PROPVAR_HexToNum(const WCHAR *hex)
{
    DWORD ret;

    if(hex[0]>='0' && hex[0]<='9')
        ret = hex[0]-'0';
    else if(hex[0]>='a' && hex[0]<='f')
        ret = hex[0]-'a'+10;
    else if(hex[0]>='A' && hex[0]<='F')
        ret = hex[0]-'A'+10;
    else
        return -1;

    ret <<= 4;
    if(hex[1]>='0' && hex[1]<='9')
        return ret + hex[1]-'0';
    else if(hex[1]>='a' && hex[1]<='f')
        return ret + hex[1]-'a'+10;
    else if(hex[1]>='A' && hex[1]<='F')
        return ret + hex[1]-'A'+10;
    else
        return -1;
}

static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
{
    DWORD i, val=0;
    const WCHAR *p;

    memset(guid, 0, sizeof(GUID));

    if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
            || str[19]!='-' || str[24]!='-' || str[37]!='}') {
        WARN("Error parsing %s\n", debugstr_w(str));
        return E_INVALIDARG;
    }

    p = str+1;
    for(i=0; i<4 && val!=-1; i++) {
        val = PROPVAR_HexToNum(p);
        guid->Data1 = (guid->Data1<<8) + val;
        p += 2;
    }
    p++;
    for(i=0; i<2 && val!=-1; i++) {
        val = PROPVAR_HexToNum(p);
        guid->Data2 = (guid->Data2<<8) + val;
        p += 2;
    }
    p++;
    for(i=0; i<2 && val!=-1; i++) {
        val = PROPVAR_HexToNum(p);
        guid->Data3 = (guid->Data3<<8) + val;
        p += 2;
    }
    p++;
    for(i=0; i<8 && val!=-1; i++) {
        if(i == 2)
            p++;

        val = guid->Data4[i] = PROPVAR_HexToNum(p);
        p += 2;
    }

    if(val == -1) {
        WARN("Error parsing %s\n", debugstr_w(str));
        memset(guid, 0, sizeof(GUID));
        return E_INVALIDARG;
    }
    return S_OK;
}

HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
{
    TRACE("%p %p)\n", ppropvar, guid);

    switch(ppropvar->vt) {
    case VT_BSTR:
753
        return PROPVAR_WCHARToGUID(ppropvar->bstrVal, SysStringLen(ppropvar->bstrVal), guid);
754
    case VT_LPWSTR:
755
        return PROPVAR_WCHARToGUID(ppropvar->pwszVal, lstrlenW(ppropvar->pwszVal), guid);
756
    case VT_CLSID:
757
        memcpy(guid, ppropvar->puuid, sizeof(*ppropvar->puuid));
758
        return S_OK;
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782

    default:
        FIXME("unsupported vt: %d\n", ppropvar->vt);
        return E_NOTIMPL;
    }
}

HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
{
    TRACE("(%p %p)\n", pvar, guid);

    switch(V_VT(pvar)) {
    case VT_BSTR: {
        HRESULT hres = PROPVAR_WCHARToGUID(V_BSTR(pvar), SysStringLen(V_BSTR(pvar)), guid);
        if(hres == E_INVALIDARG)
            return E_FAIL;
        return hres;
    }

    default:
        FIXME("unsupported vt: %d\n", V_VT(pvar));
        return E_NOTIMPL;
    }
}
783

784
static BOOL isemptyornull(const PROPVARIANT *propvar)
785 786
{
    if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
787
        return TRUE;
788 789 790
    if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
    {
        int i;
791
        for (i=0; i<propvar->parray->cDims; i++)
792
        {
793
            if (propvar->parray->rgsabound[i].cElements != 0)
794 795
                break;
        }
796
        return i == propvar->parray->cDims;
797
    }
798
    if (propvar->vt == VT_CLSID)
799
        return !propvar->puuid;
800

801 802 803 804
    if (propvar->vt & VT_VECTOR)
        return !propvar->caub.cElems;

    /* FIXME: byrefs, errors? */
805
    return FALSE;
806 807
}

808 809 810
INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2,
    PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
{
811 812
    const PROPVARIANT *propvar2_converted;
    PROPVARIANT propvar2_static;
813
    unsigned int count;
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
    HRESULT hr;
    INT res=-1;

    TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);

    if (isemptyornull(propvar1))
    {
        if (isemptyornull(propvar2))
            return 0;
        return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
    }

    if (isemptyornull(propvar2))
        return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;

    if (propvar1->vt != propvar2->vt)
    {
        hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);

        if (FAILED(hr))
            return -1;

        propvar2_converted = &propvar2_static;
    }
    else
        propvar2_converted = propvar2;

841
#define CMP_NUM_VALUE(var) do { \
842
    if (propvar1->var > propvar2_converted->var) \
843
        res = 1; \
844
    else if (propvar1->var < propvar2_converted->var) \
845 846 847 848 849 850 851 852
        res = -1; \
    else \
        res = 0; \
    } while (0)

    switch (propvar1->vt)
    {
    case VT_I1:
853
        CMP_NUM_VALUE(cVal);
854 855
        break;
    case VT_UI1:
856
        CMP_NUM_VALUE(bVal);
857 858
        break;
    case VT_I2:
859
        CMP_NUM_VALUE(iVal);
860 861
        break;
    case VT_UI2:
862
        CMP_NUM_VALUE(uiVal);
863 864
        break;
    case VT_I4:
865
        CMP_NUM_VALUE(lVal);
866 867
        break;
    case VT_UI4:
868
        CMP_NUM_VALUE(uiVal);
869 870
        break;
    case VT_I8:
871
        CMP_NUM_VALUE(hVal.QuadPart);
872 873
        break;
    case VT_UI8:
874 875 876 877 878 879 880
        CMP_NUM_VALUE(uhVal.QuadPart);
        break;
    case VT_R4:
        CMP_NUM_VALUE(fltVal);
        break;
    case VT_R8:
        CMP_NUM_VALUE(dblVal);
881 882
        break;
    case VT_BSTR:
883 884 885
    case VT_LPWSTR:
        /* FIXME: Use other string flags. */
        if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
886
            res = lstrcmpiW(propvar1->bstrVal, propvar2_converted->bstrVal);
887
        else
888
            res = lstrcmpW(propvar1->bstrVal, propvar2_converted->bstrVal);
889 890 891 892
        break;
    case VT_LPSTR:
        /* FIXME: Use other string flags. */
        if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
893
            res = lstrcmpiA(propvar1->pszVal, propvar2_converted->pszVal);
894
        else
895
            res = lstrcmpA(propvar1->pszVal, propvar2_converted->pszVal);
896
        break;
897
    case VT_CLSID:
898
        res = memcmp(propvar1->puuid, propvar2->puuid, sizeof(*propvar1->puuid));
899 900
        if (res) res = res > 0 ? 1 : -1;
        break;
901 902 903 904 905 906 907
    case VT_VECTOR | VT_UI1:
        count = min(propvar1->caub.cElems, propvar2->caub.cElems);
        res = count ? memcmp(propvar1->caub.pElems, propvar2->caub.pElems, sizeof(*propvar1->caub.pElems) * count) : 0;
        if (res) res = res > 0 ? 1 : -1;
        if (!res && propvar1->caub.cElems != propvar2->caub.cElems)
            res = propvar1->caub.cElems > propvar2->caub.cElems ? 1 : -1;
        break;
908
    default:
909
        FIXME("vartype %#x not handled\n", propvar1->vt);
910 911 912 913 914 915
        res = -1;
        break;
    }

    if (propvar2_converted == &propvar2_static)
        PropVariantClear(&propvar2_static);
916

917
    return res;
918
}