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
21 #include "propsys_private.h"
26 #include <propvarutil.h>
28 static HRESULT
PROPVAR_ConvertFILETIME(PROPVARIANT
*ppropvarDest
,
29 REFPROPVARIANT propvarSrc
, VARTYPE vt
)
33 FileTimeToSystemTime(&propvarSrc
->u
.filetime
, &time
);
39 static const char format
[] = "%04d/%02d/%02d:%02d:%02d:%02d.%03d";
41 ppropvarDest
->u
.pszVal
= HeapAlloc(GetProcessHeap(), 0,
42 lstrlenA(format
) + 1);
43 if (!ppropvarDest
->u
.pszVal
)
46 sprintf(ppropvarDest
->u
.pszVal
, format
, time
.wYear
, time
.wMonth
,
47 time
.wDay
, time
.wHour
, time
.wMinute
,
48 time
.wSecond
, time
.wMilliseconds
);
54 FIXME("Unhandled target type: %d\n", vt
);
60 static HRESULT
PROPVAR_ConvertNumber(REFPROPVARIANT pv
, int dest_bits
,
61 int dest_signed
, LONGLONG
*res
)
93 *res
= pv
->u
.hVal
.QuadPart
;
97 *res
= pv
->u
.uhVal
.QuadPart
;
104 FIXME("unhandled vt %d\n", pv
->vt
);
108 if (*res
< 0 && src_signed
!= dest_signed
)
109 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
115 if (*res
>= ((LONGLONG
)1 << (dest_bits
-1)) ||
116 *res
< ((LONGLONG
)-1 << (dest_bits
-1)))
117 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
121 if ((ULONGLONG
)(*res
) >= ((ULONGLONG
)1 << dest_bits
))
122 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW
);
129 HRESULT WINAPI
PropVariantToInt16(REFPROPVARIANT propvarIn
, SHORT
*ret
)
134 TRACE("%p,%p\n", propvarIn
, ret
);
136 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, 1, &res
);
137 if (SUCCEEDED(hr
)) *ret
= (SHORT
)res
;
141 HRESULT WINAPI
PropVariantToInt32(REFPROPVARIANT propvarIn
, LONG
*ret
)
146 TRACE("%p,%p\n", propvarIn
, ret
);
148 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, 1, &res
);
149 if (SUCCEEDED(hr
)) *ret
= (LONG
)res
;
153 HRESULT WINAPI
PropVariantToInt64(REFPROPVARIANT propvarIn
, LONGLONG
*ret
)
158 TRACE("%p,%p\n", propvarIn
, ret
);
160 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, 1, &res
);
161 if (SUCCEEDED(hr
)) *ret
= (LONGLONG
)res
;
165 HRESULT WINAPI
PropVariantToUInt16(REFPROPVARIANT propvarIn
, USHORT
*ret
)
170 TRACE("%p,%p\n", propvarIn
, ret
);
172 hr
= PROPVAR_ConvertNumber(propvarIn
, 16, 0, &res
);
173 if (SUCCEEDED(hr
)) *ret
= (USHORT
)res
;
177 HRESULT WINAPI
PropVariantToUInt32(REFPROPVARIANT propvarIn
, ULONG
*ret
)
182 TRACE("%p,%p\n", propvarIn
, ret
);
184 hr
= PROPVAR_ConvertNumber(propvarIn
, 32, 0, &res
);
185 if (SUCCEEDED(hr
)) *ret
= (ULONG
)res
;
189 HRESULT WINAPI
PropVariantToUInt64(REFPROPVARIANT propvarIn
, ULONGLONG
*ret
)
194 TRACE("%p,%p\n", propvarIn
, ret
);
196 hr
= PROPVAR_ConvertNumber(propvarIn
, 64, 0, &res
);
197 if (SUCCEEDED(hr
)) *ret
= (ULONGLONG
)res
;
201 /******************************************************************
202 * PropVariantChangeType (PROPSYS.@)
204 HRESULT WINAPI
PropVariantChangeType(PROPVARIANT
*ppropvarDest
, REFPROPVARIANT propvarSrc
,
205 PROPVAR_CHANGE_FLAGS flags
, VARTYPE vt
)
209 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest
, propvarSrc
,
210 propvarSrc
->vt
, flags
, vt
);
217 hr
= PropVariantToInt16(propvarSrc
, &res
);
220 ppropvarDest
->vt
= VT_I2
;
221 ppropvarDest
->u
.iVal
= res
;
228 hr
= PropVariantToUInt16(propvarSrc
, &res
);
231 ppropvarDest
->vt
= VT_UI2
;
232 ppropvarDest
->u
.uiVal
= res
;
239 hr
= PropVariantToInt32(propvarSrc
, &res
);
242 ppropvarDest
->vt
= VT_I4
;
243 ppropvarDest
->u
.lVal
= res
;
250 hr
= PropVariantToUInt32(propvarSrc
, &res
);
253 ppropvarDest
->vt
= VT_UI4
;
254 ppropvarDest
->u
.ulVal
= res
;
261 hr
= PropVariantToInt64(propvarSrc
, &res
);
264 ppropvarDest
->vt
= VT_I8
;
265 ppropvarDest
->u
.hVal
.QuadPart
= res
;
272 hr
= PropVariantToUInt64(propvarSrc
, &res
);
275 ppropvarDest
->vt
= VT_UI8
;
276 ppropvarDest
->u
.uhVal
.QuadPart
= res
;
282 switch (propvarSrc
->vt
)
285 return PROPVAR_ConvertFILETIME(ppropvarDest
, propvarSrc
, vt
);
287 FIXME("Unhandled source type: %d\n", propvarSrc
->vt
);
293 static void PROPVAR_GUIDToWSTR(REFGUID guid
, WCHAR
*str
)
295 static const WCHAR format
[] = {'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X',
296 '-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X',
297 '%','0','2','X','%','0','2','X','%','0','2','X','}',0};
299 sprintfW(str
, format
, guid
->Data1
, guid
->Data2
, guid
->Data3
,
300 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
301 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
304 HRESULT WINAPI
InitPropVariantFromGUIDAsString(REFGUID guid
, PROPVARIANT
*ppropvar
)
306 TRACE("(%p %p)\n", guid
, ppropvar
);
311 ppropvar
->vt
= VT_LPWSTR
;
312 ppropvar
->u
.pwszVal
= CoTaskMemAlloc(39*sizeof(WCHAR
));
313 if(!ppropvar
->u
.pwszVal
)
314 return E_OUTOFMEMORY
;
316 PROPVAR_GUIDToWSTR(guid
, ppropvar
->u
.pwszVal
);
320 HRESULT WINAPI
InitVariantFromGUIDAsString(REFGUID guid
, VARIANT
*pvar
)
322 TRACE("(%p %p)\n", guid
, pvar
);
325 FIXME("guid == NULL\n");
329 V_VT(pvar
) = VT_BSTR
;
330 V_BSTR(pvar
) = SysAllocStringLen(NULL
, 38);
332 return E_OUTOFMEMORY
;
334 PROPVAR_GUIDToWSTR(guid
, V_BSTR(pvar
));
338 HRESULT WINAPI
InitPropVariantFromBuffer(const VOID
*pv
, UINT cb
, PROPVARIANT
*ppropvar
)
340 TRACE("(%p %u %p)\n", pv
, cb
, ppropvar
);
342 ppropvar
->u
.caub
.pElems
= CoTaskMemAlloc(cb
);
343 if(!ppropvar
->u
.caub
.pElems
)
344 return E_OUTOFMEMORY
;
346 ppropvar
->vt
= VT_VECTOR
|VT_UI1
;
347 ppropvar
->u
.caub
.cElems
= cb
;
348 memcpy(ppropvar
->u
.caub
.pElems
, pv
, cb
);
352 HRESULT WINAPI
InitVariantFromBuffer(const VOID
*pv
, UINT cb
, VARIANT
*pvar
)
358 TRACE("(%p %u %p)\n", pv
, cb
, pvar
);
360 arr
= SafeArrayCreateVector(VT_UI1
, 0, cb
);
362 return E_OUTOFMEMORY
;
364 hres
= SafeArrayAccessData(arr
, &data
);
366 SafeArrayDestroy(arr
);
370 memcpy(data
, pv
, cb
);
372 hres
= SafeArrayUnaccessData(arr
);
374 SafeArrayDestroy(arr
);
378 V_VT(pvar
) = VT_ARRAY
|VT_UI1
;
383 static inline DWORD
PROPVAR_HexToNum(const WCHAR
*hex
)
387 if(hex
[0]>='0' && hex
[0]<='9')
389 else if(hex
[0]>='a' && hex
[0]<='f')
391 else if(hex
[0]>='A' && hex
[0]<='F')
397 if(hex
[1]>='0' && hex
[1]<='9')
398 return ret
+ hex
[1]-'0';
399 else if(hex
[1]>='a' && hex
[1]<='f')
400 return ret
+ hex
[1]-'a'+10;
401 else if(hex
[1]>='A' && hex
[1]<='F')
402 return ret
+ hex
[1]-'A'+10;
407 static inline HRESULT
PROPVAR_WCHARToGUID(const WCHAR
*str
, int len
, GUID
*guid
)
412 memset(guid
, 0, sizeof(GUID
));
414 if(len
!=38 || str
[0]!='{' || str
[9]!='-' || str
[14]!='-'
415 || str
[19]!='-' || str
[24]!='-' || str
[37]!='}') {
416 WARN("Error parsing %s\n", debugstr_w(str
));
421 for(i
=0; i
<4 && val
!=-1; i
++) {
422 val
= PROPVAR_HexToNum(p
);
423 guid
->Data1
= (guid
->Data1
<<8) + val
;
427 for(i
=0; i
<2 && val
!=-1; i
++) {
428 val
= PROPVAR_HexToNum(p
);
429 guid
->Data2
= (guid
->Data2
<<8) + val
;
433 for(i
=0; i
<2 && val
!=-1; i
++) {
434 val
= PROPVAR_HexToNum(p
);
435 guid
->Data3
= (guid
->Data3
<<8) + val
;
439 for(i
=0; i
<8 && val
!=-1; i
++) {
443 val
= guid
->Data4
[i
] = PROPVAR_HexToNum(p
);
448 WARN("Error parsing %s\n", debugstr_w(str
));
449 memset(guid
, 0, sizeof(GUID
));
455 HRESULT WINAPI
PropVariantToGUID(const PROPVARIANT
*ppropvar
, GUID
*guid
)
457 TRACE("%p %p)\n", ppropvar
, guid
);
459 switch(ppropvar
->vt
) {
461 return PROPVAR_WCHARToGUID(ppropvar
->u
.bstrVal
, SysStringLen(ppropvar
->u
.bstrVal
), guid
);
463 return PROPVAR_WCHARToGUID(ppropvar
->u
.pwszVal
, strlenW(ppropvar
->u
.pwszVal
), guid
);
466 FIXME("unsupported vt: %d\n", ppropvar
->vt
);
471 HRESULT WINAPI
VariantToGUID(const VARIANT
*pvar
, GUID
*guid
)
473 TRACE("(%p %p)\n", pvar
, guid
);
477 HRESULT hres
= PROPVAR_WCHARToGUID(V_BSTR(pvar
), SysStringLen(V_BSTR(pvar
)), guid
);
478 if(hres
== E_INVALIDARG
)
484 FIXME("unsupported vt: %d\n", V_VT(pvar
));
489 static int isemptyornull(const PROPVARIANT
*propvar
)
491 if (propvar
->vt
== VT_EMPTY
|| propvar
->vt
== VT_NULL
)
493 if ((propvar
->vt
& VT_ARRAY
) == VT_ARRAY
)
496 for (i
=0; i
<propvar
->u
.parray
->cDims
; i
++)
498 if (propvar
->u
.parray
->rgsabound
[i
].cElements
!= 0)
501 return i
== propvar
->u
.parray
->cDims
;
503 /* FIXME: vectors, byrefs, errors? */
507 INT WINAPI
PropVariantCompareEx(REFPROPVARIANT propvar1
, REFPROPVARIANT propvar2
,
508 PROPVAR_COMPARE_UNIT unit
, PROPVAR_COMPARE_FLAGS flags
)
510 const PROPVARIANT
*propvar2_converted
;
511 PROPVARIANT propvar2_static
;
515 TRACE("%p,%p,%x,%x\n", propvar1
, propvar2
, unit
, flags
);
517 if (isemptyornull(propvar1
))
519 if (isemptyornull(propvar2
))
521 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? 1 : -1;
524 if (isemptyornull(propvar2
))
525 return (flags
& PVCF_TREATEMPTYASGREATERTHAN
) ? -1 : 1;
527 if (propvar1
->vt
!= propvar2
->vt
)
529 hr
= PropVariantChangeType(&propvar2_static
, propvar2
, 0, propvar1
->vt
);
534 propvar2_converted
= &propvar2_static
;
537 propvar2_converted
= propvar2
;
539 #define CMP_INT_VALUE(var) do { \
540 if (propvar1->u.var > propvar2_converted->u.var) \
542 else if (propvar1->u.var < propvar2_converted->u.var) \
548 switch (propvar1
->vt
)
560 CMP_INT_VALUE(uiVal
);
566 CMP_INT_VALUE(uiVal
);
569 CMP_INT_VALUE(hVal
.QuadPart
);
572 CMP_INT_VALUE(uhVal
.QuadPart
);
575 /* FIXME: Use string flags. */
576 res
= lstrcmpW(propvar1
->u
.bstrVal
, propvar2
->u
.bstrVal
);
579 FIXME("vartype %d not handled\n", propvar1
->vt
);
584 if (propvar2_converted
== &propvar2_static
)
585 PropVariantClear(&propvar2_static
);