2 * PropVariant implementation
4 * Copyright 2008 James Hawkins for CodeWeavers
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.
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.
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
32 #include "propvarutil.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(propsys
);
39 static HRESULT
PROPVAR_ConvertFILETIME(const FILETIME
*ft
, PROPVARIANT
*ppropvarDest
, VARTYPE vt
)
43 FileTimeToSystemTime(ft
, &time
);
48 ppropvarDest
->pszVal
= HeapAlloc(GetProcessHeap(), 0, 64);
49 if (!ppropvarDest
->pszVal
)
52 sprintf( ppropvarDest
->pszVal
, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
53 time
.wYear
, time
.wMonth
, time
.wDay
,
54 time
.wHour
, time
.wMinute
, time
.wSecond
,
60 FIXME("Unhandled target type: %d\n", vt
);
66 static HRESULT
PROPVAR_ConvertNumber(REFPROPVARIANT pv
, int dest_bits
,
67 BOOL dest_signed
, LONGLONG
*res
)
99 *res
= pv
->hVal
.QuadPart
;
103 *res
= pv
->uhVal
.QuadPart
;
112 *res
= strtoll(pv
->pszVal
, &end
, 0);
113 if (pv
->pszVal
== end
)
114 return DISP_E_TYPEMISMATCH
;
115 src_signed
= *res
< 0;
122 *res
= wcstol(pv
->pwszVal
, &end
, 0);
123 if (pv
->pwszVal
== end
)
124 return DISP_E_TYPEMISMATCH
;
125 src_signed
= *res
< 0;
135 FIXME("unhandled vt %d\n", pv
->vt
);
139 if (*res
< 0 && src_signed
!= dest_signed
)
140 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
146 if (*res
>= ((LONGLONG
)1 << (dest_bits
-1)) ||
147 *res
< ((LONGLONG
)-1 << (dest_bits
-1)))
148 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
152 if ((ULONGLONG
)(*res
) >= ((ULONGLONG
)1 << dest_bits
))
153 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
160 HRESULT WINAPI
PropVariantToDouble(REFPROPVARIANT propvarIn
, double *ret
)
165 TRACE("(%p, %p)\n", propvarIn
, ret
);
167 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
168 if (SUCCEEDED(hr
)) *ret
= (double)res
;
172 HRESULT WINAPI
PropVariantToInt16(REFPROPVARIANT propvarIn
, SHORT
*ret
)
177 TRACE("%p,%p\n", propvarIn
, ret
);
179 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, TRUE
, &res
);
180 if (SUCCEEDED(hr
)) *ret
= (SHORT
)res
;
184 HRESULT WINAPI
PropVariantToInt32(REFPROPVARIANT propvarIn
, LONG
*ret
)
189 TRACE("%p,%p\n", propvarIn
, ret
);
191 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, TRUE
, &res
);
192 if (SUCCEEDED(hr
)) *ret
= (LONG
)res
;
196 HRESULT WINAPI
PropVariantToInt64(REFPROPVARIANT propvarIn
, LONGLONG
*ret
)
201 TRACE("%p,%p\n", propvarIn
, ret
);
203 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
204 if (SUCCEEDED(hr
)) *ret
= res
;
208 HRESULT WINAPI
PropVariantToUInt16(REFPROPVARIANT propvarIn
, USHORT
*ret
)
213 TRACE("%p,%p\n", propvarIn
, ret
);
215 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, FALSE
, &res
);
216 if (SUCCEEDED(hr
)) *ret
= (USHORT
)res
;
220 HRESULT WINAPI
PropVariantToUInt32(REFPROPVARIANT propvarIn
, ULONG
*ret
)
225 TRACE("%p,%p\n", propvarIn
, ret
);
227 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, FALSE
, &res
);
228 if (SUCCEEDED(hr
)) *ret
= (ULONG
)res
;
232 ULONG WINAPI
PropVariantToUInt32WithDefault(REFPROPVARIANT propvarIn
, ULONG ulDefault
)
237 TRACE("%p,%lu\n", propvarIn
, ulDefault
);
239 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, FALSE
, &res
);
246 HRESULT WINAPI
PropVariantToUInt64(REFPROPVARIANT propvarIn
, ULONGLONG
*ret
)
251 TRACE("%p,%p\n", propvarIn
, ret
);
253 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, FALSE
, &res
);
254 if (SUCCEEDED(hr
)) *ret
= (ULONGLONG
)res
;
258 HRESULT WINAPI
PropVariantToBoolean(REFPROPVARIANT propvarIn
, BOOL
*ret
)
263 TRACE("%p,%p\n", propvarIn
, ret
);
267 switch (propvarIn
->vt
)
270 *ret
= propvarIn
->boolVal
== VARIANT_TRUE
;
275 if (!propvarIn
->pwszVal
)
276 return DISP_E_TYPEMISMATCH
;
278 if (!lstrcmpiW(propvarIn
->pwszVal
, L
"true") || !lstrcmpW(propvarIn
->pwszVal
, L
"#TRUE#"))
284 if (!lstrcmpiW(propvarIn
->pwszVal
, L
"false") || !lstrcmpW(propvarIn
->pwszVal
, L
"#FALSE#"))
292 if (!propvarIn
->pszVal
)
293 return DISP_E_TYPEMISMATCH
;
295 if (!lstrcmpiA(propvarIn
->pszVal
, "true") || !lstrcmpA(propvarIn
->pszVal
, "#TRUE#"))
301 if (!lstrcmpiA(propvarIn
->pszVal
, "false") || !lstrcmpA(propvarIn
->pszVal
, "#FALSE#"))
309 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
314 HRESULT WINAPI
PropVariantToBuffer(REFPROPVARIANT propvarIn
, void *ret
, UINT cb
)
318 TRACE("(%p, %p, %d)\n", propvarIn
, ret
, cb
);
320 switch(propvarIn
->vt
)
322 case VT_VECTOR
|VT_UI1
:
323 if(cb
> propvarIn
->caub
.cElems
)
325 memcpy(ret
, propvarIn
->caub
.pElems
, cb
);
327 case VT_ARRAY
|VT_UI1
:
328 FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
332 WARN("Unexpected type: %x\n", propvarIn
->vt
);
340 HRESULT WINAPI
PropVariantToString(REFPROPVARIANT propvarIn
, PWSTR ret
, UINT cch
)
343 WCHAR
*stringW
= NULL
;
345 TRACE("(%p, %p, %d)\n", propvarIn
, ret
, cch
);
352 hr
= PropVariantToStringAlloc(propvarIn
, &stringW
);
355 if(lstrlenW(stringW
) >= cch
)
356 hr
= STRSAFE_E_INSUFFICIENT_BUFFER
;
357 lstrcpynW(ret
, stringW
, cch
);
358 CoTaskMemFree(stringW
);
364 HRESULT WINAPI
PropVariantToStringAlloc(REFPROPVARIANT propvarIn
, WCHAR
**ret
)
369 TRACE("%p,%p semi-stub\n", propvarIn
, ret
);
371 switch(propvarIn
->vt
)
375 res
= CoTaskMemAlloc(1*sizeof(WCHAR
));
380 if(propvarIn
->pszVal
)
384 len
= MultiByteToWideChar(CP_ACP
, 0, propvarIn
->pszVal
, -1, NULL
, 0);
385 res
= CoTaskMemAlloc(len
*sizeof(WCHAR
));
387 return E_OUTOFMEMORY
;
389 MultiByteToWideChar(CP_ACP
, 0, propvarIn
->pszVal
, -1, res
, len
);
395 if (propvarIn
->pwszVal
)
397 DWORD size
= (lstrlenW(propvarIn
->pwszVal
) + 1) * sizeof(WCHAR
);
398 res
= CoTaskMemAlloc(size
);
399 if(!res
) return E_OUTOFMEMORY
;
400 memcpy(res
, propvarIn
->pwszVal
, size
);
405 FIXME("Unsupported conversion (%d)\n", propvarIn
->vt
);
415 PCWSTR WINAPI
PropVariantToStringWithDefault(REFPROPVARIANT propvarIn
, LPCWSTR pszDefault
)
417 if (propvarIn
->vt
== VT_BSTR
)
419 if (propvarIn
->bstrVal
== NULL
)
422 return propvarIn
->bstrVal
;
425 if (propvarIn
->vt
== VT_LPWSTR
&& propvarIn
->pwszVal
!= NULL
)
426 return propvarIn
->pwszVal
;
431 /******************************************************************
432 * VariantToStringWithDefault (PROPSYS.@)
434 PCWSTR WINAPI
VariantToStringWithDefault(const VARIANT
*pvar
, const WCHAR
*default_value
)
436 TRACE("%s, %s.\n", debugstr_variant(pvar
), debugstr_w(default_value
));
438 if (V_VT(pvar
) == (VT_BYREF
| VT_VARIANT
)) pvar
= V_VARIANTREF(pvar
);
439 if (V_VT(pvar
) == (VT_BYREF
| VT_BSTR
) || V_VT(pvar
) == VT_BSTR
)
441 BSTR ret
= V_ISBYREF(pvar
) ? *V_BSTRREF(pvar
) : V_BSTR(pvar
);
442 return ret
? ret
: L
"";
445 return default_value
;
448 /******************************************************************
449 * VariantToString (PROPSYS.@)
451 HRESULT WINAPI
VariantToString(REFVARIANT var
, PWSTR ret
, UINT cch
)
453 WCHAR buffer
[64], *str
= buffer
;
455 TRACE("%p, %p, %u.\n", var
, ret
, cch
);
468 swprintf(buffer
, ARRAY_SIZE(buffer
), L
"%d", V_I4(var
));
471 FIXME("Unsupported type %d.\n", V_VT(var
));
475 if (wcslen(str
) > cch
- 1)
476 return STRSAFE_E_INSUFFICIENT_BUFFER
;
482 /******************************************************************
483 * PropVariantChangeType (PROPSYS.@)
485 HRESULT WINAPI
PropVariantChangeType(PROPVARIANT
*ppropvarDest
, REFPROPVARIANT propvarSrc
,
486 PROPVAR_CHANGE_FLAGS flags
, VARTYPE vt
)
490 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest
, propvarSrc
,
491 propvarSrc
->vt
, flags
, vt
);
493 if (vt
== propvarSrc
->vt
)
494 return PropVariantCopy(ppropvarDest
, propvarSrc
);
496 if (propvarSrc
->vt
== VT_FILETIME
)
497 return PROPVAR_ConvertFILETIME(&propvarSrc
->filetime
, ppropvarDest
, vt
);
505 hr
= PROPVAR_ConvertNumber(propvarSrc
, 8, TRUE
, &res
);
508 ppropvarDest
->vt
= VT_I1
;
509 ppropvarDest
->cVal
= (char)res
;
518 hr
= PROPVAR_ConvertNumber(propvarSrc
, 8, FALSE
, &res
);
521 ppropvarDest
->vt
= VT_UI1
;
522 ppropvarDest
->bVal
= (UCHAR
)res
;
530 hr
= PropVariantToInt16(propvarSrc
, &res
);
533 ppropvarDest
->vt
= VT_I2
;
534 ppropvarDest
->iVal
= res
;
541 hr
= PropVariantToUInt16(propvarSrc
, &res
);
544 ppropvarDest
->vt
= VT_UI2
;
545 ppropvarDest
->uiVal
= res
;
552 hr
= PropVariantToInt32(propvarSrc
, &res
);
555 ppropvarDest
->vt
= VT_I4
;
556 ppropvarDest
->lVal
= res
;
563 hr
= PropVariantToUInt32(propvarSrc
, &res
);
566 ppropvarDest
->vt
= VT_UI4
;
567 ppropvarDest
->ulVal
= res
;
574 hr
= PropVariantToInt64(propvarSrc
, &res
);
577 ppropvarDest
->vt
= VT_I8
;
578 ppropvarDest
->hVal
.QuadPart
= res
;
585 hr
= PropVariantToUInt64(propvarSrc
, &res
);
588 ppropvarDest
->vt
= VT_UI8
;
589 ppropvarDest
->uhVal
.QuadPart
= res
;
598 hr
= PropVariantToStringAlloc(propvarSrc
, &res
);
601 ppropvarDest
->vt
= VT_LPWSTR
;
602 ppropvarDest
->pwszVal
= res
;
610 hr
= PropVariantToStringAlloc(propvarSrc
, &resW
);
616 len
= WideCharToMultiByte(CP_ACP
, 0, resW
, -1, NULL
, 0, NULL
, NULL
);
617 res
= CoTaskMemAlloc(len
);
620 WideCharToMultiByte(CP_ACP
, 0, resW
, -1, res
, len
, NULL
, NULL
);
621 ppropvarDest
->vt
= VT_LPSTR
;
622 ppropvarDest
->pszVal
= res
;
633 FIXME("Unhandled dest type: %d\n", vt
);
638 static void PROPVAR_GUIDToWSTR(REFGUID guid
, WCHAR
*str
)
640 swprintf(str
, 39, L
"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid
->Data1
,
641 guid
->Data2
, guid
->Data3
, guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2],
642 guid
->Data4
[3], guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
645 HRESULT WINAPI
InitPropVariantFromGUIDAsString(REFGUID guid
, PROPVARIANT
*ppropvar
)
647 TRACE("(%p %p)\n", guid
, ppropvar
);
652 ppropvar
->vt
= VT_LPWSTR
;
653 ppropvar
->pwszVal
= CoTaskMemAlloc(39*sizeof(WCHAR
));
654 if(!ppropvar
->pwszVal
)
655 return E_OUTOFMEMORY
;
657 PROPVAR_GUIDToWSTR(guid
, ppropvar
->pwszVal
);
661 HRESULT WINAPI
InitVariantFromGUIDAsString(REFGUID guid
, VARIANT
*pvar
)
663 TRACE("(%p %p)\n", guid
, pvar
);
666 FIXME("guid == NULL\n");
670 V_VT(pvar
) = VT_BSTR
;
671 V_BSTR(pvar
) = SysAllocStringLen(NULL
, 38);
673 return E_OUTOFMEMORY
;
675 PROPVAR_GUIDToWSTR(guid
, V_BSTR(pvar
));
679 HRESULT WINAPI
InitPropVariantFromBuffer(const VOID
*pv
, UINT cb
, PROPVARIANT
*ppropvar
)
681 TRACE("(%p %u %p)\n", pv
, cb
, ppropvar
);
683 ppropvar
->caub
.pElems
= CoTaskMemAlloc(cb
);
684 if(!ppropvar
->caub
.pElems
)
685 return E_OUTOFMEMORY
;
687 ppropvar
->vt
= VT_VECTOR
|VT_UI1
;
688 ppropvar
->caub
.cElems
= cb
;
689 memcpy(ppropvar
->caub
.pElems
, pv
, cb
);
693 HRESULT WINAPI
InitPropVariantFromCLSID(REFCLSID clsid
, PROPVARIANT
*ppropvar
)
695 TRACE("(%s %p)\n", debugstr_guid(clsid
), ppropvar
);
697 ppropvar
->puuid
= CoTaskMemAlloc(sizeof(*ppropvar
->puuid
));
699 return E_OUTOFMEMORY
;
701 ppropvar
->vt
= VT_CLSID
;
702 memcpy(ppropvar
->puuid
, clsid
, sizeof(*ppropvar
->puuid
));
706 HRESULT WINAPI
InitPropVariantFromStringVector(PCWSTR
*strs
, ULONG count
, PROPVARIANT
*ppropvar
)
710 TRACE("(%p %lu %p)\n", strs
, count
, ppropvar
);
712 ppropvar
->calpwstr
.pElems
= CoTaskMemAlloc(count
* sizeof(*ppropvar
->calpwstr
.pElems
));
713 if(!ppropvar
->calpwstr
.pElems
)
714 return E_OUTOFMEMORY
;
716 ppropvar
->vt
= VT_LPWSTR
| VT_VECTOR
;
717 ppropvar
->calpwstr
.cElems
= 0;
719 memset(ppropvar
->calpwstr
.pElems
, 0, count
* sizeof(*ppropvar
->calpwstr
.pElems
));
721 for (i
= 0; i
< count
; ++i
)
725 if (!(ppropvar
->calpwstr
.pElems
[i
] = CoTaskMemAlloc((wcslen(strs
[i
]) + 1)*sizeof(**strs
))))
727 PropVariantClear(ppropvar
);
728 return E_OUTOFMEMORY
;
731 wcscpy(ppropvar
->calpwstr
.pElems
[i
], strs
[i
]);
732 ppropvar
->calpwstr
.cElems
++;
738 HRESULT WINAPI
InitVariantFromBuffer(const VOID
*pv
, UINT cb
, VARIANT
*pvar
)
744 TRACE("(%p %u %p)\n", pv
, cb
, pvar
);
746 arr
= SafeArrayCreateVector(VT_UI1
, 0, cb
);
748 return E_OUTOFMEMORY
;
750 hres
= SafeArrayAccessData(arr
, &data
);
752 SafeArrayDestroy(arr
);
756 memcpy(data
, pv
, cb
);
758 hres
= SafeArrayUnaccessData(arr
);
760 SafeArrayDestroy(arr
);
764 V_VT(pvar
) = VT_ARRAY
|VT_UI1
;
769 HRESULT WINAPI
InitVariantFromFileTime(const FILETIME
*ft
, VARIANT
*var
)
773 TRACE("%p, %p\n", ft
, var
);
776 if (!FileTimeToSystemTime(ft
, &st
))
778 if (!SystemTimeToVariantTime(&st
, &V_DATE(var
)))
784 static inline DWORD
PROPVAR_HexToNum(const WCHAR
*hex
)
788 if(hex
[0]>='0' && hex
[0]<='9')
790 else if(hex
[0]>='a' && hex
[0]<='f')
792 else if(hex
[0]>='A' && hex
[0]<='F')
798 if(hex
[1]>='0' && hex
[1]<='9')
799 return ret
+ hex
[1]-'0';
800 else if(hex
[1]>='a' && hex
[1]<='f')
801 return ret
+ hex
[1]-'a'+10;
802 else if(hex
[1]>='A' && hex
[1]<='F')
803 return ret
+ hex
[1]-'A'+10;
808 static inline HRESULT
PROPVAR_WCHARToGUID(const WCHAR
*str
, int len
, GUID
*guid
)
813 memset(guid
, 0, sizeof(GUID
));
815 if(len
!=38 || str
[0]!='{' || str
[9]!='-' || str
[14]!='-'
816 || str
[19]!='-' || str
[24]!='-' || str
[37]!='}') {
817 WARN("Error parsing %s\n", debugstr_w(str
));
822 for(i
=0; i
<4 && val
!=-1; i
++) {
823 val
= PROPVAR_HexToNum(p
);
824 guid
->Data1
= (guid
->Data1
<<8) + val
;
828 for(i
=0; i
<2 && val
!=-1; i
++) {
829 val
= PROPVAR_HexToNum(p
);
830 guid
->Data2
= (guid
->Data2
<<8) + val
;
834 for(i
=0; i
<2 && val
!=-1; i
++) {
835 val
= PROPVAR_HexToNum(p
);
836 guid
->Data3
= (guid
->Data3
<<8) + val
;
840 for(i
=0; i
<8 && val
!=-1; i
++) {
844 val
= guid
->Data4
[i
] = PROPVAR_HexToNum(p
);
849 WARN("Error parsing %s\n", debugstr_w(str
));
850 memset(guid
, 0, sizeof(GUID
));
856 HRESULT WINAPI
PropVariantToGUID(const PROPVARIANT
*ppropvar
, GUID
*guid
)
858 TRACE("%p %p)\n", ppropvar
, guid
);
860 switch(ppropvar
->vt
) {
862 return PROPVAR_WCHARToGUID(ppropvar
->bstrVal
, SysStringLen(ppropvar
->bstrVal
), guid
);
864 return PROPVAR_WCHARToGUID(ppropvar
->pwszVal
, lstrlenW(ppropvar
->pwszVal
), guid
);
866 memcpy(guid
, ppropvar
->puuid
, sizeof(*ppropvar
->puuid
));
870 FIXME("unsupported vt: %d\n", ppropvar
->vt
);
875 HRESULT WINAPI
VariantToGUID(const VARIANT
*pvar
, GUID
*guid
)
877 TRACE("(%p %p)\n", pvar
, guid
);
881 HRESULT hres
= PROPVAR_WCHARToGUID(V_BSTR(pvar
), SysStringLen(V_BSTR(pvar
)), guid
);
882 if(hres
== E_INVALIDARG
)
888 FIXME("unsupported vt: %d\n", V_VT(pvar
));
893 static BOOL
isemptyornull(const PROPVARIANT
*propvar
)
895 if (propvar
->vt
== VT_EMPTY
|| propvar
->vt
== VT_NULL
)
897 if ((propvar
->vt
& VT_ARRAY
) == VT_ARRAY
)
900 for (i
=0; i
<propvar
->parray
->cDims
; i
++)
902 if (propvar
->parray
->rgsabound
[i
].cElements
!= 0)
905 return i
== propvar
->parray
->cDims
;
907 if (propvar
->vt
== VT_CLSID
)
908 return !propvar
->puuid
;
910 if (propvar
->vt
& VT_VECTOR
)
911 return !propvar
->caub
.cElems
;
913 /* FIXME: byrefs, errors? */
917 INT WINAPI
PropVariantCompareEx(REFPROPVARIANT propvar1
, REFPROPVARIANT propvar2
,
918 PROPVAR_COMPARE_UNIT unit
, PROPVAR_COMPARE_FLAGS flags
)
920 const PROPVARIANT
*propvar2_converted
;
921 PROPVARIANT propvar2_static
;
926 TRACE("%p,%p,%x,%x\n", propvar1
, propvar2
, unit
, flags
);
928 if (isemptyornull(propvar1
))
930 if (isemptyornull(propvar2
))
932 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? 1 : -1;
935 if (isemptyornull(propvar2
))
936 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? -1 : 1;
938 if (propvar1
->vt
!= propvar2
->vt
)
940 hr
= PropVariantChangeType(&propvar2_static
, propvar2
, 0, propvar1
->vt
);
945 propvar2_converted
= &propvar2_static
;
948 propvar2_converted
= propvar2
;
950 #define CMP_NUM_VALUE(var) do { \
951 if (propvar1->var > propvar2_converted->var) \
953 else if (propvar1->var < propvar2_converted->var) \
959 switch (propvar1
->vt
)
971 CMP_NUM_VALUE(uiVal
);
977 CMP_NUM_VALUE(ulVal
);
980 CMP_NUM_VALUE(hVal
.QuadPart
);
983 CMP_NUM_VALUE(uhVal
.QuadPart
);
986 CMP_NUM_VALUE(fltVal
);
989 CMP_NUM_VALUE(dblVal
);
993 /* FIXME: Use other string flags. */
994 if (flags
& (PVCF_USESTRCMPI
| PVCF_USESTRCMPIC
))
995 res
= lstrcmpiW(propvar1
->bstrVal
, propvar2_converted
->bstrVal
);
997 res
= lstrcmpW(propvar1
->bstrVal
, propvar2_converted
->bstrVal
);
1000 /* FIXME: Use other string flags. */
1001 if (flags
& (PVCF_USESTRCMPI
| PVCF_USESTRCMPIC
))
1002 res
= lstrcmpiA(propvar1
->pszVal
, propvar2_converted
->pszVal
);
1004 res
= lstrcmpA(propvar1
->pszVal
, propvar2_converted
->pszVal
);
1007 res
= memcmp(propvar1
->puuid
, propvar2
->puuid
, sizeof(*propvar1
->puuid
));
1008 if (res
) res
= res
> 0 ? 1 : -1;
1010 case VT_VECTOR
| VT_UI1
:
1011 count
= min(propvar1
->caub
.cElems
, propvar2
->caub
.cElems
);
1012 res
= count
? memcmp(propvar1
->caub
.pElems
, propvar2
->caub
.pElems
, sizeof(*propvar1
->caub
.pElems
) * count
) : 0;
1013 if (res
) res
= res
> 0 ? 1 : -1;
1014 if (!res
&& propvar1
->caub
.cElems
!= propvar2
->caub
.cElems
)
1015 res
= propvar1
->caub
.cElems
> propvar2
->caub
.cElems
? 1 : -1;
1018 FIXME("vartype %#x not handled\n", propvar1
->vt
);
1023 if (propvar2_converted
== &propvar2_static
)
1024 PropVariantClear(&propvar2_static
);