ReactOS 0.4.16-dev-889-g9563c07
propvar.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winreg.h"
#include "winuser.h"
#include "shlobj.h"
#include "propvarutil.h"
#include "strsafe.h"
#include "wine/debug.h"
Include dependency graph for propvar.c:

Go to the source code of this file.

Macros

#define GUID_STR_LEN   38
 
#define CMP_NUM_VALUE(var)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (propsys)
 
static HRESULT VARIANT_ValidateType (VARTYPE vt)
 
static HRESULT PROPVAR_ConvertFILETIME (const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
 
static HRESULT PROPVAR_ConvertNumber (REFPROPVARIANT pv, int dest_bits, BOOL dest_signed, LONGLONG *res)
 
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)
 
ULONG WINAPI PropVariantToUInt32WithDefault (REFPROPVARIANT propvarIn, ULONG ulDefault)
 
HRESULT WINAPI PropVariantToUInt64 (REFPROPVARIANT propvarIn, ULONGLONG *ret)
 
HRESULT WINAPI PropVariantToBoolean (REFPROPVARIANT propvarIn, BOOL *ret)
 
HRESULT WINAPI PropVariantToBSTR (REFPROPVARIANT propvar, BSTR *bstr)
 
HRESULT WINAPI PropVariantToBuffer (REFPROPVARIANT propvarIn, void *ret, UINT cb)
 
HRESULT WINAPI PropVariantToString (REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
 
HRESULT WINAPI PropVariantToStringAlloc (REFPROPVARIANT propvarIn, WCHAR **ret)
 
PCWSTR WINAPI PropVariantToStringWithDefault (REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
 
PCWSTR WINAPI VariantToStringWithDefault (const VARIANT *pvar, const WCHAR *default_value)
 
HRESULT WINAPI VariantToString (REFVARIANT var, PWSTR ret, UINT cch)
 
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 InitPropVariantFromStringVector (PCWSTR *strs, ULONG count, PROPVARIANT *ppropvar)
 
HRESULT WINAPI InitVariantFromBuffer (const VOID *pv, UINT cb, VARIANT *pvar)
 
HRESULT WINAPI InitVariantFromFileTime (const FILETIME *ft, VARIANT *var)
 
static DWORD PROPVAR_HexToNum (const WCHAR *hex)
 
static HRESULT PROPVAR_WCHARToGUID (const WCHAR *str, int len, GUID *guid)
 
HRESULT WINAPI PropVariantToGUID (const PROPVARIANT *ppropvar, GUID *guid)
 
HRESULT WINAPI VariantToGUID (const VARIANT *pvar, GUID *guid)
 
static BOOL isemptyornull (const PROPVARIANT *propvar)
 
INT WINAPI PropVariantCompareEx (REFPROPVARIANT propvar1, REFPROPVARIANT propvar2, PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
 
HRESULT WINAPI PropVariantToVariant (const PROPVARIANT *propvar, VARIANT *var)
 
HRESULT WINAPI VariantToPropVariant (const VARIANT *var, PROPVARIANT *propvar)
 

Macro Definition Documentation

◆ CMP_NUM_VALUE

#define CMP_NUM_VALUE (   var)
Value:
do { \
if (propvar1->var > propvar2_converted->var) \
res = 1; \
else if (propvar1->var < propvar2_converted->var) \
res = -1; \
else \
res = 0; \
} while (0)
GLuint res
Definition: glext.h:9613

◆ GUID_STR_LEN

#define GUID_STR_LEN   38

Definition at line 38 of file propvar.c.

Function Documentation

◆ InitPropVariantFromBuffer()

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

Definition at line 723 of file propvar.c.

724{
725 TRACE("(%p %u %p)\n", pv, cb, ppropvar);
726
727 ppropvar->caub.pElems = CoTaskMemAlloc(cb);
728 if(!ppropvar->caub.pElems)
729 return E_OUTOFMEMORY;
730
731 ppropvar->vt = VT_VECTOR|VT_UI1;
732 ppropvar->caub.cElems = cb;
733 memcpy(ppropvar->caub.pElems, pv, cb);
734 return S_OK;
735}
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
@ VT_VECTOR
Definition: compat.h:2340
@ VT_UI1
Definition: compat.h:2311
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
#define S_OK
Definition: intsafe.h:52
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by test_InitPropVariantFromBuffer(), and test_PropVariantToBuffer().

◆ InitPropVariantFromCLSID()

HRESULT WINAPI InitPropVariantFromCLSID ( REFCLSID  clsid,
PROPVARIANT *  ppropvar 
)

Definition at line 737 of file propvar.c.

738{
739 TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);
740
741 ppropvar->puuid = CoTaskMemAlloc(sizeof(*ppropvar->puuid));
742 if(!ppropvar->puuid)
743 return E_OUTOFMEMORY;
744
745 ppropvar->vt = VT_CLSID;
746 memcpy(ppropvar->puuid, clsid, sizeof(*ppropvar->puuid));
747 return S_OK;
748}
@ VT_CLSID
Definition: compat.h:2337
#define debugstr_guid
Definition: kernel32.h:35
REFCLSID clsid
Definition: msctf.c:82

Referenced by test_InitPropVariantFromCLSID(), and test_PropVariantToGUID().

◆ InitPropVariantFromGUIDAsString()

HRESULT WINAPI InitPropVariantFromGUIDAsString ( REFGUID  guid,
PROPVARIANT *  ppropvar 
)

Definition at line 689 of file propvar.c.

690{
691 TRACE("(%p %p)\n", guid, ppropvar);
692
693 if(!guid)
694 return E_FAIL;
695
696 ppropvar->vt = VT_LPWSTR;
697 ppropvar->pwszVal = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR));
698 if(!ppropvar->pwszVal)
699 return E_OUTOFMEMORY;
700
701 StringFromGUID2(guid, ppropvar->pwszVal, GUID_STR_LEN + 1);
702 return S_OK;
703}
#define E_FAIL
Definition: ddrawi.h:102
@ VT_LPWSTR
Definition: compat.h:2325
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
#define GUID_STR_LEN
Definition: propvar.c:38
const GUID * guid
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

◆ InitPropVariantFromStringVector()

HRESULT WINAPI InitPropVariantFromStringVector ( PCWSTR strs,
ULONG  count,
PROPVARIANT *  ppropvar 
)

Definition at line 750 of file propvar.c.

751{
752 unsigned int i;
753
754 TRACE("(%p %lu %p)\n", strs, count, ppropvar);
755
756 ppropvar->calpwstr.pElems = CoTaskMemAlloc(count * sizeof(*ppropvar->calpwstr.pElems));
757 if(!ppropvar->calpwstr.pElems)
758 return E_OUTOFMEMORY;
759
760 ppropvar->vt = VT_LPWSTR | VT_VECTOR;
761 ppropvar->calpwstr.cElems = 0;
762 if (count)
763 memset(ppropvar->calpwstr.pElems, 0, count * sizeof(*ppropvar->calpwstr.pElems));
764
765 for (i = 0; i < count; ++i)
766 {
767 if (strs[i])
768 {
769 if (!(ppropvar->calpwstr.pElems[i] = CoTaskMemAlloc((wcslen(strs[i]) + 1)*sizeof(**strs))))
770 {
771 PropVariantClear(ppropvar);
772 return E_OUTOFMEMORY;
773 }
774 }
775 wcscpy(ppropvar->calpwstr.pElems[i], strs[i]);
776 ppropvar->calpwstr.cElems++;
777 }
778
779 return S_OK;
780}
wcscpy
HRESULT WINAPI PropVariantClear(PROPVARIANT *pvar)
Definition: ole2.c:2968
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define memset(x, y, z)
Definition: compat.h:39

Referenced by test_InitPropVariantFromStringVector().

◆ InitVariantFromBuffer()

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

Definition at line 782 of file propvar.c.

783{
784 SAFEARRAY *arr;
785 void *data;
787
788 TRACE("(%p %u %p)\n", pv, cb, pvar);
789
791 if(!arr)
792 return E_OUTOFMEMORY;
793
795 if(FAILED(hres)) {
796 SafeArrayDestroy(arr);
797 return hres;
798 }
799
800 memcpy(data, pv, cb);
801
803 if(FAILED(hres)) {
804 SafeArrayDestroy(arr);
805 return hres;
806 }
807
808 V_VT(pvar) = VT_ARRAY|VT_UI1;
809 V_ARRAY(pvar) = arr;
810 return S_OK;
811}
@ VT_ARRAY
Definition: compat.h:2341
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
Definition: safearray.c:677
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define FAILED(hr)
Definition: intsafe.h:51
HRESULT hres
Definition: protocol.c:465
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_VT(A)
Definition: oleauto.h:211

◆ InitVariantFromFileTime()

HRESULT WINAPI InitVariantFromFileTime ( const FILETIME ft,
VARIANT var 
)

Definition at line 813 of file propvar.c.

814{
815 SYSTEMTIME st;
816
817 TRACE("%p, %p\n", ft, var);
818
820 if (!FileTimeToSystemTime(ft, &st))
821 return E_INVALIDARG;
823 return E_INVALIDARG;
824 V_VT(var) = VT_DATE;
825 return S_OK;
826}
#define E_INVALIDARG
Definition: ddrawi.h:101
@ VT_DATE
Definition: compat.h:2302
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
const char * var
Definition: shader.c:5666
#define V_DATE(A)
Definition: oleauto.h:231
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut)
Definition: variant.c:1286

Referenced by test_InitVariantFromFileTime().

◆ InitVariantFromGUIDAsString()

HRESULT WINAPI InitVariantFromGUIDAsString ( REFGUID  guid,
VARIANT pvar 
)

Definition at line 705 of file propvar.c.

706{
707 TRACE("(%p %p)\n", guid, pvar);
708
709 if(!guid) {
710 FIXME("guid == NULL\n");
711 return E_FAIL;
712 }
713
714 V_VT(pvar) = VT_BSTR;
716 if(!V_BSTR(pvar))
717 return E_OUTOFMEMORY;
718
720 return S_OK;
721}
#define FIXME(fmt,...)
Definition: precomp.h:53
#define NULL
Definition: types.h:112
@ VT_BSTR
Definition: compat.h:2303
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
#define V_BSTR(A)
Definition: oleauto.h:226

Referenced by test_InitPropVariantFromGUIDAsString(), and test_PropVariantToGUID().

◆ isemptyornull()

static BOOL isemptyornull ( const PROPVARIANT *  propvar)
static

Definition at line 937 of file propvar.c.

938{
939 if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
940 return TRUE;
941 if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
942 {
943 int i;
944 for (i=0; i<propvar->parray->cDims; i++)
945 {
946 if (propvar->parray->rgsabound[i].cElements != 0)
947 break;
948 }
949 return i == propvar->parray->cDims;
950 }
951 if (propvar->vt == VT_CLSID)
952 return !propvar->puuid;
953
954 if (propvar->vt & VT_VECTOR)
955 return !propvar->caub.cElems;
956
957 /* FIXME: byrefs, errors? */
958 return FALSE;
959}
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
@ VT_NULL
Definition: compat.h:2296
@ VT_EMPTY
Definition: compat.h:2295

Referenced by PropVariantCompareEx().

◆ PROPVAR_ConvertFILETIME()

static HRESULT PROPVAR_ConvertFILETIME ( const FILETIME ft,
PROPVARIANT *  ppropvarDest,
VARTYPE  vt 
)
static

Definition at line 59 of file propvar.c.

60{
62
64
65 switch (vt)
66 {
67 case VT_LPSTR:
68 ppropvarDest->pszVal = HeapAlloc(GetProcessHeap(), 0, 64);
69 if (!ppropvarDest->pszVal)
70 return E_OUTOFMEMORY;
71
72 sprintf( ppropvarDest->pszVal, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
73 time.wYear, time.wMonth, time.wDay,
74 time.wHour, time.wMinute, time.wSecond,
75 time.wMilliseconds );
76
77 return S_OK;
78
79 default:
80 FIXME("Unhandled target type: %d\n", vt);
81 }
82
83 return E_FAIL;
84}
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
@ VT_LPSTR
Definition: compat.h:2324
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
Definition: suminfo.c:91
__u16 time
Definition: mkdosfs.c:8
#define sprintf(buf, format,...)
Definition: sprintf.c:55

Referenced by PropVariantChangeType().

◆ PROPVAR_ConvertNumber()

static HRESULT PROPVAR_ConvertNumber ( REFPROPVARIANT  pv,
int  dest_bits,
BOOL  dest_signed,
LONGLONG res 
)
static

Definition at line 86 of file propvar.c.

88{
89 BOOL src_signed;
90
91 switch (pv->vt)
92 {
93 case VT_I1:
94 src_signed = TRUE;
95 *res = pv->cVal;
96 break;
97 case VT_UI1:
98 src_signed = FALSE;
99 *res = pv->bVal;
100 break;
101 case VT_I2:
102 src_signed = TRUE;
103 *res = pv->iVal;
104 break;
105 case VT_UI2:
106 src_signed = FALSE;
107 *res = pv->uiVal;
108 break;
109 case VT_I4:
110 src_signed = TRUE;
111 *res = pv->lVal;
112 break;
113 case VT_UI4:
114 src_signed = FALSE;
115 *res = pv->ulVal;
116 break;
117 case VT_I8:
118 src_signed = TRUE;
119 *res = pv->hVal.QuadPart;
120 break;
121 case VT_UI8:
122 src_signed = FALSE;
123 *res = pv->uhVal.QuadPart;
124 break;
125 case VT_EMPTY:
126 src_signed = FALSE;
127 *res = 0;
128 break;
129 case VT_LPSTR:
130 {
131 char *end;
132#ifdef __REACTOS__
133 *res = _strtoi64(pv->pszVal, &end, 0);
134#else
135 *res = strtoll(pv->pszVal, &end, 0);
136#endif
137 if (pv->pszVal == end)
138 return DISP_E_TYPEMISMATCH;
139 src_signed = *res < 0;
140 break;
141 }
142 case VT_LPWSTR:
143 case VT_BSTR:
144 {
145 WCHAR *end;
146 *res = wcstol(pv->pwszVal, &end, 0);
147 if (pv->pwszVal == end)
148 return DISP_E_TYPEMISMATCH;
149 src_signed = *res < 0;
150 break;
151 }
152 case VT_R8:
153 {
154 src_signed = TRUE;
155 *res = pv->dblVal;
156 break;
157 }
158 default:
159 FIXME("unhandled vt %d\n", pv->vt);
160 return E_NOTIMPL;
161 }
162
163 if (*res < 0 && src_signed != dest_signed)
165
166 if (dest_bits < 64)
167 {
168 if (dest_signed)
169 {
170 if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
171 *res < ((LONGLONG)-1 << (dest_bits-1)))
173 }
174 else
175 {
176 if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
178 }
179 }
180
181 return S_OK;
182}
#define E_NOTIMPL
Definition: ddrawi.h:99
@ VT_UI8
Definition: compat.h:2315
@ VT_UI2
Definition: compat.h:2312
@ VT_R8
Definition: compat.h:2300
@ VT_I8
Definition: compat.h:2314
@ VT_I1
Definition: compat.h:2310
@ VT_I4
Definition: compat.h:2298
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
unsigned int BOOL
Definition: ntddk_ex.h:94
GLuint GLuint end
Definition: gl.h:1545
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
__MINGW_EXTENSION long long __cdecl strtoll(const char *__restrict__, char **__restrict, int)
Definition: strtox.cpp:119
_Check_return_ _ACRTIMP __int64 __cdecl _strtoi64(_In_z_ char const *_String, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
int64_t LONGLONG
Definition: typedefs.h:68
uint64_t ULONGLONG
Definition: typedefs.h:67
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_ARITHMETIC_OVERFLOW
Definition: winerror.h:351
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514

Referenced by PropVariantChangeType(), PropVariantToBoolean(), PropVariantToDouble(), PropVariantToInt16(), PropVariantToInt32(), PropVariantToInt64(), PropVariantToUInt16(), PropVariantToUInt32(), PropVariantToUInt32WithDefault(), and PropVariantToUInt64().

◆ PROPVAR_HexToNum()

static DWORD PROPVAR_HexToNum ( const WCHAR hex)
inlinestatic

Definition at line 828 of file propvar.c.

829{
830 DWORD ret;
831
832 if(hex[0]>='0' && hex[0]<='9')
833 ret = hex[0]-'0';
834 else if(hex[0]>='a' && hex[0]<='f')
835 ret = hex[0]-'a'+10;
836 else if(hex[0]>='A' && hex[0]<='F')
837 ret = hex[0]-'A'+10;
838 else
839 return -1;
840
841 ret <<= 4;
842 if(hex[1]>='0' && hex[1]<='9')
843 return ret + hex[1]-'0';
844 else if(hex[1]>='a' && hex[1]<='f')
845 return ret + hex[1]-'a'+10;
846 else if(hex[1]>='A' && hex[1]<='F')
847 return ret + hex[1]-'A'+10;
848 else
849 return -1;
850}
unsigned long DWORD
Definition: ntddk_ex.h:95
int hex(char ch)
int ret

Referenced by PROPVAR_WCHARToGUID().

◆ PROPVAR_WCHARToGUID()

static HRESULT PROPVAR_WCHARToGUID ( const WCHAR str,
int  len,
GUID guid 
)
inlinestatic

Definition at line 852 of file propvar.c.

853{
854 DWORD i, val=0;
855 const WCHAR *p;
856
857 memset(guid, 0, sizeof(GUID));
858
859 if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
860 || str[19]!='-' || str[24]!='-' || str[37]!='}') {
861 WARN("Error parsing %s\n", debugstr_w(str));
862 return E_INVALIDARG;
863 }
864
865 p = str+1;
866 for(i=0; i<4 && val!=-1; i++) {
868 guid->Data1 = (guid->Data1<<8) + val;
869 p += 2;
870 }
871 p++;
872 for(i=0; i<2 && val!=-1; i++) {
874 guid->Data2 = (guid->Data2<<8) + val;
875 p += 2;
876 }
877 p++;
878 for(i=0; i<2 && val!=-1; i++) {
880 guid->Data3 = (guid->Data3<<8) + val;
881 p += 2;
882 }
883 p++;
884 for(i=0; i<8 && val!=-1; i++) {
885 if(i == 2)
886 p++;
887
888 val = guid->Data4[i] = PROPVAR_HexToNum(p);
889 p += 2;
890 }
891
892 if(val == -1) {
893 WARN("Error parsing %s\n", debugstr_w(str));
894 memset(guid, 0, sizeof(GUID));
895 return E_INVALIDARG;
896 }
897 return S_OK;
898}
#define WARN(fmt,...)
Definition: precomp.h:61
static DWORD PROPVAR_HexToNum(const WCHAR *hex)
Definition: propvar.c:828
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
#define debugstr_w
Definition: kernel32.h:32
const WCHAR * str

Referenced by PropVariantToGUID(), and VariantToGUID().

◆ PropVariantChangeType()

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

Definition at line 537 of file propvar.c.

539{
540 HRESULT hr;
541
542 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
543 propvarSrc->vt, flags, vt);
544
545 if (vt == propvarSrc->vt)
546 return PropVariantCopy(ppropvarDest, propvarSrc);
547
548 if (propvarSrc->vt == VT_FILETIME)
549 return PROPVAR_ConvertFILETIME(&propvarSrc->filetime, ppropvarDest, vt);
550
551 switch (vt)
552 {
553 case VT_I1:
554 {
556
558 if (SUCCEEDED(hr))
559 {
560 ppropvarDest->vt = VT_I1;
561 ppropvarDest->cVal = (char)res;
562 }
563 return hr;
564 }
565
566 case VT_UI1:
567 {
569
571 if (SUCCEEDED(hr))
572 {
573 ppropvarDest->vt = VT_UI1;
574 ppropvarDest->bVal = (UCHAR)res;
575 }
576 return hr;
577 }
578
579 case VT_I2:
580 {
581 SHORT res;
583 if (SUCCEEDED(hr))
584 {
585 ppropvarDest->vt = VT_I2;
586 ppropvarDest->iVal = res;
587 }
588 return hr;
589 }
590 case VT_UI2:
591 {
592 USHORT res;
594 if (SUCCEEDED(hr))
595 {
596 ppropvarDest->vt = VT_UI2;
597 ppropvarDest->uiVal = res;
598 }
599 return hr;
600 }
601 case VT_I4:
602 {
603 LONG res;
605 if (SUCCEEDED(hr))
606 {
607 ppropvarDest->vt = VT_I4;
608 ppropvarDest->lVal = res;
609 }
610 return hr;
611 }
612 case VT_UI4:
613 {
614 ULONG res;
616 if (SUCCEEDED(hr))
617 {
618 ppropvarDest->vt = VT_UI4;
619 ppropvarDest->ulVal = res;
620 }
621 return hr;
622 }
623 case VT_I8:
624 {
627 if (SUCCEEDED(hr))
628 {
629 ppropvarDest->vt = VT_I8;
630 ppropvarDest->hVal.QuadPart = res;
631 }
632 return hr;
633 }
634 case VT_UI8:
635 {
638 if (SUCCEEDED(hr))
639 {
640 ppropvarDest->vt = VT_UI8;
641 ppropvarDest->uhVal.QuadPart = res;
642 }
643 return hr;
644 }
645
646 case VT_LPWSTR:
647 case VT_BSTR:
648 {
649 WCHAR *res;
651 if (SUCCEEDED(hr))
652 {
653 ppropvarDest->vt = VT_LPWSTR;
654 ppropvarDest->pwszVal = res;
655 }
656 return hr;
657 }
658
659 case VT_LPSTR:
660 {
661 WCHAR *resW;
663 if (SUCCEEDED(hr))
664 {
665 char *res;
666 DWORD len;
667
668 len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
670 if (res)
671 {
672 WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
673 ppropvarDest->vt = VT_LPSTR;
674 ppropvarDest->pszVal = res;
675 }
676 else
678
679 CoTaskMemFree(resW);
680 }
681 return hr;
682 }
683
684 default:
685 FIXME("Unhandled dest type: %d\n", vt);
686 return E_FAIL;
687 }
688}
#define CP_ACP
Definition: compat.h:109
#define WideCharToMultiByte
Definition: compat.h:111
@ VT_FILETIME
Definition: compat.h:2329
static REFPROPVARIANT propvarSrc
Definition: suminfo.c:90
HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest, const PROPVARIANT *pvarSrc)
Definition: ole2.c:3086
HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
Definition: propvar.c:208
static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
Definition: propvar.c:59
HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
Definition: propvar.c:232
HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
Definition: propvar.c:407
static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits, BOOL dest_signed, LONGLONG *res)
Definition: propvar.c:86
HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
Definition: propvar.c:220
HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
Definition: propvar.c:270
HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
Definition: propvar.c:244
HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
Definition: propvar.c:196
unsigned char
Definition: typeof.h:29
GLbitfield flags
Definition: glext.h:7161
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define SUCCEEDED(hr)
Definition: intsafe.h:50
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
HRESULT hr
Definition: shlfolder.c:183
uint32_t ULONG
Definition: typedefs.h:59
unsigned char UCHAR
Definition: xmlstorage.h:181

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

◆ PropVariantCompareEx()

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

Definition at line 961 of file propvar.c.

963{
964 const PROPVARIANT *propvar2_converted;
965 PROPVARIANT propvar2_static;
966 unsigned int count;
967 HRESULT hr;
968 INT res=-1;
969
970 TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);
971
972 if (isemptyornull(propvar1))
973 {
975 return 0;
976 return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
977 }
978
980 return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;
981
982 if (propvar1->vt != propvar2->vt)
983 {
984 hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);
985
986 if (FAILED(hr))
987 return -1;
988
989 propvar2_converted = &propvar2_static;
990 }
991 else
992 propvar2_converted = propvar2;
993
994#define CMP_NUM_VALUE(var) do { \
995 if (propvar1->var > propvar2_converted->var) \
996 res = 1; \
997 else if (propvar1->var < propvar2_converted->var) \
998 res = -1; \
999 else \
1000 res = 0; \
1001 } while (0)
1002
1003 switch (propvar1->vt)
1004 {
1005 case VT_I1:
1006 CMP_NUM_VALUE(cVal);
1007 break;
1008 case VT_UI1:
1009 CMP_NUM_VALUE(bVal);
1010 break;
1011 case VT_I2:
1012 CMP_NUM_VALUE(iVal);
1013 break;
1014 case VT_UI2:
1015 CMP_NUM_VALUE(uiVal);
1016 break;
1017 case VT_I4:
1018 CMP_NUM_VALUE(lVal);
1019 break;
1020 case VT_UI4:
1021 CMP_NUM_VALUE(ulVal);
1022 break;
1023 case VT_I8:
1024 CMP_NUM_VALUE(hVal.QuadPart);
1025 break;
1026 case VT_UI8:
1027 CMP_NUM_VALUE(uhVal.QuadPart);
1028 break;
1029 case VT_R4:
1030 CMP_NUM_VALUE(fltVal);
1031 break;
1032 case VT_R8:
1033 CMP_NUM_VALUE(dblVal);
1034 break;
1035 case VT_BSTR:
1036 case VT_LPWSTR:
1037 /* FIXME: Use other string flags. */
1039 res = lstrcmpiW(propvar1->bstrVal, propvar2_converted->bstrVal);
1040 else
1041 res = lstrcmpW(propvar1->bstrVal, propvar2_converted->bstrVal);
1042 break;
1043 case VT_LPSTR:
1044 /* FIXME: Use other string flags. */
1046 res = lstrcmpiA(propvar1->pszVal, propvar2_converted->pszVal);
1047 else
1048 res = lstrcmpA(propvar1->pszVal, propvar2_converted->pszVal);
1049 break;
1050 case VT_CLSID:
1051 res = memcmp(propvar1->puuid, propvar2->puuid, sizeof(*propvar1->puuid));
1052 if (res) res = res > 0 ? 1 : -1;
1053 break;
1054 case VT_VECTOR | VT_UI1:
1055 count = min(propvar1->caub.cElems, propvar2->caub.cElems);
1056 res = count ? memcmp(propvar1->caub.pElems, propvar2->caub.pElems, sizeof(*propvar1->caub.pElems) * count) : 0;
1057 if (res) res = res > 0 ? 1 : -1;
1058 if (!res && propvar1->caub.cElems != propvar2->caub.cElems)
1059 res = propvar1->caub.cElems > propvar2->caub.cElems ? 1 : -1;
1060 break;
1061 default:
1062 FIXME("vartype %#x not handled\n", propvar1->vt);
1063 res = -1;
1064 break;
1065 }
1066
1067 if (propvar2_converted == &propvar2_static)
1068 PropVariantClear(&propvar2_static);
1069
1070 return res;
1071}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
@ VT_R4
Definition: compat.h:2299
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4195
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4262
int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4224
#define CMP_NUM_VALUE(var)
static BOOL isemptyornull(const PROPVARIANT *propvar)
Definition: propvar.c:937
HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
Definition: propvar.c:537
#define min(a, b)
Definition: monoChain.cc:55
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
@ PVCF_USESTRCMPI
Definition: propvarutil.h:70
@ PVCF_USESTRCMPIC
Definition: propvarutil.h:71
@ PVCF_TREATEMPTYASGREATERTHAN
Definition: propvarutil.h:67
REFPROPVARIANT propvar2
Definition: propvarutil.h:86
int32_t INT
Definition: typedefs.h:58

Referenced by MetadataHandler_GetValue(), and test_PropVariantCompareEx().

◆ PropVariantToBoolean()

HRESULT WINAPI PropVariantToBoolean ( REFPROPVARIANT  propvarIn,
BOOL ret 
)

Definition at line 282 of file propvar.c.

283{
285 HRESULT hr;
286
287 TRACE("%p,%p\n", propvarIn, ret);
288
289 *ret = FALSE;
290
291 switch (propvarIn->vt)
292 {
293 case VT_BOOL:
294 *ret = propvarIn->boolVal == VARIANT_TRUE;
295 return S_OK;
296
297 case VT_LPWSTR:
298 case VT_BSTR:
299 if (!propvarIn->pwszVal)
300 return DISP_E_TYPEMISMATCH;
301
302 if (!lstrcmpiW(propvarIn->pwszVal, L"true") || !lstrcmpW(propvarIn->pwszVal, L"#TRUE#"))
303 {
304 *ret = TRUE;
305 return S_OK;
306 }
307
308 if (!lstrcmpiW(propvarIn->pwszVal, L"false") || !lstrcmpW(propvarIn->pwszVal, L"#FALSE#"))
309 {
310 *ret = FALSE;
311 return S_OK;
312 }
313 break;
314
315 case VT_LPSTR:
316 if (!propvarIn->pszVal)
317 return DISP_E_TYPEMISMATCH;
318
319 if (!lstrcmpiA(propvarIn->pszVal, "true") || !lstrcmpA(propvarIn->pszVal, "#TRUE#"))
320 {
321 *ret = TRUE;
322 return S_OK;
323 }
324
325 if (!lstrcmpiA(propvarIn->pszVal, "false") || !lstrcmpA(propvarIn->pszVal, "#FALSE#"))
326 {
327 *ret = FALSE;
328 return S_OK;
329 }
330 break;
331 }
332
333 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
334 *ret = !!res;
335 return hr;
336}
@ VT_BOOL
Definition: compat.h:2306
#define L(x)
Definition: ntvdm.h:50

Referenced by test_PropVariantToBoolean().

◆ PropVariantToBSTR()

HRESULT WINAPI PropVariantToBSTR ( REFPROPVARIANT  propvar,
BSTR bstr 
)

Definition at line 338 of file propvar.c.

339{
340 WCHAR *str;
341 HRESULT hr;
342
343 TRACE("propvar %p, propvar->vt %#x, bstr %p.\n",
344 propvar, propvar ? propvar->vt : 0, bstr);
345
346 if (FAILED(hr = PropVariantToStringAlloc(propvar, &str)))
347 return hr;
348
349 *bstr = SysAllocString(str);
351
352 if (!*bstr)
353 return E_OUTOFMEMORY;
354
355 return S_OK;
356}
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238

Referenced by PropVariantToVariant(), and test_PropVariantToBSTR().

◆ PropVariantToBuffer()

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

Definition at line 358 of file propvar.c.

359{
360 HRESULT hr = S_OK;
361
362 TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);
363
364 switch(propvarIn->vt)
365 {
366 case VT_VECTOR|VT_UI1:
367 if(cb > propvarIn->caub.cElems)
368 return E_FAIL;
369 memcpy(ret, propvarIn->caub.pElems, cb);
370 break;
371 case VT_ARRAY|VT_UI1:
372 FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
373 hr = E_NOTIMPL;
374 break;
375 default:
376 WARN("Unexpected type: %x\n", propvarIn->vt);
378 }
379
380 return hr;
381}

Referenced by test_PropVariantToBuffer().

◆ PropVariantToDouble()

HRESULT WINAPI PropVariantToDouble ( REFPROPVARIANT  propvarIn,
double ret 
)

Definition at line 184 of file propvar.c.

185{
187 HRESULT hr;
188
189 TRACE("(%p, %p)\n", propvarIn, ret);
190
191 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
192 if (SUCCEEDED(hr)) *ret = (double)res;
193 return hr;
194}
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:89

Referenced by test_PropVariantToDouble().

◆ PropVariantToGUID()

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

Definition at line 900 of file propvar.c.

901{
902 TRACE("%p %p)\n", ppropvar, guid);
903
904 switch(ppropvar->vt) {
905 case VT_BSTR:
906 return PROPVAR_WCHARToGUID(ppropvar->bstrVal, SysStringLen(ppropvar->bstrVal), guid);
907 case VT_LPWSTR:
908 return PROPVAR_WCHARToGUID(ppropvar->pwszVal, lstrlenW(ppropvar->pwszVal), guid);
909 case VT_CLSID:
910 memcpy(guid, ppropvar->puuid, sizeof(*ppropvar->puuid));
911 return S_OK;
912
913 default:
914 FIXME("unsupported vt: %d\n", ppropvar->vt);
915 return E_NOTIMPL;
916 }
917}
#define lstrlenW
Definition: compat.h:750
static HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
Definition: propvar.c:852
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196

Referenced by test_PropVariantToGUID().

◆ PropVariantToInt16()

HRESULT WINAPI PropVariantToInt16 ( REFPROPVARIANT  propvarIn,
SHORT ret 
)

Definition at line 196 of file propvar.c.

197{
199 HRESULT hr;
200
201 TRACE("%p,%p\n", propvarIn, ret);
202
203 hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
204 if (SUCCEEDED(hr)) *ret = (SHORT)res;
205 return hr;
206}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToInt32()

HRESULT WINAPI PropVariantToInt32 ( REFPROPVARIANT  propvarIn,
LONG ret 
)

Definition at line 208 of file propvar.c.

209{
211 HRESULT hr;
212
213 TRACE("%p,%p\n", propvarIn, ret);
214
215 hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
216 if (SUCCEEDED(hr)) *ret = (LONG)res;
217 return hr;
218}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToInt64()

HRESULT WINAPI PropVariantToInt64 ( REFPROPVARIANT  propvarIn,
LONGLONG ret 
)

Definition at line 220 of file propvar.c.

221{
223 HRESULT hr;
224
225 TRACE("%p,%p\n", propvarIn, ret);
226
227 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
228 if (SUCCEEDED(hr)) *ret = res;
229 return hr;
230}

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

◆ PropVariantToString()

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

Definition at line 383 of file propvar.c.

384{
385 HRESULT hr;
386 WCHAR *stringW = NULL;
387
388 TRACE("(%p, %p, %d)\n", propvarIn, ret, cch);
389
390 ret[0] = '\0';
391
392 if(!cch)
393 return E_INVALIDARG;
394
395 hr = PropVariantToStringAlloc(propvarIn, &stringW);
396 if(SUCCEEDED(hr))
397 {
398 if(lstrlenW(stringW) >= cch)
402 }
403
404 return hr;
405}
#define lstrcpynW
Definition: compat.h:738
static const WCHAR stringW[]
Definition: engine.c:38
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
#define STRSAFE_E_INSUFFICIENT_BUFFER
Definition: strsafe.h:103

Referenced by test_PropVariantToString().

◆ PropVariantToStringAlloc()

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

Definition at line 407 of file propvar.c.

408{
409 WCHAR *res = NULL;
410 HRESULT hr = S_OK;
411
412 TRACE("%p,%p semi-stub\n", propvarIn, ret);
413
414 switch(propvarIn->vt)
415 {
416 case VT_EMPTY:
417 case VT_NULL:
418 res = CoTaskMemAlloc(1*sizeof(WCHAR));
419 res[0] = '\0';
420 break;
421
422 case VT_LPSTR:
423 if(propvarIn->pszVal)
424 {
425 DWORD len;
426
427 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, NULL, 0);
428 res = CoTaskMemAlloc(len*sizeof(WCHAR));
429 if(!res)
430 return E_OUTOFMEMORY;
431
432 MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, res, len);
433 }
434 break;
435
436 case VT_LPWSTR:
437 case VT_BSTR:
438 if (propvarIn->pwszVal)
439 {
440 DWORD size = (lstrlenW(propvarIn->pwszVal) + 1) * sizeof(WCHAR);
442 if(!res) return E_OUTOFMEMORY;
443 memcpy(res, propvarIn->pwszVal, size);
444 }
445 break;
446
447 case VT_CLSID:
448 if (propvarIn->puuid)
449 {
450 if (!(res = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR))))
451 return E_OUTOFMEMORY;
452 StringFromGUID2(propvarIn->puuid, res, GUID_STR_LEN + 1);
453 }
454 break;
455
456 default:
457 FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
458 hr = E_FAIL;
459 break;
460 }
461
462 *ret = res;
463
464 return hr;
465}
#define MultiByteToWideChar
Definition: compat.h:110
GLsizeiptr size
Definition: glext.h:5919

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

◆ PropVariantToStringWithDefault()

PCWSTR WINAPI PropVariantToStringWithDefault ( REFPROPVARIANT  propvarIn,
LPCWSTR  pszDefault 
)

Definition at line 467 of file propvar.c.

468{
469 if (propvarIn->vt == VT_BSTR)
470 {
471 if (propvarIn->bstrVal == NULL)
472 return L"";
473
474 return propvarIn->bstrVal;
475 }
476
477 if (propvarIn->vt == VT_LPWSTR && propvarIn->pwszVal != NULL)
478 return propvarIn->pwszVal;
479
480 return pszDefault;
481}
LPCWSTR pszDefault
Definition: propvarutil.h:103

Referenced by test_PropVariantToStringWithDefault().

◆ PropVariantToUInt16()

HRESULT WINAPI PropVariantToUInt16 ( REFPROPVARIANT  propvarIn,
USHORT ret 
)

Definition at line 232 of file propvar.c.

233{
235 HRESULT hr;
236
237 TRACE("%p,%p\n", propvarIn, ret);
238
239 hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
240 if (SUCCEEDED(hr)) *ret = (USHORT)res;
241 return hr;
242}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToUInt32()

HRESULT WINAPI PropVariantToUInt32 ( REFPROPVARIANT  propvarIn,
ULONG ret 
)

Definition at line 244 of file propvar.c.

245{
247 HRESULT hr;
248
249 TRACE("%p,%p\n", propvarIn, ret);
250
251 hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
252 if (SUCCEEDED(hr)) *ret = (ULONG)res;
253 return hr;
254}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToUInt32WithDefault()

ULONG WINAPI PropVariantToUInt32WithDefault ( REFPROPVARIANT  propvarIn,
ULONG  ulDefault 
)

Definition at line 256 of file propvar.c.

257{
259 HRESULT hr;
260
261 TRACE("%p,%lu\n", propvarIn, ulDefault);
262
263 hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
264 if (SUCCEEDED(hr))
265 return (ULONG)res;
266
267 return ulDefault;
268}

Referenced by test_intconversions().

◆ PropVariantToUInt64()

HRESULT WINAPI PropVariantToUInt64 ( REFPROPVARIANT  propvarIn,
ULONGLONG ret 
)

Definition at line 270 of file propvar.c.

271{
273 HRESULT hr;
274
275 TRACE("%p,%p\n", propvarIn, ret);
276
277 hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
278 if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
279 return hr;
280}

Referenced by PropVariantChangeType(), and test_intconversions().

◆ PropVariantToVariant()

HRESULT WINAPI PropVariantToVariant ( const PROPVARIANT *  propvar,
VARIANT var 
)

Definition at line 1073 of file propvar.c.

1074{
1075 HRESULT hr = S_OK;
1076
1077 TRACE("propvar %p, var %p, propvar->vt %#x.\n", propvar, var, propvar ? propvar->vt : 0);
1078
1079 if (!var || !propvar)
1080 return E_INVALIDARG;
1081
1083#ifdef __REACTOS__
1084 V_VT(var) = propvar->vt;
1085#else
1086 var->vt = propvar->vt;
1087#endif
1088
1089 switch (propvar->vt)
1090 {
1091 case VT_EMPTY:
1092 case VT_NULL:
1093 break;
1094 case VT_I1:
1095 V_I1(var) = propvar->cVal;
1096 break;
1097 case VT_I2:
1098 V_I2(var) = propvar->iVal;
1099 break;
1100 case VT_I4:
1101 V_I4(var) = propvar->lVal;
1102 break;
1103 case VT_I8:
1104 V_I8(var) = propvar->hVal.QuadPart;
1105 break;
1106 case VT_UI1:
1107 V_UI1(var) = propvar->bVal;
1108 break;
1109 case VT_UI2:
1110 V_UI2(var) = propvar->uiVal;
1111 break;
1112 case VT_UI4:
1113 V_UI4(var) = propvar->ulVal;
1114 break;
1115 case VT_UI8:
1116 V_UI8(var) = propvar->uhVal.QuadPart;
1117 break;
1118 case VT_BOOL:
1119 V_BOOL(var) = propvar->boolVal;
1120 break;
1121 case VT_R4:
1122 V_R4(var) = propvar->fltVal;
1123 break;
1124 case VT_R8:
1125 V_R8(var) = propvar->dblVal;
1126 break;
1127 case VT_LPSTR:
1128 case VT_LPWSTR:
1129 case VT_BSTR:
1130 case VT_CLSID:
1131#ifdef __REACTOS__
1132 V_VT(var) = VT_BSTR;
1133#else
1134 var->vt = VT_BSTR;
1135#endif
1136 hr = PropVariantToBSTR(propvar, &V_BSTR(var));
1137 break;
1138 default:
1139 FIXME("Unsupported type %d.\n", propvar->vt);
1140 return E_INVALIDARG;
1141 }
1142
1143 return hr;
1144}
HRESULT WINAPI PropVariantToBSTR(REFPROPVARIANT propvar, BSTR *bstr)
Definition: propvar.c:338
#define V_UI1(A)
Definition: oleauto.h:266
#define V_I8(A)
Definition: oleauto.h:249
#define V_BOOL(A)
Definition: oleauto.h:224
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
#define V_I4(A)
Definition: oleauto.h:247
#define V_R4(A)
Definition: oleauto.h:260
#define V_UI4(A)
Definition: oleauto.h:270
#define V_R8(A)
Definition: oleauto.h:262
#define V_UI8(A)
Definition: oleauto.h:272
#define V_I2(A)
Definition: oleauto.h:245

Referenced by test_PropVariantToVariant().

◆ VARIANT_ValidateType()

static HRESULT VARIANT_ValidateType ( VARTYPE  vt)
static

Definition at line 39 of file propvar.c.

40{
41 VARTYPE vtExtra = vt & (VT_VECTOR | VT_ARRAY | VT_BYREF | VT_RESERVED);
42
43 vt &= VT_TYPEMASK;
44
45 if (!(vtExtra & (VT_VECTOR | VT_RESERVED)))
46 {
47 if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID)
48 {
49 if ((vtExtra & (VT_BYREF | VT_ARRAY)) && vt <= VT_NULL)
50 return DISP_E_BADVARTYPE;
51 if (vt != (VARTYPE)15)
52 return S_OK;
53 }
54 }
55
56 return DISP_E_BADVARTYPE;
57}
unsigned short VARTYPE
Definition: compat.h:2254
@ VT_VOID
Definition: compat.h:2318
@ VT_TYPEMASK
Definition: compat.h:2346
@ VT_RESERVED
Definition: compat.h:2343
@ VT_BYREF
Definition: compat.h:2342
@ VT_RECORD
Definition: compat.h:2326
#define DISP_E_BADVARTYPE
Definition: winerror.h:2517

Referenced by VariantToPropVariant().

◆ VariantToGUID()

HRESULT WINAPI VariantToGUID ( const VARIANT pvar,
GUID guid 
)

Definition at line 919 of file propvar.c.

920{
921 TRACE("(%p %p)\n", pvar, guid);
922
923 switch(V_VT(pvar)) {
924 case VT_BSTR: {
926 if(hres == E_INVALIDARG)
927 return E_FAIL;
928 return hres;
929 }
930
931 default:
932 FIXME("unsupported vt: %d\n", V_VT(pvar));
933 return E_NOTIMPL;
934 }
935}

Referenced by test_PropVariantToGUID().

◆ VariantToPropVariant()

HRESULT WINAPI VariantToPropVariant ( const VARIANT var,
PROPVARIANT *  propvar 
)

Definition at line 1146 of file propvar.c.

1147{
1148 HRESULT hr;
1149
1150 TRACE("var %p, propvar %p.\n", debugstr_variant(var), propvar);
1151
1152 if (!var || !propvar)
1153 return E_INVALIDARG;
1154
1155#ifdef __REACTOS__
1157#else
1158 if (FAILED(hr = VARIANT_ValidateType(var->vt)))
1159#endif
1160 return hr;
1161
1162 PropVariantInit(propvar);
1163
1164
1165#ifdef __REACTOS__
1166 propvar->vt = V_VT(var);
1167#else
1168 propvar->vt = var->vt;
1169#endif
1170
1171#ifdef __REACTOS__
1172 switch (V_VT(var))
1173#else
1174 switch (var->vt)
1175#endif
1176 {
1177 case VT_EMPTY:
1178 case VT_NULL:
1179 break;
1180 case VT_I1:
1181 propvar->cVal = V_I1(var);
1182 break;
1183 case VT_I2:
1184 propvar->iVal = V_I2(var);
1185 break;
1186 case VT_I4:
1187 propvar->lVal = V_I4(var);
1188 break;
1189 case VT_I8:
1190 propvar->hVal.QuadPart = V_I8(var);
1191 break;
1192 case VT_UI1:
1193 propvar->bVal = V_UI1(var);
1194 break;
1195 case VT_UI2:
1196 propvar->uiVal = V_UI2(var);
1197 break;
1198 case VT_UI4:
1199 propvar->ulVal = V_UI4(var);
1200 break;
1201 case VT_UI8:
1202 propvar->uhVal.QuadPart = V_UI8(var);
1203 break;
1204 case VT_BOOL:
1205 propvar->boolVal = V_BOOL(var);
1206 break;
1207 case VT_R4:
1208 propvar->fltVal = V_R4(var);
1209 break;
1210 case VT_R8:
1211 propvar->dblVal = V_R8(var);
1212 break;
1213 case VT_BSTR:
1214 propvar->bstrVal = SysAllocString(V_BSTR(var));
1215 break;
1216 default:
1217#ifdef __REACTOS__
1218 FIXME("Unsupported type %d.\n", V_VT(var));
1219#else
1220 FIXME("Unsupported type %d.\n", var->vt);
1221#endif
1222 return E_INVALIDARG;
1223 }
1224
1225 return S_OK;
1226}
static HRESULT VARIANT_ValidateType(VARTYPE vt)
Definition: propvar.c:39
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46

Referenced by test_VariantToPropVariant().

◆ VariantToString()

HRESULT WINAPI VariantToString ( REFVARIANT  var,
PWSTR  ret,
UINT  cch 
)

Definition at line 503 of file propvar.c.

504{
505 WCHAR buffer[64], *str = buffer;
506
507 TRACE("%p, %p, %u.\n", var, ret, cch);
508
509 *ret = 0;
510
511 if (!cch)
512 return E_INVALIDARG;
513
514 switch (V_VT(var))
515 {
516 case VT_BSTR:
517 str = V_BSTR(var);
518 break;
519 case VT_I4:
521 break;
522 default:
523 FIXME("Unsupported type %d.\n", V_VT(var));
524 return E_NOTIMPL;
525 }
526
527 if (wcslen(str) > cch - 1)
529 wcscpy(ret, str);
530
531 return S_OK;
532}
#define ARRAY_SIZE(A)
Definition: main.h:20
#define swprintf
Definition: precomp.h:40
GLuint buffer
Definition: glext.h:5915

Referenced by anonymous_namespace{mstscax.cpp}::CAdvancedSettings::IMsRdpClientAdvancedSettings::put_ConnectWithEndpoint(), anonymous_namespace{mstscax.cpp}::CoClass::Invoke(), and test_VariantToString().

◆ VariantToStringWithDefault()

PCWSTR WINAPI VariantToStringWithDefault ( const VARIANT pvar,
const WCHAR default_value 
)

Definition at line 486 of file propvar.c.

487{
488 TRACE("%s, %s.\n", debugstr_variant(pvar), debugstr_w(default_value));
489
490 if (V_VT(pvar) == (VT_BYREF | VT_VARIANT)) pvar = V_VARIANTREF(pvar);
491 if (V_VT(pvar) == (VT_BYREF | VT_BSTR) || V_VT(pvar) == VT_BSTR)
492 {
493 BSTR ret = V_ISBYREF(pvar) ? *V_BSTRREF(pvar) : V_BSTR(pvar);
494 return ret ? ret : L"";
495 }
496
497 return default_value;
498}
OLECHAR * BSTR
Definition: compat.h:2293
@ VT_VARIANT
Definition: compat.h:2307
#define V_BSTRREF(A)
Definition: oleauto.h:227
#define V_ISBYREF(A)
Definition: oleauto.h:217
#define V_VARIANTREF(A)
Definition: oleauto.h:283

Referenced by test_VariantToStringWithDefault().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( propsys  )