propvarutil.h File Reference

#include <shtypes.h>
#include <shlwapi.h>

Include dependency graph for propvarutil.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef int	PROPVAR_CHANGE_FLAGS
typedef int	PROPVAR_COMPARE_UNIT
typedef int	PROPVAR_COMPARE_FLAGS

Enumerations
enum	tagPROPVAR_CHANGE_FLAGS {   PVCHF_DEFAULT = 0x00000000 , PVCHF_NOVALUEPROP = 0x00000001 , PVCHF_ALPHABOOL = 0x00000002 , PVCHF_NOUSEROVERRIDE = 0x00000004 ,   PVCHF_LOCALBOOL = 0x00000008 , PVCHF_NOHEXSTRING = 0x00000010 }
enum	tagPROPVAR_COMPARE_UNIT {   PVCU_DEFAULT = 0x00000000 , PVCU_SECOND = 0x00000001 , PVCU_MINUTE = 0x00000002 , PVCU_HOUR = 0x00000003 ,   PVCU_DAY = 0x00000004 , PVCU_MONTH = 0x00000005 , PVCU_YEAR = 0x00000006 }
enum	tagPROPVAR_COMPARE_FLAGS {   PVCF_DEFAULT = 0x00000000 , PVCF_TREATEMPTYASGREATERTHAN = 0x00000001 , PVCF_USESTRCMP = 0x00000002 , PVCF_USESTRCMPC = 0x00000004 ,   PVCF_USESTRCMPI = 0x00000008 , PVCF_USESTRCMPIC = 0x00000010 }

Functions
HRESULT WINAPI	PropVariantChangeType (PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
HRESULT WINAPI	InitPropVariantFromGUIDAsString (REFGUID guid, PROPVARIANT *ppropvar)
HRESULT WINAPI	InitVariantFromGUIDAsString (REFGUID guid, VARIANT *pvar)
HRESULT WINAPI	InitPropVariantFromBuffer (const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
HRESULT WINAPI	InitPropVariantFromCLSID (REFCLSID clsid, PROPVARIANT *ppropvar)
HRESULT WINAPI	InitVariantFromBuffer (const VOID *pv, UINT cb, VARIANT *pvar)
HRESULT WINAPI	PropVariantToGUID (const PROPVARIANT *ppropvar, GUID *guid)
HRESULT WINAPI	VariantToGUID (const VARIANT *pvar, GUID *guid)
INT WINAPI	PropVariantCompareEx (REFPROPVARIANT propvar1, REFPROPVARIANT propvar2, PROPVAR_COMPARE_UNIT uint, PROPVAR_COMPARE_FLAGS flags)
HRESULT WINAPI	PropVariantToDouble (REFPROPVARIANT propvarIn, double *ret)
HRESULT WINAPI	PropVariantToInt16 (REFPROPVARIANT propvarIn, SHORT *ret)
HRESULT WINAPI	PropVariantToInt32 (REFPROPVARIANT propvarIn, LONG *ret)
HRESULT WINAPI	PropVariantToInt64 (REFPROPVARIANT propvarIn, LONGLONG *ret)
HRESULT WINAPI	PropVariantToUInt16 (REFPROPVARIANT propvarIn, USHORT *ret)
HRESULT WINAPI	PropVariantToUInt32 (REFPROPVARIANT propvarIn, ULONG *ret)
HRESULT WINAPI	PropVariantToUInt64 (REFPROPVARIANT propvarIn, ULONGLONG *ret)
HRESULT WINAPI	PropVariantToBoolean (REFPROPVARIANT propvarIn, BOOL *ret)
HRESULT WINAPI	PropVariantToBuffer (REFPROPVARIANT propvarIn, void *ret, UINT cb)
HRESULT WINAPI	PropVariantToString (REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
PCWSTR WINAPI	PropVariantToStringWithDefault (REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
HRESULT WINAPI	PropVariantToStringAlloc (REFPROPVARIANT propvarIn, WCHAR **ret)

Typedef Documentation

PROPVAR_CHANGE_FLAGS

typedef int PROPVAR_CHANGE_FLAGS

Definition at line 39 of file propvarutil.h.

PROPVAR_COMPARE_FLAGS

typedef int PROPVAR_COMPARE_FLAGS

Definition at line 64 of file propvarutil.h.

PROPVAR_COMPARE_UNIT

typedef int PROPVAR_COMPARE_UNIT

Definition at line 52 of file propvarutil.h.

Enumeration Type Documentation

tagPROPVAR_CHANGE_FLAGS

enum tagPROPVAR_CHANGE_FLAGS

Enumerator
PVCHF_DEFAULT
PVCHF_NOVALUEPROP
PVCHF_ALPHABOOL
PVCHF_NOUSEROVERRIDE
PVCHF_LOCALBOOL
PVCHF_NOHEXSTRING

Definition at line 29 of file propvarutil.h.

{
    PVCHF_DEFAULT           = 0x00000000,
    PVCHF_NOVALUEPROP       = 0x00000001,
    PVCHF_ALPHABOOL         = 0x00000002,
    PVCHF_NOUSEROVERRIDE    = 0x00000004,
    PVCHF_LOCALBOOL         = 0x00000008,
    PVCHF_NOHEXSTRING       = 0x00000010,
};

tagPROPVAR_COMPARE_FLAGS

enum tagPROPVAR_COMPARE_FLAGS

Enumerator
PVCF_DEFAULT
PVCF_TREATEMPTYASGREATERTHAN
PVCF_USESTRCMP
PVCF_USESTRCMPC
PVCF_USESTRCMPI
PVCF_USESTRCMPIC

Definition at line 54 of file propvarutil.h.

{
    PVCF_DEFAULT           = 0x00000000,
    PVCF_TREATEMPTYASGREATERTHAN = 0x00000001,
    PVCF_USESTRCMP         = 0x00000002,
    PVCF_USESTRCMPC        = 0x00000004,
    PVCF_USESTRCMPI        = 0x00000008,
    PVCF_USESTRCMPIC       = 0x00000010,
};

tagPROPVAR_COMPARE_UNIT

enum tagPROPVAR_COMPARE_UNIT

Enumerator
PVCU_DEFAULT
PVCU_SECOND
PVCU_MINUTE
PVCU_HOUR
PVCU_DAY
PVCU_MONTH
PVCU_YEAR

Definition at line 41 of file propvarutil.h.

{
    PVCU_DEFAULT           = 0x00000000,
    PVCU_SECOND            = 0x00000001,
    PVCU_MINUTE            = 0x00000002,
    PVCU_HOUR              = 0x00000003,
    PVCU_DAY               = 0x00000004,
    PVCU_MONTH             = 0x00000005,
    PVCU_YEAR              = 0x00000006,
};

Function Documentation

InitPropVariantFromBuffer()

HRESULT WINAPI InitPropVariantFromBuffer	(	const VOID *	pv,
		UINT	cb,
		PROPVARIANT *	ppropvar
	)

Definition at line 626 of file propvar.c.

{
    TRACE("(%p %u %p)\n", pv, cb, ppropvar);
 
    ppropvar->u.caub.pElems = CoTaskMemAlloc(cb);
    if(!ppropvar->u.caub.pElems)
        return E_OUTOFMEMORY;
 
    ppropvar->vt = VT_VECTOR|VT_UI1;
    ppropvar->u.caub.cElems = cb;
    memcpy(ppropvar->u.caub.pElems, pv, cb);
    return S_OK;
}

Referenced by test_InitPropVariantFromBuffer(), and test_PropVariantToBuffer().

InitPropVariantFromCLSID()

HRESULT WINAPI InitPropVariantFromCLSID	(	REFCLSID	clsid,
		PROPVARIANT *	ppropvar
	)

Definition at line 640 of file propvar.c.

{
    TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);
 
    ppropvar->u.puuid = CoTaskMemAlloc(sizeof(*ppropvar->u.puuid));
    if(!ppropvar->u.puuid)
        return E_OUTOFMEMORY;
 
    ppropvar->vt = VT_CLSID;
    memcpy(ppropvar->u.puuid, clsid, sizeof(*ppropvar->u.puuid));
    return S_OK;
}

Referenced by test_InitPropVariantFromCLSID(), and test_PropVariantToGUID().

InitPropVariantFromGUIDAsString()

HRESULT WINAPI InitPropVariantFromGUIDAsString	(	REFGUID	guid,
		PROPVARIANT *	ppropvar
	)

Definition at line 592 of file propvar.c.

{
    TRACE("(%p %p)\n", guid, ppropvar);
 
    if(!guid)
        return E_FAIL;
 
    ppropvar->vt = VT_LPWSTR;
    ppropvar->u.pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR));
    if(!ppropvar->u.pwszVal)
        return E_OUTOFMEMORY;
 
    PROPVAR_GUIDToWSTR(guid, ppropvar->u.pwszVal);
    return S_OK;
}

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

InitVariantFromBuffer()

HRESULT WINAPI InitVariantFromBuffer	(	const VOID *	pv,
		UINT	cb,
		VARIANT *	pvar
	)

Definition at line 653 of file propvar.c.

{
    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;
}

Referenced by test_InitPropVariantFromBuffer().

InitVariantFromGUIDAsString()

HRESULT WINAPI InitVariantFromGUIDAsString	(	REFGUID	guid,
		VARIANT *	pvar
	)

Definition at line 608 of file propvar.c.

{
    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;
}

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

PropVariantChangeType()

HRESULT WINAPI PropVariantChangeType	(	PROPVARIANT *	ppropvarDest,
		REFPROPVARIANT	propvarSrc,
		PROPVAR_CHANGE_FLAGS	flags,
		VARTYPE	vt
	)

Definition at line 428 of file propvar.c.

{
    HRESULT hr;
 
    FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
          propvarSrc->vt, flags, vt);
 
    if (vt == propvarSrc->vt)
        return PropVariantCopy(ppropvarDest, propvarSrc);
 
    if (propvarSrc->vt == VT_FILETIME)
        return PROPVAR_ConvertFILETIME(&propvarSrc->u.filetime, ppropvarDest, vt);
 
    switch (vt)
    {
    case VT_I1:
    {
        LONGLONG res;
 
        hr = PROPVAR_ConvertNumber(propvarSrc, 8, TRUE, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I1;
            ppropvarDest->u.cVal = (char)res;
        }
        return hr;
    }
 
    case VT_UI1:
    {
        LONGLONG res;
 
        hr = PROPVAR_ConvertNumber(propvarSrc, 8, FALSE, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI1;
            ppropvarDest->u.bVal = (UCHAR)res;
        }
        return hr;
    }
 
    case VT_I2:
    {
        SHORT res;
        hr = PropVariantToInt16(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I2;
            ppropvarDest->u.iVal = res;
        }
        return hr;
    }
    case VT_UI2:
    {
        USHORT res;
        hr = PropVariantToUInt16(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI2;
            ppropvarDest->u.uiVal = res;
        }
        return hr;
    }
    case VT_I4:
    {
        LONG res;
        hr = PropVariantToInt32(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I4;
            ppropvarDest->u.lVal = res;
        }
        return hr;
    }
    case VT_UI4:
    {
        ULONG res;
        hr = PropVariantToUInt32(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI4;
            ppropvarDest->u.ulVal = res;
        }
        return hr;
    }
    case VT_I8:
    {
        LONGLONG res;
        hr = PropVariantToInt64(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_I8;
            ppropvarDest->u.hVal.QuadPart = res;
        }
        return hr;
    }
    case VT_UI8:
    {
        ULONGLONG res;
        hr = PropVariantToUInt64(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_UI8;
            ppropvarDest->u.uhVal.QuadPart = res;
        }
        return hr;
    }
 
    case VT_LPWSTR:
    case VT_BSTR:
    {
        WCHAR *res;
        hr = PropVariantToStringAlloc(propvarSrc, &res);
        if (SUCCEEDED(hr))
        {
            ppropvarDest->vt = VT_LPWSTR;
            ppropvarDest->u.pwszVal = res;
        }
        return hr;
    }
 
    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;
                ppropvarDest->u.pszVal = res;
            }
            else
                hr = E_OUTOFMEMORY;
 
            CoTaskMemFree(resW);
        }
        return hr;
    }
 
    default:
        FIXME("Unhandled dest type: %d\n", vt);
        return E_FAIL;
    }
}

Referenced by get_token(), MimeBody_GetProp(), PropVariantCompareEx(), and test_PropVariantChangeType_LPWSTR().

PropVariantCompareEx()

INT WINAPI PropVariantCompareEx	(	REFPROPVARIANT	propvar1,
		REFPROPVARIANT	propvar2,
		PROPVAR_COMPARE_UNIT	uint,
		PROPVAR_COMPARE_FLAGS	flags
	)

Definition at line 814 of file propvar.c.

{
    const PROPVARIANT *propvar2_converted;
    PROPVARIANT propvar2_static;
    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;
 
#define CMP_NUM_VALUE(var) do { \
    if (propvar1->u.var > propvar2_converted->u.var) \
        res = 1; \
    else if (propvar1->u.var < propvar2_converted->u.var) \
        res = -1; \
    else \
        res = 0; \
    } while (0)
 
    switch (propvar1->vt)
    {
    case VT_I1:
        CMP_NUM_VALUE(cVal);
        break;
    case VT_UI1:
        CMP_NUM_VALUE(bVal);
        break;
    case VT_I2:
        CMP_NUM_VALUE(iVal);
        break;
    case VT_UI2:
        CMP_NUM_VALUE(uiVal);
        break;
    case VT_I4:
        CMP_NUM_VALUE(lVal);
        break;
    case VT_UI4:
        CMP_NUM_VALUE(uiVal);
        break;
    case VT_I8:
        CMP_NUM_VALUE(hVal.QuadPart);
        break;
    case VT_UI8:
        CMP_NUM_VALUE(uhVal.QuadPart);
        break;
    case VT_R4:
        CMP_NUM_VALUE(fltVal);
        break;
    case VT_R8:
        CMP_NUM_VALUE(dblVal);
        break;
    case VT_BSTR:
    case VT_LPWSTR:
        /* FIXME: Use other string flags. */
        if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
            res = lstrcmpiW(propvar1->u.bstrVal, propvar2_converted->u.bstrVal);
        else
            res = lstrcmpW(propvar1->u.bstrVal, propvar2_converted->u.bstrVal);
        break;
    case VT_LPSTR:
        /* FIXME: Use other string flags. */
        if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
            res = lstrcmpiA(propvar1->u.pszVal, propvar2_converted->u.pszVal);
        else
            res = lstrcmpA(propvar1->u.pszVal, propvar2_converted->u.pszVal);
        break;
    case VT_CLSID:
        res = memcmp(propvar1->u.puuid, propvar2->u.puuid, sizeof(*propvar1->u.puuid));
        if (res) res = res > 0 ? 1 : -1;
        break;
    default:
        FIXME("vartype %#x not handled\n", propvar1->vt);
        res = -1;
        break;
    }
 
    if (propvar2_converted == &propvar2_static)
        PropVariantClear(&propvar2_static);
 
    return res;
}

Referenced by MetadataHandler_GetValue(), and test_PropVariantCompare().

PropVariantToBoolean()

HRESULT WINAPI PropVariantToBoolean	(	REFPROPVARIANT	propvarIn,
		BOOL *	ret
	)

Definition at line 246 of file propvar.c.

{
    static const WCHAR trueW[] = {'t','r','u','e',0};
    static const WCHAR falseW[] = {'f','a','l','s','e',0};
    static const WCHAR true2W[] = {'#','T','R','U','E','#',0};
    static const WCHAR false2W[] = {'#','F','A','L','S','E','#',0};
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    *ret = FALSE;
 
    switch (propvarIn->vt)
    {
        case VT_BOOL:
            *ret = propvarIn->u.boolVal == VARIANT_TRUE;
            return S_OK;
 
        case VT_LPWSTR:
        case VT_BSTR:
            if (!propvarIn->u.pwszVal)
                return DISP_E_TYPEMISMATCH;
 
            if (!lstrcmpiW(propvarIn->u.pwszVal, trueW) || !lstrcmpW(propvarIn->u.pwszVal, true2W))
            {
                *ret = TRUE;
                return S_OK;
            }
 
            if (!lstrcmpiW(propvarIn->u.pwszVal, falseW) || !lstrcmpW(propvarIn->u.pwszVal, false2W))
            {
                *ret = FALSE;
                return S_OK;
            }
            break;
 
         case VT_LPSTR:
            if (!propvarIn->u.pszVal)
                return DISP_E_TYPEMISMATCH;
 
            if (!lstrcmpiA(propvarIn->u.pszVal, "true") || !lstrcmpA(propvarIn->u.pszVal, "#TRUE#"))
            {
                *ret = TRUE;
                return S_OK;
            }
 
            if (!lstrcmpiA(propvarIn->u.pszVal, "false") || !lstrcmpA(propvarIn->u.pszVal, "#FALSE#"))
            {
                *ret = FALSE;
                return S_OK;
            }
            break;
    }
 
    hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
    *ret = !!res;
    return hr;
}

Referenced by test_PropVariantToBoolean().

PropVariantToBuffer()

HRESULT WINAPI PropVariantToBuffer	(	REFPROPVARIANT	propvarIn,
		void *	ret,
		UINT	cb
	)

Definition at line 306 of file propvar.c.

{
    HRESULT hr = S_OK;
 
    TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);
 
    switch(propvarIn->vt)
    {
        case VT_VECTOR|VT_UI1:
            if(cb > propvarIn->u.caub.cElems)
                return E_FAIL;
            memcpy(ret, propvarIn->u.caub.pElems, cb);
            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;
}

Referenced by test_PropVariantToBuffer().

PropVariantToDouble()

HRESULT WINAPI PropVariantToDouble	(	REFPROPVARIANT	propvarIn,
		double *	ret
	)

Definition at line 162 of file propvar.c.

{
    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;
}

Referenced by test_PropVariantToDouble().

PropVariantToGUID()

HRESULT WINAPI PropVariantToGUID	(	const PROPVARIANT *	ppropvar,
		GUID *	guid
	)

Definition at line 756 of file propvar.c.

{
    TRACE("%p %p)\n", ppropvar, guid);
 
    switch(ppropvar->vt) {
    case VT_BSTR:
        return PROPVAR_WCHARToGUID(ppropvar->u.bstrVal, SysStringLen(ppropvar->u.bstrVal), guid);
    case VT_LPWSTR:
        return PROPVAR_WCHARToGUID(ppropvar->u.pwszVal, lstrlenW(ppropvar->u.pwszVal), guid);
    case VT_CLSID:
        memcpy(guid, ppropvar->u.puuid, sizeof(*ppropvar->u.puuid));
        return S_OK;
 
    default:
        FIXME("unsupported vt: %d\n", ppropvar->vt);
        return E_NOTIMPL;
    }
}

Referenced by test_PropVariantToGUID().

PropVariantToInt16()

HRESULT WINAPI PropVariantToInt16	(	REFPROPVARIANT	propvarIn,
		SHORT *	ret
	)

Definition at line 174 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
    if (SUCCEEDED(hr)) *ret = (SHORT)res;
    return hr;
}

Referenced by PropVariantChangeType(), and test_intconversions().

PropVariantToInt32()

HRESULT WINAPI PropVariantToInt32	(	REFPROPVARIANT	propvarIn,
		LONG *	ret
	)

Definition at line 186 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
    if (SUCCEEDED(hr)) *ret = (LONG)res;
    return hr;
}

Referenced by PropVariantChangeType(), and test_intconversions().

PropVariantToInt64()

HRESULT WINAPI PropVariantToInt64	(	REFPROPVARIANT	propvarIn,
		LONGLONG *	ret
	)

Definition at line 198 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
    if (SUCCEEDED(hr)) *ret = res;
    return hr;
}

Referenced by propvar_cmp(), PropVariantChangeType(), and test_intconversions().

PropVariantToString()

HRESULT WINAPI PropVariantToString	(	REFPROPVARIANT	propvarIn,
		PWSTR	ret,
		UINT	cch
	)

Definition at line 332 of file propvar.c.

{
    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;
}

Referenced by test_PropVariantToString().

PropVariantToStringAlloc()

HRESULT WINAPI PropVariantToStringAlloc	(	REFPROPVARIANT	propvarIn,
		WCHAR **	ret
	)

Definition at line 356 of file propvar.c.

{
    WCHAR *res = NULL;
    HRESULT hr = S_OK;
 
    TRACE("%p,%p semi-stub\n", propvarIn, ret);
 
    switch(propvarIn->vt)
    {
        case VT_EMPTY:
        case VT_NULL:
            res = CoTaskMemAlloc(1*sizeof(WCHAR));
            res[0] = '\0';
            break;
 
        case VT_LPSTR:
            if(propvarIn->u.pszVal)
            {
                DWORD len;
 
                len = MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, NULL, 0);
                res = CoTaskMemAlloc(len*sizeof(WCHAR));
                if(!res)
                    return E_OUTOFMEMORY;
 
                MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, res, len);
            }
            break;
 
        case VT_LPWSTR:
        case VT_BSTR:
            if (propvarIn->u.pwszVal)
            {
                DWORD size = (lstrlenW(propvarIn->u.pwszVal) + 1) * sizeof(WCHAR);
                res = CoTaskMemAlloc(size);
                if(!res) return E_OUTOFMEMORY;
                memcpy(res, propvarIn->u.pwszVal, size);
            }
            break;
 
        default:
            FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
            hr = E_FAIL;
            break;
    }
 
    *ret = res;
 
    return hr;
}

Referenced by PropVariantChangeType(), PropVariantToString(), and test_PropVariantToStringAlloc().

PropVariantToStringWithDefault()

PCWSTR WINAPI PropVariantToStringWithDefault	(	REFPROPVARIANT	propvarIn,
		LPCWSTR	pszDefault
	)

Definition at line 407 of file propvar.c.

{
    static const WCHAR str_empty[] = {0};
    if (propvarIn->vt == VT_BSTR)
    {
        if (propvarIn->u.bstrVal == NULL)
            return str_empty;
 
        return propvarIn->u.bstrVal;
    }
 
    if (propvarIn->vt == VT_LPWSTR && propvarIn->u.pwszVal != NULL)
        return propvarIn->u.pwszVal;
 
    return pszDefault;
}

Referenced by test_PropVariantToStringWithDefault().

PropVariantToUInt16()

HRESULT WINAPI PropVariantToUInt16	(	REFPROPVARIANT	propvarIn,
		USHORT *	ret
	)

Definition at line 210 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
    if (SUCCEEDED(hr)) *ret = (USHORT)res;
    return hr;
}

Referenced by PropVariantChangeType(), and test_intconversions().

PropVariantToUInt32()

HRESULT WINAPI PropVariantToUInt32	(	REFPROPVARIANT	propvarIn,
		ULONG *	ret
	)

Definition at line 222 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
    if (SUCCEEDED(hr)) *ret = (ULONG)res;
    return hr;
}

Referenced by PropVariantChangeType(), and test_intconversions().

PropVariantToUInt64()

HRESULT WINAPI PropVariantToUInt64	(	REFPROPVARIANT	propvarIn,
		ULONGLONG *	ret
	)

Definition at line 234 of file propvar.c.

{
    LONGLONG res;
    HRESULT hr;
 
    TRACE("%p,%p\n", propvarIn, ret);
 
    hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
    if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
    return hr;
}

Referenced by PropVariantChangeType(), and test_intconversions().

VariantToGUID()

HRESULT WINAPI VariantToGUID	(	const VARIANT *	pvar,
		GUID *	guid
	)

Definition at line 775 of file propvar.c.

{
    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;
    }
}

Referenced by test_PropVariantToGUID().