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
26 #define NONAMELESSUNION
34 #include "propvarutil.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(propsys
);
41 static HRESULT
PROPVAR_ConvertFILETIME(const FILETIME
*ft
, PROPVARIANT
*ppropvarDest
, VARTYPE vt
)
45 FileTimeToSystemTime(ft
, &time
);
50 ppropvarDest
->pszVal
= HeapAlloc(GetProcessHeap(), 0, 64);
51 if (!ppropvarDest
->pszVal
)
54 sprintf( ppropvarDest
->pszVal
, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
55 time
.wYear
, time
.wMonth
, time
.wDay
,
56 time
.wHour
, time
.wMinute
, time
.wSecond
,
62 FIXME("Unhandled target type: %d\n", vt
);
68 static HRESULT
PROPVAR_ConvertNumber(REFPROPVARIANT pv
, int dest_bits
,
69 BOOL dest_signed
, LONGLONG
*res
)
101 *res
= pv
->hVal
.QuadPart
;
105 *res
= pv
->uhVal
.QuadPart
;
114 *res
= strtoll(pv
->pszVal
, &end
, 0);
115 if (pv
->pszVal
== end
)
116 return DISP_E_TYPEMISMATCH
;
117 src_signed
= *res
< 0;
124 *res
= wcstol(pv
->pwszVal
, &end
, 0);
125 if (pv
->pwszVal
== end
)
126 return DISP_E_TYPEMISMATCH
;
127 src_signed
= *res
< 0;
137 FIXME("unhandled vt %d\n", pv
->vt
);
141 if (*res
< 0 && src_signed
!= dest_signed
)
142 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
148 if (*res
>= ((LONGLONG
)1 << (dest_bits
-1)) ||
149 *res
< ((LONGLONG
)-1 << (dest_bits
-1)))
150 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
154 if ((ULONGLONG
)(*res
) >= ((ULONGLONG
)1 << dest_bits
))
155 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
162 HRESULT WINAPI
PropVariantToDouble(REFPROPVARIANT propvarIn
, double *ret
)
167 TRACE("(%p, %p)\n", propvarIn
, ret
);
169 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
170 if (SUCCEEDED(hr
)) *ret
= (double)res
;
174 HRESULT WINAPI
PropVariantToInt16(REFPROPVARIANT propvarIn
, SHORT
*ret
)
179 TRACE("%p,%p\n", propvarIn
, ret
);
181 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, TRUE
, &res
);
182 if (SUCCEEDED(hr
)) *ret
= (SHORT
)res
;
186 HRESULT WINAPI
PropVariantToInt32(REFPROPVARIANT propvarIn
, LONG
*ret
)
191 TRACE("%p,%p\n", propvarIn
, ret
);
193 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, TRUE
, &res
);
194 if (SUCCEEDED(hr
)) *ret
= (LONG
)res
;
198 HRESULT WINAPI
PropVariantToInt64(REFPROPVARIANT propvarIn
, LONGLONG
*ret
)
203 TRACE("%p,%p\n", propvarIn
, ret
);
205 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
206 if (SUCCEEDED(hr
)) *ret
= res
;
210 HRESULT WINAPI
PropVariantToUInt16(REFPROPVARIANT propvarIn
, USHORT
*ret
)
215 TRACE("%p,%p\n", propvarIn
, ret
);
217 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, FALSE
, &res
);
218 if (SUCCEEDED(hr
)) *ret
= (USHORT
)res
;
222 HRESULT WINAPI
PropVariantToUInt32(REFPROPVARIANT propvarIn
, ULONG
*ret
)
227 TRACE("%p,%p\n", propvarIn
, ret
);
229 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, FALSE
, &res
);
230 if (SUCCEEDED(hr
)) *ret
= (ULONG
)res
;
234 HRESULT WINAPI
PropVariantToUInt64(REFPROPVARIANT propvarIn
, ULONGLONG
*ret
)
239 TRACE("%p,%p\n", propvarIn
, ret
);
241 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, FALSE
, &res
);
242 if (SUCCEEDED(hr
)) *ret
= (ULONGLONG
)res
;
246 HRESULT WINAPI
PropVariantToBoolean(REFPROPVARIANT propvarIn
, BOOL
*ret
)
251 TRACE("%p,%p\n", propvarIn
, ret
);
255 switch (propvarIn
->vt
)
258 *ret
= propvarIn
->boolVal
== VARIANT_TRUE
;
263 if (!propvarIn
->pwszVal
)
264 return DISP_E_TYPEMISMATCH
;
266 if (!lstrcmpiW(propvarIn
->pwszVal
, L
"true") || !lstrcmpW(propvarIn
->pwszVal
, L
"#TRUE#"))
272 if (!lstrcmpiW(propvarIn
->pwszVal
, L
"false") || !lstrcmpW(propvarIn
->pwszVal
, L
"#FALSE#"))
280 if (!propvarIn
->pszVal
)
281 return DISP_E_TYPEMISMATCH
;
283 if (!lstrcmpiA(propvarIn
->pszVal
, "true") || !lstrcmpA(propvarIn
->pszVal
, "#TRUE#"))
289 if (!lstrcmpiA(propvarIn
->pszVal
, "false") || !lstrcmpA(propvarIn
->pszVal
, "#FALSE#"))
297 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
302 HRESULT WINAPI
PropVariantToBuffer(REFPROPVARIANT propvarIn
, void *ret
, UINT cb
)
306 TRACE("(%p, %p, %d)\n", propvarIn
, ret
, cb
);
308 switch(propvarIn
->vt
)
310 case VT_VECTOR
|VT_UI1
:
311 if(cb
> propvarIn
->caub
.cElems
)
313 memcpy(ret
, propvarIn
->caub
.pElems
, cb
);
315 case VT_ARRAY
|VT_UI1
:
316 FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
320 WARN("Unexpected type: %x\n", propvarIn
->vt
);
328 HRESULT WINAPI
PropVariantToString(REFPROPVARIANT propvarIn
, PWSTR ret
, UINT cch
)
331 WCHAR
*stringW
= NULL
;
333 TRACE("(%p, %p, %d)\n", propvarIn
, ret
, cch
);
340 hr
= PropVariantToStringAlloc(propvarIn
, &stringW
);
343 if(lstrlenW(stringW
) >= cch
)
344 hr
= STRSAFE_E_INSUFFICIENT_BUFFER
;
345 lstrcpynW(ret
, stringW
, cch
);
346 CoTaskMemFree(stringW
);
352 HRESULT WINAPI
PropVariantToStringAlloc(REFPROPVARIANT propvarIn
, WCHAR
**ret
)
357 TRACE("%p,%p semi-stub\n", propvarIn
, ret
);
359 switch(propvarIn
->vt
)
363 res
= CoTaskMemAlloc(1*sizeof(WCHAR
));
368 if(propvarIn
->pszVal
)
372 len
= MultiByteToWideChar(CP_ACP
, 0, propvarIn
->pszVal
, -1, NULL
, 0);
373 res
= CoTaskMemAlloc(len
*sizeof(WCHAR
));
375 return E_OUTOFMEMORY
;
377 MultiByteToWideChar(CP_ACP
, 0, propvarIn
->pszVal
, -1, res
, len
);
383 if (propvarIn
->pwszVal
)
385 DWORD size
= (lstrlenW(propvarIn
->pwszVal
) + 1) * sizeof(WCHAR
);
386 res
= CoTaskMemAlloc(size
);
387 if(!res
) return E_OUTOFMEMORY
;
388 memcpy(res
, propvarIn
->pwszVal
, size
);
393 FIXME("Unsupported conversion (%d)\n", propvarIn
->vt
);
403 PCWSTR WINAPI
PropVariantToStringWithDefault(REFPROPVARIANT propvarIn
, LPCWSTR pszDefault
)
405 if (propvarIn
->vt
== VT_BSTR
)
407 if (propvarIn
->bstrVal
== NULL
)
410 return propvarIn
->bstrVal
;
413 if (propvarIn
->vt
== VT_LPWSTR
&& propvarIn
->pwszVal
!= NULL
)
414 return propvarIn
->pwszVal
;
419 /******************************************************************
420 * VariantToStringWithDefault (PROPSYS.@)
422 PCWSTR WINAPI
VariantToStringWithDefault(const VARIANT
*pvar
, const WCHAR
*default_value
)
424 TRACE("%s, %s.\n", debugstr_variant(pvar
), debugstr_w(default_value
));
426 if (V_VT(pvar
) == (VT_BYREF
| VT_VARIANT
)) pvar
= V_VARIANTREF(pvar
);
427 if (V_VT(pvar
) == (VT_BYREF
| VT_BSTR
) || V_VT(pvar
) == VT_BSTR
)
429 BSTR ret
= V_ISBYREF(pvar
) ? *V_BSTRREF(pvar
) : V_BSTR(pvar
);
430 return ret
? ret
: L
"";
433 return default_value
;
436 /******************************************************************
437 * PropVariantChangeType (PROPSYS.@)
439 HRESULT WINAPI
PropVariantChangeType(PROPVARIANT
*ppropvarDest
, REFPROPVARIANT propvarSrc
,
440 PROPVAR_CHANGE_FLAGS flags
, VARTYPE vt
)
444 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest
, propvarSrc
,
445 propvarSrc
->vt
, flags
, vt
);
447 if (vt
== propvarSrc
->vt
)
448 return PropVariantCopy(ppropvarDest
, propvarSrc
);
450 if (propvarSrc
->vt
== VT_FILETIME
)
451 return PROPVAR_ConvertFILETIME(&propvarSrc
->filetime
, ppropvarDest
, vt
);
459 hr
= PROPVAR_ConvertNumber(propvarSrc
, 8, TRUE
, &res
);
462 ppropvarDest
->vt
= VT_I1
;
463 ppropvarDest
->cVal
= (char)res
;
472 hr
= PROPVAR_ConvertNumber(propvarSrc
, 8, FALSE
, &res
);
475 ppropvarDest
->vt
= VT_UI1
;
476 ppropvarDest
->bVal
= (UCHAR
)res
;
484 hr
= PropVariantToInt16(propvarSrc
, &res
);
487 ppropvarDest
->vt
= VT_I2
;
488 ppropvarDest
->iVal
= res
;
495 hr
= PropVariantToUInt16(propvarSrc
, &res
);
498 ppropvarDest
->vt
= VT_UI2
;
499 ppropvarDest
->uiVal
= res
;
506 hr
= PropVariantToInt32(propvarSrc
, &res
);
509 ppropvarDest
->vt
= VT_I4
;
510 ppropvarDest
->lVal
= res
;
517 hr
= PropVariantToUInt32(propvarSrc
, &res
);
520 ppropvarDest
->vt
= VT_UI4
;
521 ppropvarDest
->ulVal
= res
;
528 hr
= PropVariantToInt64(propvarSrc
, &res
);
531 ppropvarDest
->vt
= VT_I8
;
532 ppropvarDest
->hVal
.QuadPart
= res
;
539 hr
= PropVariantToUInt64(propvarSrc
, &res
);
542 ppropvarDest
->vt
= VT_UI8
;
543 ppropvarDest
->uhVal
.QuadPart
= res
;
552 hr
= PropVariantToStringAlloc(propvarSrc
, &res
);
555 ppropvarDest
->vt
= VT_LPWSTR
;
556 ppropvarDest
->pwszVal
= res
;
564 hr
= PropVariantToStringAlloc(propvarSrc
, &resW
);
570 len
= WideCharToMultiByte(CP_ACP
, 0, resW
, -1, NULL
, 0, NULL
, NULL
);
571 res
= CoTaskMemAlloc(len
);
574 WideCharToMultiByte(CP_ACP
, 0, resW
, -1, res
, len
, NULL
, NULL
);
575 ppropvarDest
->vt
= VT_LPSTR
;
576 ppropvarDest
->pszVal
= res
;
587 FIXME("Unhandled dest type: %d\n", vt
);
592 static void PROPVAR_GUIDToWSTR(REFGUID guid
, WCHAR
*str
)
594 swprintf(str
, 39, L
"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid
->Data1
,
595 guid
->Data2
, guid
->Data3
, guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2],
596 guid
->Data4
[3], guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
599 HRESULT WINAPI
InitPropVariantFromGUIDAsString(REFGUID guid
, PROPVARIANT
*ppropvar
)
601 TRACE("(%p %p)\n", guid
, ppropvar
);
606 ppropvar
->vt
= VT_LPWSTR
;
607 ppropvar
->pwszVal
= CoTaskMemAlloc(39*sizeof(WCHAR
));
608 if(!ppropvar
->pwszVal
)
609 return E_OUTOFMEMORY
;
611 PROPVAR_GUIDToWSTR(guid
, ppropvar
->pwszVal
);
615 HRESULT WINAPI
InitVariantFromGUIDAsString(REFGUID guid
, VARIANT
*pvar
)
617 TRACE("(%p %p)\n", guid
, pvar
);
620 FIXME("guid == NULL\n");
624 V_VT(pvar
) = VT_BSTR
;
625 V_BSTR(pvar
) = SysAllocStringLen(NULL
, 38);
627 return E_OUTOFMEMORY
;
629 PROPVAR_GUIDToWSTR(guid
, V_BSTR(pvar
));
633 HRESULT WINAPI
InitPropVariantFromBuffer(const VOID
*pv
, UINT cb
, PROPVARIANT
*ppropvar
)
635 TRACE("(%p %u %p)\n", pv
, cb
, ppropvar
);
637 ppropvar
->caub
.pElems
= CoTaskMemAlloc(cb
);
638 if(!ppropvar
->caub
.pElems
)
639 return E_OUTOFMEMORY
;
641 ppropvar
->vt
= VT_VECTOR
|VT_UI1
;
642 ppropvar
->caub
.cElems
= cb
;
643 memcpy(ppropvar
->caub
.pElems
, pv
, cb
);
647 HRESULT WINAPI
InitPropVariantFromCLSID(REFCLSID clsid
, PROPVARIANT
*ppropvar
)
649 TRACE("(%s %p)\n", debugstr_guid(clsid
), ppropvar
);
651 ppropvar
->puuid
= CoTaskMemAlloc(sizeof(*ppropvar
->puuid
));
653 return E_OUTOFMEMORY
;
655 ppropvar
->vt
= VT_CLSID
;
656 memcpy(ppropvar
->puuid
, clsid
, sizeof(*ppropvar
->puuid
));
660 HRESULT WINAPI
InitVariantFromBuffer(const VOID
*pv
, UINT cb
, VARIANT
*pvar
)
666 TRACE("(%p %u %p)\n", pv
, cb
, pvar
);
668 arr
= SafeArrayCreateVector(VT_UI1
, 0, cb
);
670 return E_OUTOFMEMORY
;
672 hres
= SafeArrayAccessData(arr
, &data
);
674 SafeArrayDestroy(arr
);
678 memcpy(data
, pv
, cb
);
680 hres
= SafeArrayUnaccessData(arr
);
682 SafeArrayDestroy(arr
);
686 V_VT(pvar
) = VT_ARRAY
|VT_UI1
;
691 HRESULT WINAPI
InitVariantFromFileTime(const FILETIME
*ft
, VARIANT
*var
)
695 TRACE("%p, %p\n", ft
, var
);
698 if (!FileTimeToSystemTime(ft
, &st
))
700 if (!SystemTimeToVariantTime(&st
, &V_DATE(var
)))
706 static inline DWORD
PROPVAR_HexToNum(const WCHAR
*hex
)
710 if(hex
[0]>='0' && hex
[0]<='9')
712 else if(hex
[0]>='a' && hex
[0]<='f')
714 else if(hex
[0]>='A' && hex
[0]<='F')
720 if(hex
[1]>='0' && hex
[1]<='9')
721 return ret
+ hex
[1]-'0';
722 else if(hex
[1]>='a' && hex
[1]<='f')
723 return ret
+ hex
[1]-'a'+10;
724 else if(hex
[1]>='A' && hex
[1]<='F')
725 return ret
+ hex
[1]-'A'+10;
730 static inline HRESULT
PROPVAR_WCHARToGUID(const WCHAR
*str
, int len
, GUID
*guid
)
735 memset(guid
, 0, sizeof(GUID
));
737 if(len
!=38 || str
[0]!='{' || str
[9]!='-' || str
[14]!='-'
738 || str
[19]!='-' || str
[24]!='-' || str
[37]!='}') {
739 WARN("Error parsing %s\n", debugstr_w(str
));
744 for(i
=0; i
<4 && val
!=-1; i
++) {
745 val
= PROPVAR_HexToNum(p
);
746 guid
->Data1
= (guid
->Data1
<<8) + val
;
750 for(i
=0; i
<2 && val
!=-1; i
++) {
751 val
= PROPVAR_HexToNum(p
);
752 guid
->Data2
= (guid
->Data2
<<8) + val
;
756 for(i
=0; i
<2 && val
!=-1; i
++) {
757 val
= PROPVAR_HexToNum(p
);
758 guid
->Data3
= (guid
->Data3
<<8) + val
;
762 for(i
=0; i
<8 && val
!=-1; i
++) {
766 val
= guid
->Data4
[i
] = PROPVAR_HexToNum(p
);
771 WARN("Error parsing %s\n", debugstr_w(str
));
772 memset(guid
, 0, sizeof(GUID
));
778 HRESULT WINAPI
PropVariantToGUID(const PROPVARIANT
*ppropvar
, GUID
*guid
)
780 TRACE("%p %p)\n", ppropvar
, guid
);
782 switch(ppropvar
->vt
) {
784 return PROPVAR_WCHARToGUID(ppropvar
->bstrVal
, SysStringLen(ppropvar
->bstrVal
), guid
);
786 return PROPVAR_WCHARToGUID(ppropvar
->pwszVal
, lstrlenW(ppropvar
->pwszVal
), guid
);
788 memcpy(guid
, ppropvar
->puuid
, sizeof(*ppropvar
->puuid
));
792 FIXME("unsupported vt: %d\n", ppropvar
->vt
);
797 HRESULT WINAPI
VariantToGUID(const VARIANT
*pvar
, GUID
*guid
)
799 TRACE("(%p %p)\n", pvar
, guid
);
803 HRESULT hres
= PROPVAR_WCHARToGUID(V_BSTR(pvar
), SysStringLen(V_BSTR(pvar
)), guid
);
804 if(hres
== E_INVALIDARG
)
810 FIXME("unsupported vt: %d\n", V_VT(pvar
));
815 static BOOL
isemptyornull(const PROPVARIANT
*propvar
)
817 if (propvar
->vt
== VT_EMPTY
|| propvar
->vt
== VT_NULL
)
819 if ((propvar
->vt
& VT_ARRAY
) == VT_ARRAY
)
822 for (i
=0; i
<propvar
->parray
->cDims
; i
++)
824 if (propvar
->parray
->rgsabound
[i
].cElements
!= 0)
827 return i
== propvar
->parray
->cDims
;
829 if (propvar
->vt
== VT_CLSID
)
830 return !propvar
->puuid
;
832 if (propvar
->vt
& VT_VECTOR
)
833 return !propvar
->caub
.cElems
;
835 /* FIXME: byrefs, errors? */
839 INT WINAPI
PropVariantCompareEx(REFPROPVARIANT propvar1
, REFPROPVARIANT propvar2
,
840 PROPVAR_COMPARE_UNIT unit
, PROPVAR_COMPARE_FLAGS flags
)
842 const PROPVARIANT
*propvar2_converted
;
843 PROPVARIANT propvar2_static
;
848 TRACE("%p,%p,%x,%x\n", propvar1
, propvar2
, unit
, flags
);
850 if (isemptyornull(propvar1
))
852 if (isemptyornull(propvar2
))
854 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? 1 : -1;
857 if (isemptyornull(propvar2
))
858 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? -1 : 1;
860 if (propvar1
->vt
!= propvar2
->vt
)
862 hr
= PropVariantChangeType(&propvar2_static
, propvar2
, 0, propvar1
->vt
);
867 propvar2_converted
= &propvar2_static
;
870 propvar2_converted
= propvar2
;
872 #define CMP_NUM_VALUE(var) do { \
873 if (propvar1->var > propvar2_converted->var) \
875 else if (propvar1->var < propvar2_converted->var) \
881 switch (propvar1
->vt
)
893 CMP_NUM_VALUE(uiVal
);
899 CMP_NUM_VALUE(ulVal
);
902 CMP_NUM_VALUE(hVal
.QuadPart
);
905 CMP_NUM_VALUE(uhVal
.QuadPart
);
908 CMP_NUM_VALUE(fltVal
);
911 CMP_NUM_VALUE(dblVal
);
915 /* FIXME: Use other string flags. */
916 if (flags
& (PVCF_USESTRCMPI
| PVCF_USESTRCMPIC
))
917 res
= lstrcmpiW(propvar1
->bstrVal
, propvar2_converted
->bstrVal
);
919 res
= lstrcmpW(propvar1
->bstrVal
, propvar2_converted
->bstrVal
);
922 /* FIXME: Use other string flags. */
923 if (flags
& (PVCF_USESTRCMPI
| PVCF_USESTRCMPIC
))
924 res
= lstrcmpiA(propvar1
->pszVal
, propvar2_converted
->pszVal
);
926 res
= lstrcmpA(propvar1
->pszVal
, propvar2_converted
->pszVal
);
929 res
= memcmp(propvar1
->puuid
, propvar2
->puuid
, sizeof(*propvar1
->puuid
));
930 if (res
) res
= res
> 0 ? 1 : -1;
932 case VT_VECTOR
| VT_UI1
:
933 count
= min(propvar1
->caub
.cElems
, propvar2
->caub
.cElems
);
934 res
= count
? memcmp(propvar1
->caub
.pElems
, propvar2
->caub
.pElems
, sizeof(*propvar1
->caub
.pElems
) * count
) : 0;
935 if (res
) res
= res
> 0 ? 1 : -1;
936 if (!res
&& propvar1
->caub
.cElems
!= propvar2
->caub
.cElems
)
937 res
= propvar1
->caub
.cElems
> propvar2
->caub
.cElems
? 1 : -1;
940 FIXME("vartype %#x not handled\n", propvar1
->vt
);
945 if (propvar2_converted
== &propvar2_static
)
946 PropVariantClear(&propvar2_static
);