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
24 #define NONAMELESSUNION
32 #include "propvarutil.h"
34 #include "wine/debug.h"
35 #include "wine/unicode.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(propsys
);
39 static HRESULT
PROPVAR_ConvertFILETIME(PROPVARIANT
*ppropvarDest
,
40 REFPROPVARIANT propvarSrc
, VARTYPE vt
)
44 FileTimeToSystemTime(&propvarSrc
->u
.filetime
, &time
);
50 static const char format
[] = "%04d/%02d/%02d:%02d:%02d:%02d.%03d";
52 ppropvarDest
->u
.pszVal
= HeapAlloc(GetProcessHeap(), 0,
54 if (!ppropvarDest
->u
.pszVal
)
57 snprintf( ppropvarDest
->u
.pszVal
, sizeof(format
),
59 time
.wYear
, time
.wMonth
, time
.wDay
,
60 time
.wHour
, time
.wMinute
, time
.wSecond
,
67 FIXME("Unhandled target type: %d\n", vt
);
73 static HRESULT
PROPVAR_ConvertNumber(REFPROPVARIANT pv
, int dest_bits
,
74 BOOL dest_signed
, LONGLONG
*res
)
106 *res
= pv
->u
.hVal
.QuadPart
;
110 *res
= pv
->u
.uhVal
.QuadPart
;
117 FIXME("unhandled vt %d\n", pv
->vt
);
121 if (*res
< 0 && src_signed
!= dest_signed
)
122 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
128 if (*res
>= ((LONGLONG
)1 << (dest_bits
-1)) ||
129 *res
< ((LONGLONG
)-1 << (dest_bits
-1)))
130 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
134 if ((ULONGLONG
)(*res
) >= ((ULONGLONG
)1 << dest_bits
))
135 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
142 HRESULT WINAPI
PropVariantToInt16(REFPROPVARIANT propvarIn
, SHORT
*ret
)
147 TRACE("%p,%p\n", propvarIn
, ret
);
149 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, TRUE
, &res
);
150 if (SUCCEEDED(hr
)) *ret
= (SHORT
)res
;
154 HRESULT WINAPI
PropVariantToInt32(REFPROPVARIANT propvarIn
, LONG
*ret
)
159 TRACE("%p,%p\n", propvarIn
, ret
);
161 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, TRUE
, &res
);
162 if (SUCCEEDED(hr
)) *ret
= (LONG
)res
;
166 HRESULT WINAPI
PropVariantToInt64(REFPROPVARIANT propvarIn
, LONGLONG
*ret
)
171 TRACE("%p,%p\n", propvarIn
, ret
);
173 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, TRUE
, &res
);
174 if (SUCCEEDED(hr
)) *ret
= (LONGLONG
)res
;
178 HRESULT WINAPI
PropVariantToUInt16(REFPROPVARIANT propvarIn
, USHORT
*ret
)
183 TRACE("%p,%p\n", propvarIn
, ret
);
185 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, FALSE
, &res
);
186 if (SUCCEEDED(hr
)) *ret
= (USHORT
)res
;
190 HRESULT WINAPI
PropVariantToUInt32(REFPROPVARIANT propvarIn
, ULONG
*ret
)
195 TRACE("%p,%p\n", propvarIn
, ret
);
197 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, FALSE
, &res
);
198 if (SUCCEEDED(hr
)) *ret
= (ULONG
)res
;
202 HRESULT WINAPI
PropVariantToUInt64(REFPROPVARIANT propvarIn
, ULONGLONG
*ret
)
207 TRACE("%p,%p\n", propvarIn
, ret
);
209 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, FALSE
, &res
);
210 if (SUCCEEDED(hr
)) *ret
= (ULONGLONG
)res
;
214 HRESULT WINAPI
PropVariantToStringAlloc(REFPROPVARIANT propvarIn
, WCHAR
**ret
)
219 TRACE("%p,%p semi-stub\n", propvarIn
, ret
);
221 switch(propvarIn
->vt
)
224 res
= CoTaskMemAlloc(1*sizeof(WCHAR
));
228 if(propvarIn
->u
.pszVal
)
232 len
= MultiByteToWideChar(CP_ACP
, 0, propvarIn
->u
.pszVal
, -1, NULL
, 0);
233 res
= CoTaskMemAlloc(len
*sizeof(WCHAR
));
235 return E_OUTOFMEMORY
;
237 MultiByteToWideChar(CP_ACP
, 0, propvarIn
->u
.pszVal
, -1, res
, len
);
241 FIXME("Unsupported conversion (%d)\n", propvarIn
->vt
);
251 /******************************************************************
252 * PropVariantChangeType (PROPSYS.@)
254 HRESULT WINAPI
PropVariantChangeType(PROPVARIANT
*ppropvarDest
, REFPROPVARIANT propvarSrc
,
255 PROPVAR_CHANGE_FLAGS flags
, VARTYPE vt
)
259 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest
, propvarSrc
,
260 propvarSrc
->vt
, flags
, vt
);
262 if(vt
== propvarSrc
->vt
)
263 return PropVariantCopy(ppropvarDest
, propvarSrc
);
270 hr
= PropVariantToInt16(propvarSrc
, &res
);
273 ppropvarDest
->vt
= VT_I2
;
274 ppropvarDest
->u
.iVal
= res
;
281 hr
= PropVariantToUInt16(propvarSrc
, &res
);
284 ppropvarDest
->vt
= VT_UI2
;
285 ppropvarDest
->u
.uiVal
= res
;
292 hr
= PropVariantToInt32(propvarSrc
, &res
);
295 ppropvarDest
->vt
= VT_I4
;
296 ppropvarDest
->u
.lVal
= res
;
303 hr
= PropVariantToUInt32(propvarSrc
, &res
);
306 ppropvarDest
->vt
= VT_UI4
;
307 ppropvarDest
->u
.ulVal
= res
;
314 hr
= PropVariantToInt64(propvarSrc
, &res
);
317 ppropvarDest
->vt
= VT_I8
;
318 ppropvarDest
->u
.hVal
.QuadPart
= res
;
325 hr
= PropVariantToUInt64(propvarSrc
, &res
);
328 ppropvarDest
->vt
= VT_UI8
;
329 ppropvarDest
->u
.uhVal
.QuadPart
= res
;
336 hr
= PropVariantToStringAlloc(propvarSrc
, &res
);
339 ppropvarDest
->vt
= VT_LPWSTR
;
340 ppropvarDest
->u
.pwszVal
= res
;
346 switch (propvarSrc
->vt
)
349 return PROPVAR_ConvertFILETIME(ppropvarDest
, propvarSrc
, vt
);
351 FIXME("Unhandled source type: %d\n", propvarSrc
->vt
);
357 static void PROPVAR_GUIDToWSTR(REFGUID guid
, WCHAR
*str
)
359 static const WCHAR format
[] = {'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X',
360 '-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X',
361 '%','0','2','X','%','0','2','X','%','0','2','X','}',0};
363 sprintfW(str
, format
, guid
->Data1
, guid
->Data2
, guid
->Data3
,
364 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
365 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
368 HRESULT WINAPI
InitPropVariantFromGUIDAsString(REFGUID guid
, PROPVARIANT
*ppropvar
)
370 TRACE("(%p %p)\n", guid
, ppropvar
);
375 ppropvar
->vt
= VT_LPWSTR
;
376 ppropvar
->u
.pwszVal
= CoTaskMemAlloc(39*sizeof(WCHAR
));
377 if(!ppropvar
->u
.pwszVal
)
378 return E_OUTOFMEMORY
;
380 PROPVAR_GUIDToWSTR(guid
, ppropvar
->u
.pwszVal
);
384 HRESULT WINAPI
InitVariantFromGUIDAsString(REFGUID guid
, VARIANT
*pvar
)
386 TRACE("(%p %p)\n", guid
, pvar
);
389 FIXME("guid == NULL\n");
393 V_VT(pvar
) = VT_BSTR
;
394 V_BSTR(pvar
) = SysAllocStringLen(NULL
, 38);
396 return E_OUTOFMEMORY
;
398 PROPVAR_GUIDToWSTR(guid
, V_BSTR(pvar
));
402 HRESULT WINAPI
InitPropVariantFromBuffer(const VOID
*pv
, UINT cb
, PROPVARIANT
*ppropvar
)
404 TRACE("(%p %u %p)\n", pv
, cb
, ppropvar
);
406 ppropvar
->u
.caub
.pElems
= CoTaskMemAlloc(cb
);
407 if(!ppropvar
->u
.caub
.pElems
)
408 return E_OUTOFMEMORY
;
410 ppropvar
->vt
= VT_VECTOR
|VT_UI1
;
411 ppropvar
->u
.caub
.cElems
= cb
;
412 memcpy(ppropvar
->u
.caub
.pElems
, pv
, cb
);
416 HRESULT WINAPI
InitVariantFromBuffer(const VOID
*pv
, UINT cb
, VARIANT
*pvar
)
422 TRACE("(%p %u %p)\n", pv
, cb
, pvar
);
424 arr
= SafeArrayCreateVector(VT_UI1
, 0, cb
);
426 return E_OUTOFMEMORY
;
428 hres
= SafeArrayAccessData(arr
, &data
);
430 SafeArrayDestroy(arr
);
434 memcpy(data
, pv
, cb
);
436 hres
= SafeArrayUnaccessData(arr
);
438 SafeArrayDestroy(arr
);
442 V_VT(pvar
) = VT_ARRAY
|VT_UI1
;
447 static inline DWORD
PROPVAR_HexToNum(const WCHAR
*hex
)
451 if(hex
[0]>='0' && hex
[0]<='9')
453 else if(hex
[0]>='a' && hex
[0]<='f')
455 else if(hex
[0]>='A' && hex
[0]<='F')
461 if(hex
[1]>='0' && hex
[1]<='9')
462 return ret
+ hex
[1]-'0';
463 else if(hex
[1]>='a' && hex
[1]<='f')
464 return ret
+ hex
[1]-'a'+10;
465 else if(hex
[1]>='A' && hex
[1]<='F')
466 return ret
+ hex
[1]-'A'+10;
471 static inline HRESULT
PROPVAR_WCHARToGUID(const WCHAR
*str
, int len
, GUID
*guid
)
476 memset(guid
, 0, sizeof(GUID
));
478 if(len
!=38 || str
[0]!='{' || str
[9]!='-' || str
[14]!='-'
479 || str
[19]!='-' || str
[24]!='-' || str
[37]!='}') {
480 WARN("Error parsing %s\n", debugstr_w(str
));
485 for(i
=0; i
<4 && val
!=-1; i
++) {
486 val
= PROPVAR_HexToNum(p
);
487 guid
->Data1
= (guid
->Data1
<<8) + val
;
491 for(i
=0; i
<2 && val
!=-1; i
++) {
492 val
= PROPVAR_HexToNum(p
);
493 guid
->Data2
= (guid
->Data2
<<8) + val
;
497 for(i
=0; i
<2 && val
!=-1; i
++) {
498 val
= PROPVAR_HexToNum(p
);
499 guid
->Data3
= (guid
->Data3
<<8) + val
;
503 for(i
=0; i
<8 && val
!=-1; i
++) {
507 val
= guid
->Data4
[i
] = PROPVAR_HexToNum(p
);
512 WARN("Error parsing %s\n", debugstr_w(str
));
513 memset(guid
, 0, sizeof(GUID
));
519 HRESULT WINAPI
PropVariantToGUID(const PROPVARIANT
*ppropvar
, GUID
*guid
)
521 TRACE("%p %p)\n", ppropvar
, guid
);
523 switch(ppropvar
->vt
) {
525 return PROPVAR_WCHARToGUID(ppropvar
->u
.bstrVal
, SysStringLen(ppropvar
->u
.bstrVal
), guid
);
527 return PROPVAR_WCHARToGUID(ppropvar
->u
.pwszVal
, strlenW(ppropvar
->u
.pwszVal
), guid
);
530 FIXME("unsupported vt: %d\n", ppropvar
->vt
);
535 HRESULT WINAPI
VariantToGUID(const VARIANT
*pvar
, GUID
*guid
)
537 TRACE("(%p %p)\n", pvar
, guid
);
541 HRESULT hres
= PROPVAR_WCHARToGUID(V_BSTR(pvar
), SysStringLen(V_BSTR(pvar
)), guid
);
542 if(hres
== E_INVALIDARG
)
548 FIXME("unsupported vt: %d\n", V_VT(pvar
));
553 static BOOL
isemptyornull(const PROPVARIANT
*propvar
)
555 if (propvar
->vt
== VT_EMPTY
|| propvar
->vt
== VT_NULL
)
557 if ((propvar
->vt
& VT_ARRAY
) == VT_ARRAY
)
560 for (i
=0; i
<propvar
->u
.parray
->cDims
; i
++)
562 if (propvar
->u
.parray
->rgsabound
[i
].cElements
!= 0)
565 return i
== propvar
->u
.parray
->cDims
;
567 /* FIXME: vectors, byrefs, errors? */
571 INT WINAPI
PropVariantCompareEx(REFPROPVARIANT propvar1
, REFPROPVARIANT propvar2
,
572 PROPVAR_COMPARE_UNIT unit
, PROPVAR_COMPARE_FLAGS flags
)
574 const PROPVARIANT
*propvar2_converted
;
575 PROPVARIANT propvar2_static
;
579 TRACE("%p,%p,%x,%x\n", propvar1
, propvar2
, unit
, flags
);
581 if (isemptyornull(propvar1
))
583 if (isemptyornull(propvar2
))
585 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? 1 : -1;
588 if (isemptyornull(propvar2
))
589 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? -1 : 1;
591 if (propvar1
->vt
!= propvar2
->vt
)
593 hr
= PropVariantChangeType(&propvar2_static
, propvar2
, 0, propvar1
->vt
);
598 propvar2_converted
= &propvar2_static
;
601 propvar2_converted
= propvar2
;
603 #define CMP_INT_VALUE(var) do { \
604 if (propvar1->u.var > propvar2_converted->u.var) \
606 else if (propvar1->u.var < propvar2_converted->u.var) \
612 switch (propvar1
->vt
)
624 CMP_INT_VALUE(uiVal
);
630 CMP_INT_VALUE(uiVal
);
633 CMP_INT_VALUE(hVal
.QuadPart
);
636 CMP_INT_VALUE(uhVal
.QuadPart
);
639 /* FIXME: Use string flags. */
640 res
= lstrcmpW(propvar1
->u
.bstrVal
, propvar2
->u
.bstrVal
);
643 FIXME("vartype %d not handled\n", propvar1
->vt
);
648 if (propvar2_converted
== &propvar2_static
)
649 PropVariantClear(&propvar2_static
);