static void test_change_type(IVariantChangeType *change_type, VARIANT *src, const conv_results_t *ex)
{
VARIANT v;
call_change_type(change_type, &v, src, VT_I4);
ok(V_I4(&v) == ex->int_result, "V_I4(v) = %d, expected %d\n", V_I4(&v), ex->int_result);
call_change_type(change_type, &v, src, VT_BSTR);
ok(!strcmp_wa(V_BSTR(&v), ex->str_result), "V_BSTR(v) = %s, expected %s\n", wine_dbgstr_w(V_BSTR(&v)), ex->str_result);
VariantClear(&v);
call_change_type(change_type, &v, src, VT_BOOL);
ok(V_BOOL(&v) == ex->bool_result, "V_BOOL(v) = %x, expected %x\n", V_BOOL(&v), ex->bool_result);
if(ex->test_double) {
call_change_type(change_type, &v, src, VT_R8);
ok(V_R8(&v) == ex->double_result, "V_R8(v) = %lf, expected %lf\n", V_R8(&v), ex->double_result);
call_change_type(change_type, &v, src, VT_R4);
ok(V_R4(&v) == (float)ex->double_result, "V_R4(v) = %f, expected %f\n", V_R4(&v), (float)ex->double_result);
}
if(V_VT(src) == VT_NULL)
call_change_type(change_type, &v, src, VT_NULL);
else
change_type_fail(change_type, src, VT_NULL, E_NOTIMPL);
if(V_VT(src) == VT_EMPTY)
call_change_type(change_type, &v, src, VT_EMPTY);
else
change_type_fail(change_type, src, VT_EMPTY, E_NOTIMPL);
call_change_type(change_type, &v, src, VT_I2);
ok(V_I2(&v) == (INT16)ex->int_result, "V_I2(v) = %d, expected %d\n", V_I2(&v), ex->int_result);
}
///////////////////////////////////////////////////////////////////////////////
//
// CInclinometer::OnDataUpdated
//
// Description of function/method:
// Helper function, get data from a sensor and updates the lux
//
// Parameters:
// ISensor *pSensor: Input sensor
// ISensorDataReport* pDataReport: The data to be read
// void* pData: pointer to return the data to
//
// Return Values:
// S_OK on success, else an error
//
///////////////////////////////////////////////////////////////////////////////
HRESULT CInclinometer::OnDataUpdated(ISensor *pSensor, ISensorDataReport *pDataReport, void* pData)
{
HRESULT hr = S_OK;
InclinometerData* mapTilt = (InclinometerData*)pData;
if (NULL != pSensor && NULL != pDataReport)
{
SENSOR_ID idSensor = GUID_NULL;
hr = pSensor->GetID(&idSensor);
if (SUCCEEDED(hr))
{
PROPVARIANT pvTilt;
PROPVARIANT pvTimeStamp;
PropVariantInit(&pvTilt);
PropVariantInit(&pvTimeStamp);
hr = pDataReport->GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, &pvTilt);
if (SUCCEEDED(hr))
{
// Save the lux value into our member variable
mapTilt->X_Tilt = V_R4(&pvTilt);
}
PropVariantClear(&pvTilt);
PropVariantInit(&pvTilt);
hr = pDataReport->GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, &pvTilt);
if (SUCCEEDED(hr))
{
// Save the lux value into our member variable
mapTilt->Y_Tilt = V_R4(&pvTilt);
}
PropVariantClear(&pvTilt);
PropVariantInit(&pvTilt);
hr = pDataReport->GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, &pvTilt);
if (SUCCEEDED(hr))
{
// Save the lux value into our member variable
mapTilt->Z_Tilt = V_R4(&pvTilt);
}
PropVariantClear(&pvTilt);
hr = pDataReport->GetSensorValue(SENSOR_DATA_TYPE_TIMESTAMP, &pvTimeStamp);
if (SUCCEEDED(hr))
{
mapTilt->InclinometerTime = ((unsigned __int64)pvTimeStamp.filetime.dwHighDateTime<<32) | pvTimeStamp.filetime.dwLowDateTime;
}
PropVariantClear(&pvTimeStamp);
}
}
else
{
hr = E_INVALIDARG;
}
return hr;
}
wchar_t *Variant2CWString(VARIANT *result){
switch(V_VT(result)){
case VT_EMPTY:
return L"empty";
break;
case VT_NULL:
return L"null";
break;
case VT_I2: // short
return Number2String((long)V_I2(result));
break;
case VT_I4: // long
return Number2String((long)V_I4(result));
break;
case VT_R4: // float
return Double2String(V_R4(result));
break;
case VT_R8: // double
return Double2String(V_R8(result));
break;
case VT_BOOL: //(True -1,False 0)
return (V_BOOL(result) ? L"True" : L"False");
break;
case VT_BSTR:
return (wchar_t*)(V_BSTR(result));
break;
case VT_DATE:
return Date2String( V_DATE(result));
break;
}
}
static HRESULT var2str(const VARIANT *p, nsAString *nsstr)
{
BSTR str;
BOOL ret;
HRESULT hres;
switch(V_VT(p)) {
case VT_BSTR:
return nsAString_Init(nsstr, V_BSTR(p))?
S_OK : E_OUTOFMEMORY;
case VT_R8:
hres = VarBstrFromR8(V_R8(p), 0, 0, &str);
break;
case VT_R4:
hres = VarBstrFromR4(V_R4(p), 0, 0, &str);
break;
case VT_I4:
hres = VarBstrFromI4(V_I4(p), 0, 0, &str);
break;
default:
FIXME("unsupported arg %s\n", debugstr_variant(p));
return E_NOTIMPL;
}
if (FAILED(hres))
return hres;
ret = nsAString_Init(nsstr, str);
SysFreeString(str);
return ret ? S_OK : E_OUTOFMEMORY;
}
//+---------------------------------------------------------------------------
//
// Function: CVarToVARIANTARG
//
// Synopsis: Converts a C-language variable to a VARIANT.
//
// Arguments: [pv] -- Pointer to C-language variable.
// [vt] -- Type of C-language variable.
// [pvarg] -- Resulting VARIANT. Must be initialized by caller.
// Any contents will be freed.
//
// Modifies: [pvarg]
//
// History: 2-23-94 adams Created
//
// Notes: Supports all variant pointer types, VT_UI2, VT_I2, VT_UI4,
// VT_I4, VT_R4, VT_R8, VT_ERROR.
//
//----------------------------------------------------------------------------
void CVarToVARIANTARG(void* pv, VARTYPE vt, VARIANTARG* pvarg)
{
Assert(pv);
Assert(pvarg);
VariantClear(pvarg);
V_VT(pvarg) = vt;
if(V_ISBYREF(pvarg))
{
// Use a supported pointer type for derefencing.
vt = VT_UNKNOWN;
}
switch(vt)
{
case VT_BOOL:
// convert TRUE to VT_TRUE
Assert(*(BOOL*)pv==1 || *(BOOL*)pv==0);
V_BOOL(pvarg) = VARIANT_BOOL(-*(BOOL*)pv);
break;
case VT_I2:
V_I2(pvarg) = *(short*)pv;
break;
case VT_ERROR:
case VT_I4:
V_I4(pvarg) = *(long*)pv;
break;
case VT_R4:
V_R4(pvarg) = *(float*)pv;
break;
case VT_R8:
V_R8(pvarg) = *(double*)pv;
break;
case VT_CY:
V_CY(pvarg) = *(CY*)pv;
break;
// All Pointer types.
case VT_PTR:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
V_BYREF(pvarg) = *(void**)pv;
break;
default:
Assert(FALSE && "Unknown type.");
break;
}
}
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantFloat(JNIEnv *env, jobject _this, jfloat val)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
VariantClear(v); // whatever was there before
V_VT(v) = VT_R4;
V_R4(v) = val;
}
}
/**
* Returns the value of this Variant as a Float if it is of that type.
* Otherwise it will return null (no conversion done)
*/
JNIEXPORT jfloat JNICALL Java_com_tangram_Variant_getVariantFloat(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
if (V_VT(v) != (VT_R4)) {
return NULL;
}
return (jfloat)V_R4(v);
}
return NULL;
}
TclObject::TclObject (VARIANT *pSrc, const Type &type, Tcl_Interp *interp, int bytes)
{
if (V_ISARRAY(pSrc)) {
SAFEARRAY *psa = V_ISBYREF(pSrc) ? *V_ARRAYREF(pSrc) : V_ARRAY(pSrc);
VARTYPE elementType = V_VT(pSrc) & VT_TYPEMASK;
unsigned numDimensions = SafeArrayGetDim(psa);
std::vector<long> indices(numDimensions);
m_pObj = convertFromSafeArray( psa, elementType, 1, &indices[0], type, interp, bytes);
} else if (vtMissing == pSrc) {
m_pObj = Extension::newNaObj();
} else {
switch (V_VT(pSrc)) {
case VT_BOOL:
m_pObj = Tcl_NewBooleanObj(V_BOOL(pSrc));
break;
case VT_ERROR:
m_pObj = Tcl_NewLongObj(V_ERROR(pSrc));
break;
case VT_I1:
case VT_UI1:
m_pObj = Tcl_NewLongObj(V_I1(pSrc));
break;
case VT_I2:
case VT_UI2:
m_pObj = Tcl_NewLongObj(V_I2(pSrc));
break;
case VT_I4:
case VT_UI4:
case VT_INT:
case VT_UINT:
m_pObj = Tcl_NewLongObj(V_I4(pSrc));
break;
#ifdef V_I8
case VT_I8:
case VT_UI8:
m_pObj = Tcl_NewWideIntObj(V_I8(pSrc));
break;
#endif
case VT_R4:
m_pObj = Tcl_NewDoubleObj(V_R4(pSrc));
break;
case VT_DATE:
case VT_R8:
m_pObj = Tcl_NewDoubleObj(V_R8(pSrc));
break;
case VT_DISPATCH:
m_pObj = convertFromUnknown(V_DISPATCH(pSrc), type.iid(), interp);
break;
case VT_DISPATCH | VT_BYREF:
m_pObj = convertFromUnknown(
(V_DISPATCHREF(pSrc) != 0) ? *V_DISPATCHREF(pSrc) : 0,
type.iid(),
interp);
break;
case VT_UNKNOWN:
m_pObj = convertFromUnknown(V_UNKNOWN(pSrc), type.iid(), interp);
break;
case VT_UNKNOWN | VT_BYREF:
m_pObj = convertFromUnknown(
(V_UNKNOWNREF(pSrc) != 0) ? *V_UNKNOWNREF(pSrc) : 0,
type.iid(),
interp);
break;
case VT_NULL:
m_pObj = Extension::newNullObj();
break;
case VT_LPSTR:
m_pObj = Tcl_NewStringObj(V_I1REF(pSrc), -1);
break;
case VT_LPWSTR:
{
#if TCL_MINOR_VERSION >= 2
// Uses Unicode function introduced in Tcl 8.2.
m_pObj = newUnicodeObj(V_UI2REF(pSrc), -1);
#else
const wchar_t *pWide = V_UI2REF(pSrc);
_bstr_t str(pWide);
m_pObj = Tcl_NewStringObj(str, -1);
#endif
}
break;
default:
if (V_VT(pSrc) == VT_USERDEFINED && type.name() == "GUID") {
Uuid uuid(*static_cast<UUID *>(V_BYREF(pSrc)));
m_pObj = Tcl_NewStringObj(
const_cast<char *>(uuid.toString().c_str()), -1);
} else {
if (V_VT(pSrc) == (VT_VARIANT | VT_BYREF)) {
pSrc = V_VARIANTREF(pSrc);
}
_bstr_t str(pSrc);
#if TCL_MINOR_VERSION >= 2
// Uses Unicode function introduced in Tcl 8.2.
wchar_t *pWide = str;
m_pObj = newUnicodeObj(
reinterpret_cast<Tcl_UniChar *>(pWide), str.length());
#else
m_pObj = Tcl_NewStringObj(str, -1);
#endif
}
}
}
Tcl_IncrRefCount(m_pObj);
}
STDAPI
VariantChangeType(
VARIANTARG FAR* pvargDest,
VARIANTARG FAR* pvargSrc,
unsigned short wFlags,
VARTYPE vt)
{
VARIANT varTmp;
HRESULT hresult;
VARTYPE vtSrc;
if (pvargDest == NULL || pvargSrc == NULL)
return(E_INVALIDARG);
vtSrc = V_VT(pvargSrc); // get src vartype
hresult = NOERROR; // assume success
// NOTE: all code after this point must go to LError0 upon Error.
// should have validated the destination type at this point (to ensure
// that the below optimized switch statement will work properly).
switch ( VTSW(vtSrc, vt) )
{
case VTSW(VT_BOOL, VT_BOOL):
case VTSW(VT_I2, VT_I2):
case VTSW(VT_I4, VT_I4):
case VTSW(VT_INT, VT_INT):
case VTSW(VT_I8, VT_I8):
case VTSW(VT_R4, VT_R4):
case VTSW(VT_R8, VT_R8):
case VTSW(VT_CY, VT_CY):
case VTSW(VT_DECIMAL, VT_DECIMAL):
case VTSW(VT_I1, VT_I1):
case VTSW(VT_UI1, VT_UI1):
case VTSW(VT_UI2, VT_UI2):
case VTSW(VT_UI4, VT_UI4):
case VTSW(VT_UINT, VT_UINT):
case VTSW(VT_UI8, VT_UI8):
varTmp = *pvargSrc;
break;
case VTSW(VT_EMPTY, VT_BSTR):
hresult = ErrSysAllocString(OASTR(""), &V_BSTR(&varTmp));
break;
case VTSW(VT_BOOL, VT_BSTR):
//fall through to return "0" or "-1"
case VTSW(VT_I2, VT_BSTR):
hresult = VarBstrFromI2(V_I2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I4, VT_BSTR):
case VTSW(VT_INT, VT_BSTR):
hresult = VarBstrFromI4(V_I4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I8, VT_BSTR):
hresult = VarBstrFromI8(V_I8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R4, VT_BSTR):
hresult = VarBstrFromR4(V_R4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R8, VT_BSTR):
hresult = VarBstrFromR8(V_R8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_CY, VT_BSTR):
hresult = VarBstrFromCy(V_CY(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_DECIMAL, VT_BSTR):
hresult = VarBstrFromDec(&pvargSrc->n1.decVal, LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I1, VT_BSTR):
hresult = VarBstrFromI1(V_I1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI1, VT_BSTR):
hresult = VarBstrFromUI1(V_UI1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI2, VT_BSTR):
hresult = VarBstrFromUI2(V_UI2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI4, VT_BSTR):
case VTSW(VT_UINT, VT_BSTR):
hresult = VarBstrFromUI4(V_UI4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI8, VT_BSTR):
hresult = VarBstrFromUI8(V_UI8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_BSTR, VT_BSTR):
hresult = ErrSysAllocString(V_BSTR(pvargSrc), &V_BSTR(&varTmp));
break;
case VTSW(VT_DATE, VT_BSTR):
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
default:
if (vtSrc >= VT_VARIANT) {
IfFailGo(IsLegalVartype(vtSrc), LError0);
}
// everybody else gets a type mis-match error
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
}
if (FAILED(hresult))
{
goto LError0;
}
// now set the tag in temp variant. Errors after this point have to
// goto LError1 to potentially clear this variant.
V_VT(&varTmp) = vt;
// now that we have succeeded, we can go ahead and destroy our
// destination variant.
if (V_VT(pvargDest) >= VT_BSTR) {
IfFailGo(VariantClear(pvargDest), LError1);
}
// copy in the variant we just created
memcpy(pvargDest, &varTmp, sizeof(VARIANT));
return NOERROR;
LError1:;
VariantClear(&varTmp);
// fall through
LError0:;
return hresult;
}
static void test_registry(void)
{
static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0};
static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0};
static const WCHAR regszW[] = {'r','e','g','s','z',0};
static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0};
static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0};
static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0};
static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0};
static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
static const WCHAR fooW[] = {'f','o','o',0};
static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0};
static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0};
WCHAR pathW[MAX_PATH];
DWORD dwvalue, type;
VARIANT value, v;
IWshShell3 *sh3;
VARTYPE vartype;
LONG bound;
HRESULT hr;
BSTR name;
HKEY root;
LONG ret;
UINT dim;
hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IWshShell3, (void**)&sh3);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* RegRead() */
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, NULL, &value);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
name = SysAllocString(brokenW);
hr = IWshShell3_RegRead(sh3, name, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
name = SysAllocString(broken2W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9);
ok(ret == 0, "got %d\n", ret);
dwvalue = 10;
ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
dwvalue = 11;
ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
/* REG_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_SZ with embedded NULL */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regsz2W);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_DWORD */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regdwordW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value));
ok(V_I4(&value) == 10, "got %d\n", V_I4(&value));
SysFreeString(name);
/* REG_BINARY */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regbinaryW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 3, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v));
ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v));
VariantClear(&v);
VariantClear(&value);
SysFreeString(name);
/* REG_MULTI_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regmultiszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
SysFreeString(name);
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 1, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
VariantClear(&value);
name = SysAllocString(regsz1W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
VariantClear(&value);
SysFreeString(name);
delete_key(root);
/* RegWrite() */
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
hr = IWshShell3_RegWrite(sh3, name, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
VariantInit(&value);
hr = IWshShell3_RegWrite(sh3, name, &value, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShell3_RegWrite(sh3, name, &value, &value);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
/* type is optional */
V_VT(&v) = VT_ERROR;
V_ERROR(&v) = DISP_E_PARAMNOTFOUND;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* default type is REG_SZ */
V_VT(&value) = VT_I4;
V_I4(&value) = 12;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_BSTR;
V_BSTR(&value) = SysAllocString(regszW);
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
V_VT(&v) = VT_I2;
V_I2(&v) = 1;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
VariantClear(&value);
SysFreeString(name);
delete_key(root);
IWshShell3_Release(sh3);
}
HRESULT CTCPropBagOnRegKey::_WriteSafeArray(CRegKey& key,
const _bstr_t& strPropName, VARIANT* pVar)
{
ASSERT(V_ISARRAY(pVar));
ASSERT(lstrlen(strPropName));
// Get the SAFEARRAY pointer from the variant
SAFEARRAY* psa = V_ARRAY(pVar);
if (IsBadReadPtr(psa))
return E_POINTER;
// Only support 1-dimensional arrays (currently)
if (1 != SafeArrayGetDim(psa))
return E_INVALIDARG;
// Get the element size of the safe array
UINT cbElement = SafeArrayGetElemsize(psa);
// Get the safe array type from the variant
VARTYPE vt = V_VT(pVar) & ~VT_ARRAY;
// Check for supported types and validate the element size
switch (vt)
{
case VT_BOOL:
if (sizeof(V_BOOL(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I1:
if (sizeof(V_I1(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I2:
if (sizeof(V_I2(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I4:
if (sizeof(V_I4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI1:
if (sizeof(V_UI1(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI2:
if (sizeof(V_UI2(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI4:
if (sizeof(V_UI4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_ERROR:
if (sizeof(V_ERROR(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_R4:
if (sizeof(V_R4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_R8:
if (sizeof(V_R8(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DECIMAL:
if (sizeof(V_DECIMAL(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_CY:
if (sizeof(V_CY(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DATE:
if (sizeof(V_DATE(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_BSTR:
if (sizeof(V_BSTR(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UNKNOWN:
if (sizeof(V_UNKNOWN(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DISPATCH:
if (sizeof(V_DISPATCH(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_VARIANT:
if (sizeof(V_VARIANTREF(pVar)) != cbElement)
return E_UNEXPECTED;
break;
default:
return E_UNEXPECTED;
}
// Get the upper and lower bounds of the safe array
HRESULT hr;
LONG lUBound = 0, lLBound = 0;
if (FAILED(hr = SafeArrayGetUBound(psa, 1, &lUBound)))
return hr;
if (FAILED(hr = SafeArrayGetLBound(psa, 1, &lLBound)))
return hr;
UINT nElements = lUBound - lLBound + 1;
// Create a subkey with the specified name
key.DeleteValue(strPropName);
key.RecurseDeleteKey(strPropName);
CRegKey subkey;
if (!subkey.Open(key, strPropName))
return HRESULT_FROM_WIN32(GetLastError());
// Get access to the safe array data
BYTE* pElement = NULL;
if (FAILED(hr = SafeArrayAccessData(psa, (void**)&pElement)))
return hr;
// Write the variant type value
subkey.WriteDWord(m_szVariantType, DWORD(V_VT(pVar)));
// Write the element count value
subkey.WriteDWord(m_szElementCount, DWORD(nElements));
// Write the lower bound value, if not 0
if (lLBound)
subkey.WriteDWord(m_szLowerBound, DWORD(lLBound));
// Special handling for arrays of variants
_bstr_t strText;
if (VT_VARIANT == vt)
{
// Write each variant array element to the registry
for (UINT i = 0; i < nElements; i++, pElement += cbElement)
{
// Format the value name
strText.Format(m_szElementFmt, i);
// Write the variant array element to the registry subkey
if (FAILED(hr = WriteVariant(subkey, strText, (VARIANT*)pElement)))
{
TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ",
strPropName);
TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n",
strText, hr);
}
}
}
else
{
// Write each array element to the registry
VARIANT var;
V_VT(&var) = vt;
for (UINT i = 0; i < nElements; i++, pElement += cbElement)
{
// Copy the array element to the data portion of the VARIANT
memcpy(&V_NONE(&var), pElement, cbElement);
// Format the value name
strText.Format(m_szElementFmt, i);
// Write the variant to the registry subkey
if (FAILED(hr = WriteVariant(subkey, strText, &var)))
{
TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ",
strPropName);
TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n",
strText, hr);
}
}
}
// Release access to the safe array data
VERIFY(SUCCEEDED(SafeArrayUnaccessData(psa)));
// Indicate success
return S_OK;
}
CString CCrack::strVARIANT(const COleVariant& var)
{
CString strRet;
strRet = _T("Fish");
switch(var.vt){
case VT_EMPTY:
case VT_NULL:
strRet = _T("NULL");
break;
case VT_I2:
strRet.Format(_T("%hd"),V_I2(&var));
break;
case VT_I4:
strRet.Format(_T("%d"),V_I4(&var));
break;
case VT_R4:
strRet.Format(_T("%g"),(double)V_R4(&var));
break;
case VT_R8:
strRet.Format(_T("%g"),V_R8(&var));
break;
case VT_CY:
strRet = COleCurrency(var).Format();
break;
case VT_DATE:
strRet = COleDateTime(var).Format(_T("%m %d %y"));
break;
case VT_BSTR:
strRet = V_BSTRT(&var);
break;
case VT_DISPATCH:
strRet = _T("VT_DISPATCH");
break;
case VT_ERROR:
strRet = _T("VT_ERROR");
break;
case VT_BOOL:
return strBOOL(V_BOOL(&var));
case VT_VARIANT:
strRet = _T("VT_VARIANT");
break;
case VT_UNKNOWN:
strRet = _T("VT_UNKNOWN");
break;
case VT_I1:
strRet = _T("VT_I1");
break;
case VT_UI1:
strRet.Format(_T("0x%02hX"),(unsigned short)V_UI1(&var));
break;
case VT_UI2:
strRet = _T("VT_UI2");
break;
case VT_UI4:
strRet = _T("VT_UI4");
break;
case VT_I8:
strRet = _T("VT_I8");
break;
case VT_UI8:
strRet = _T("VT_UI8");
break;
case VT_INT:
strRet = _T("VT_INT");
break;
case VT_UINT:
strRet = _T("VT_UINT");
break;
case VT_VOID:
strRet = _T("VT_VOID");
break;
case VT_HRESULT:
strRet = _T("VT_HRESULT");
break;
case VT_PTR:
strRet = _T("VT_PTR");
break;
case VT_SAFEARRAY:
strRet = _T("VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet = _T("VT_CARRAY");
break;
case VT_USERDEFINED:
strRet = _T("VT_USERDEFINED");
break;
case VT_LPSTR:
strRet = _T("VT_LPSTR");
break;
case VT_LPWSTR:
strRet = _T("VT_LPWSTR");
break;
case VT_FILETIME:
strRet = _T("VT_FILETIME");
break;
case VT_BLOB:
strRet = _T("VT_BLOB");
break;
case VT_STREAM:
strRet = _T("VT_STREAM");
break;
case VT_STORAGE:
strRet = _T("VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet = _T("VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet = _T("VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet = _T("VT_BLOB_OBJECT");
break;
case VT_CF:
strRet = _T("VT_CF");
break;
case VT_CLSID:
strRet = _T("VT_CLSID");
break;
}
WORD vt = var.vt;
if(vt & VT_ARRAY){
vt = vt & ~VT_ARRAY;
strRet = _T("Array of ");
}
if(vt & VT_BYREF){
vt = vt & ~VT_BYREF;
strRet += _T("Pointer to ");
}
if(vt != var.vt){
switch(vt){
case VT_EMPTY:
strRet += _T("VT_EMPTY");
break;
case VT_NULL:
strRet += _T("VT_NULL");
break;
case VT_I2:
strRet += _T("VT_I2");
break;
case VT_I4:
strRet += _T("VT_I4");
break;
case VT_R4:
strRet += _T("VT_R4");
break;
case VT_R8:
strRet += _T("VT_R8");
break;
case VT_CY:
strRet += _T("VT_CY");
break;
case VT_DATE:
strRet += _T("VT_DATE");
break;
case VT_BSTR:
strRet += _T("VT_BSTR");
break;
case VT_DISPATCH:
strRet += _T("VT_DISPATCH");
break;
case VT_ERROR:
strRet += _T("VT_ERROR");
break;
case VT_BOOL:
strRet += _T("VT_BOOL");
break;
case VT_VARIANT:
strRet += _T("VT_VARIANT");
break;
case VT_UNKNOWN:
strRet += _T("VT_UNKNOWN");
break;
case VT_I1:
strRet += _T("VT_I1");
break;
case VT_UI1:
strRet += _T("VT_UI1");
break;
case VT_UI2:
strRet += _T("VT_UI2");
break;
case VT_UI4:
strRet += _T("VT_UI4");
break;
case VT_I8:
strRet += _T("VT_I8");
break;
case VT_UI8:
strRet += _T("VT_UI8");
break;
case VT_INT:
strRet += _T("VT_INT");
break;
case VT_UINT:
strRet += _T("VT_UINT");
break;
case VT_VOID:
strRet += _T("VT_VOID");
break;
case VT_HRESULT:
strRet += _T("VT_HRESULT");
break;
case VT_PTR:
strRet += _T("VT_PTR");
break;
case VT_SAFEARRAY:
strRet += _T("VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet += _T("VT_CARRAY");
break;
case VT_USERDEFINED:
strRet += _T("VT_USERDEFINED");
break;
case VT_LPSTR:
strRet += _T("VT_LPSTR");
break;
case VT_LPWSTR:
strRet += _T("VT_LPWSTR");
break;
case VT_FILETIME:
strRet += _T("VT_FILETIME");
break;
case VT_BLOB:
strRet += _T("VT_BLOB");
break;
case VT_STREAM:
strRet += _T("VT_STREAM");
break;
case VT_STORAGE:
strRet += _T("VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet += _T("VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet += _T("VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet += _T("VT_BLOB_OBJECT");
break;
case VT_CF:
strRet += _T("VT_CF");
break;
case VT_CLSID:
strRet += _T("VT_CLSID");
break;
}
}
return strRet;
}
void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
switch (com->vt)
{
case VT_DISPATCH:
{
switch (java->vt)
{
case VT_DISPATCH:
{
V_DISPATCH(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
V_DISPATCH(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_DISPATCH | VT_BYREF:
{
switch (java->vt)
{
case VT_DISPATCH:
{
*V_DISPATCHREF(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_BOOL:
{
switch (java->vt)
{
case VT_BOOL:
{
V_BOOL(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
V_BOOL(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_BOOL | VT_BYREF:
{
switch (java->vt)
{
case VT_BOOL:
{
*V_BOOLREF(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
*V_BOOLREF(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_UI1:
{
switch (java->vt)
{
case VT_UI1:
{
V_UI1(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
V_UI1(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_UI1 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI1:
{
*V_UI1REF(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
*V_UI1REF(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_I2:
{
switch (java->vt)
{
case VT_I2:
{
V_I2(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
V_I2(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I2 | VT_BYREF:
{
switch (java->vt)
{
case VT_I2:
{
*V_I2REF(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
*V_I2REF(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I4:
{
switch (java->vt)
{
case VT_I4:
{
V_I4(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
V_I4(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_I4 | VT_BYREF:
{
switch (java->vt)
{
case VT_I4:
{
*V_I4REF(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
*V_I4REF(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_R4:
{
switch (java->vt)
{
case VT_R4:
{
V_R4(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
V_R4(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R4 | VT_BYREF:
{
switch (java->vt)
{
case VT_R4:
{
*V_R4REF(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
*V_R4REF(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R8:
{
switch (java->vt)
{
case VT_R8:
{
V_R8(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
V_R8(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_R8 | VT_BYREF:
{
switch (java->vt)
{
case VT_R8:
{
*V_R8REF(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
*V_R8REF(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_I1:
{
switch (java->vt)
{
case VT_I1:
{
V_I1(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
V_I1(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_I1 | VT_BYREF:
{
switch (java->vt)
{
case VT_I1:
{
*V_I1REF(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
*V_I1REF(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_UI2:
{
switch (java->vt)
{
case VT_UI2:
{
V_UI2(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
V_UI2(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI2 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI2:
{
*V_UI2REF(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
*V_UI2REF(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI4:
{
switch (java->vt)
{
case VT_UI4:
{
V_UI4(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
V_UI4(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_UI4 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI4:
{
*V_UI4REF(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
*V_UI4REF(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_INT:
{
switch (java->vt)
{
case VT_INT:
{
V_INT(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
V_INT(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_INT | VT_BYREF:
{
switch (java->vt)
{
case VT_INT:
{
*V_INTREF(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
*V_INTREF(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_UINT:
{
switch (java->vt)
{
case VT_UINT:
{
V_UINT(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
V_UINT(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_UINT | VT_BYREF:
{
switch (java->vt)
{
case VT_UINT:
{
*V_UINTREF(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
*V_UINTREF(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_CY:
{
switch (java->vt)
{
case VT_CY:
{
V_CY(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
V_CY(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_CY | VT_BYREF:
{
switch (java->vt)
{
case VT_CY:
{
*V_CYREF(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
*V_CYREF(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_DATE:
{
switch (java->vt)
{
case VT_DATE:
{
V_DATE(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
V_DATE(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_DATE | VT_BYREF:
{
switch (java->vt)
{
case VT_DATE:
{
*V_DATEREF(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
*V_DATEREF(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_BSTR:
{
switch (java->vt)
{
case VT_BSTR:
{
V_BSTR(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
V_BSTR(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_BSTR | VT_BYREF:
{
switch (java->vt)
{
case VT_BSTR:
{
*V_BSTRREF(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
*V_BSTRREF(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_DECIMAL:
{
switch (java->vt)
{
case VT_DECIMAL:
{
V_DECIMAL(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
V_DECIMAL(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
case VT_DECIMAL | VT_BYREF:
{
switch (java->vt)
{
case VT_DECIMAL:
{
*V_DECIMALREF(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
*V_DECIMALREF(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
}
}
HRESULT VariantChangeTypeSpecial(VARIANT* pvargDest, VARIANT* pVArg, VARTYPE vt, IServiceProvider* pSrvProvider/*=NULL*/, DWORD dwFlags/*=0*/)
{
HRESULT hr;
IVariantChangeType* pVarChangeType = NULL;
if(pSrvProvider)
{
hr = pSrvProvider->QueryService(SID_VariantConversion,
IID_IVariantChangeType, (void**)&pVarChangeType);
if(hr)
{
goto OldWay;
}
// Use script engine conversion routine.
hr = pVarChangeType->ChangeType(pvargDest, pVArg, 0, vt);
if(!hr)
{
goto Cleanup; // ChangeType suceeded we're done...
}
}
// Fall back to our tried & trusted type coercions
OldWay:
hr = S_OK;
if(vt==VT_BSTR && V_VT(pVArg)==VT_NULL)
{
// Converting a NULL to BSTR
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(_T("null"), &V_BSTR(pvargDest));
goto Cleanup;
}
else if(vt==VT_BSTR && V_VT(pVArg)==VT_EMPTY)
{
// Converting "undefined" to BSTR
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(_T("undefined"), &V_BSTR(pvargDest));
goto Cleanup;
}
else if(vt==VT_BOOL && V_VT(pVArg)==VT_BSTR)
{
// Converting from BSTR to BOOL
// To match Navigator compatibility empty strings implies false when
// assigned to a boolean type any other string implies true.
V_VT(pvargDest) = VT_BOOL;
V_BOOL(pvargDest) = FormsStringLen(V_BSTR(pVArg))==0 ? VARIANT_FALSE : VARIANT_TRUE;
goto Cleanup;
}
else if(V_VT(pVArg)==VT_BOOL && vt==VT_BSTR)
{
// Converting from BOOL to BSTR
// To match Nav we either get "true" or "false"
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(
V_BOOL(pVArg)==VARIANT_TRUE?_T("true"):_T("false"),
&V_BSTR(pvargDest));
goto Cleanup;
}
// If we're converting R4 or R8 to a string then we need special handling to
// map Nan and +/-Inf.
else if(vt==VT_BSTR && (V_VT(pVArg)==VT_R8||V_VT(pVArg)==VT_R4))
{
double dblValue = V_VT(pVArg)==VT_R8 ? V_R8(pVArg) : (double)(V_R4(pVArg));
// Infinity or NAN?
if(!isFinite(dblValue))
{
if(isNAN(dblValue))
{
// NAN
hr = FormsAllocStringW(_T("NaN"), &(V_BSTR(pvargDest)));
}
else
{
// Infinity
hr = FormsAllocStringW((dblValue<0)?_T("-Infinity"):_T("Infinity"), &(V_BSTR(pvargDest)));
}
}
else
{
goto DefaultConvert;
}
// Any error from allocating string?
if(hr)
{
goto Cleanup;
}
V_VT(pvargDest) = vt;
goto Cleanup;
}
DefaultConvert:
// Default VariantChangeTypeEx.
// VARIANT_NOUSEROVERRIDE flag is undocumented flag that tells OLEAUT to convert to the lcid
// given. Without it the conversion is done to user localeid
hr = VariantChangeTypeEx(pvargDest, pVArg, LCID_SCRIPTING, dwFlags|VARIANT_NOUSEROVERRIDE, vt);
if(hr == DISP_E_TYPEMISMATCH)
{
if(V_VT(pVArg) == VT_NULL)
{
hr = S_OK;
switch(vt)
{
case VT_BOOL:
V_BOOL(pvargDest) = VARIANT_FALSE;
V_VT(pvargDest) = VT_BOOL;
break;
// For NS compatability - NS treats NULL args as 0
default:
V_I4(pvargDest)=0;
break;
}
}
else if(V_VT(pVArg) == VT_DISPATCH)
{
// Nav compatability - return the string [object] or null
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString((V_DISPATCH(pVArg))?_T("[object]"):_T("null"), &V_BSTR(pvargDest));
}
else if(V_VT(pVArg)==VT_BSTR &&
(V_BSTR(pVArg) && ((V_BSTR(pVArg))[0]==_T('\0')) ||!V_BSTR(pVArg)) &&
(vt==VT_I4 || vt==VT_I2 || vt==VT_UI2||vt==VT_UI4
|| vt==VT_I8||vt==VT_UI8 || vt==VT_INT || vt==VT_UINT))
{
// Converting empty string to integer => Zero
hr = S_OK;
V_VT(pvargDest) = vt;
V_I4(pvargDest) = 0;
goto Cleanup;
}
}
else if(hr==DISP_E_OVERFLOW && vt==VT_I4 && (V_VT(pVArg)==VT_R8 || V_VT(pVArg)==VT_R4))
{
// Nav compatability - return MAXLONG on overflow
V_VT(pvargDest) = VT_I4;
V_I4(pvargDest) = MAXLONG;
hr = S_OK;
goto Cleanup;
}
// To match Navigator change any scientific notation E to e.
if(!hr && (vt==VT_BSTR && (V_VT(pVArg)==VT_R8 || V_VT(pVArg)==VT_R4)))
{
TCHAR* pENotation;
pENotation = _tcschr(V_BSTR(pvargDest), _T('E'));
if(pENotation)
{
*pENotation = _T('e');
}
}
Cleanup:
ReleaseInterface(pVarChangeType);
RRETURN(hr);
}
HRESULT variant_change_type(script_ctx_t *ctx, VARIANT *dst, VARIANT *src, VARTYPE vt)
{
jsval_t val;
HRESULT hres;
clear_ei(ctx);
hres = variant_to_jsval(src, &val);
if(FAILED(hres))
return hres;
switch(vt) {
case VT_I2:
case VT_I4: {
INT i;
hres = to_int32(ctx, val, &i);
if(SUCCEEDED(hres)) {
if(vt == VT_I4)
V_I4(dst) = i;
else
V_I2(dst) = i;
}
break;
}
case VT_R8: {
double n;
hres = to_number(ctx, val, &n);
if(SUCCEEDED(hres))
V_R8(dst) = n;
break;
}
case VT_R4: {
double n;
hres = to_number(ctx, val, &n);
if(SUCCEEDED(hres))
V_R4(dst) = n;
break;
}
case VT_BOOL: {
BOOL b;
hres = to_boolean(val, &b);
if(SUCCEEDED(hres))
V_BOOL(dst) = b ? VARIANT_TRUE : VARIANT_FALSE;
break;
}
case VT_BSTR: {
jsstr_t *str;
hres = to_string(ctx, val, &str);
if(FAILED(hres))
break;
if(str->length_flags & JSSTR_FLAG_NULLBSTR) {
V_BSTR(dst) = NULL;
break;
}
V_BSTR(dst) = SysAllocStringLen(str->str, jsstr_length(str));
if(!V_BSTR(dst))
hres = E_OUTOFMEMORY;
break;
}
case VT_EMPTY:
hres = V_VT(src) == VT_EMPTY ? S_OK : E_NOTIMPL;
break;
case VT_NULL:
hres = V_VT(src) == VT_NULL ? S_OK : E_NOTIMPL;
break;
default:
FIXME("vt %d not implemented\n", vt);
hres = E_NOTIMPL;
}
jsval_release(val);
if(FAILED(hres))
return hres;
V_VT(dst) = vt;
return S_OK;
}
PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar)
{
int ret = SUCCESS;
switch (V_VT(dstvar) & ~VT_BYREF) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
/* should not be possible */
break;
case VT_UI1:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI1REF(dstvar) = V_UI1(srcvar);
} else {
V_UI1(dstvar) = V_UI1(srcvar);
}
break;
case VT_I1:
if (V_VT(dstvar) & VT_BYREF) {
*V_I1REF(dstvar) = V_I1(srcvar);
} else {
V_I1(dstvar) = V_I1(srcvar);
}
break;
case VT_UI2:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI2REF(dstvar) = V_UI2(srcvar);
} else {
V_UI2(dstvar) = V_UI2(srcvar);
}
break;
case VT_I2:
if (V_VT(dstvar) & VT_BYREF) {
*V_I2REF(dstvar) = V_I2(srcvar);
} else {
V_I2(dstvar) = V_I2(srcvar);
}
break;
case VT_UI4:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI4REF(dstvar) = V_UI4(srcvar);
} else {
V_UI4(dstvar) = V_UI4(srcvar);
}
break;
case VT_I4:
if (V_VT(dstvar) & VT_BYREF) {
*V_I4REF(dstvar) = V_I4(srcvar);
} else {
V_I4(dstvar) = V_I4(srcvar);
}
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI8REF(dstvar) = V_UI8(srcvar);
} else {
V_UI8(dstvar) = V_UI8(srcvar);
}
break;
case VT_I8:
if (V_VT(dstvar) & VT_BYREF) {
*V_I8REF(dstvar) = V_I8(srcvar);
} else {
V_I8(dstvar) = V_I8(srcvar);
}
break;
#endif
case VT_INT:
if (V_VT(dstvar) & VT_BYREF) {
*V_INTREF(dstvar) = V_INT(srcvar);
} else {
V_INT(dstvar) = V_INT(srcvar);
}
break;
case VT_UINT:
if (V_VT(dstvar) & VT_BYREF) {
*V_UINTREF(dstvar) = V_UINT(srcvar);
} else {
V_UINT(dstvar) = V_UINT(srcvar);
}
break;
case VT_R4:
if (V_VT(dstvar) & VT_BYREF) {
*V_R4REF(dstvar) = V_R4(srcvar);
} else {
V_R4(dstvar) = V_R4(srcvar);
}
break;
case VT_R8:
if (V_VT(dstvar) & VT_BYREF) {
*V_R8REF(dstvar) = V_R8(srcvar);
} else {
V_R8(dstvar) = V_R8(srcvar);
}
break;
case VT_BOOL:
if (V_VT(dstvar) & VT_BYREF) {
*V_BOOLREF(dstvar) = V_BOOL(srcvar);
} else {
V_BOOL(dstvar) = V_BOOL(srcvar);
}
break;
case VT_BSTR:
if (V_VT(dstvar) & VT_BYREF) {
*V_BSTRREF(dstvar) = V_BSTR(srcvar);
} else {
V_BSTR(dstvar) = V_BSTR(srcvar);
}
break;
case VT_UNKNOWN:
if (V_VT(dstvar) & VT_BYREF) {
*V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar);
} else {
V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar);
}
break;
case VT_DISPATCH:
if (V_VT(dstvar) & VT_BYREF) {
*V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar);
} else {
V_DISPATCH(dstvar) = V_DISPATCH(srcvar);
}
break;
case VT_VARIANT:
return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar);
default:
php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
ret = FAILURE;
}
return ret;
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (zend_long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (zend_long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (zend_long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (zend_long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
ZVAL_LONG(z, (zend_long)V_UI8(v));
break;
case VT_I8:
ZVAL_LONG(z, (zend_long)V_I8(v));
break;
#endif
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (zend_long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
size_t len;
char *str = php_com_olestring_to_string(olestring,
&len, codepage);
ZVAL_STRINGL(z, str, len);
// TODO: avoid reallocation???
efree(str);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage);
default:
php_com_wrap_variant(z, v, codepage);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
{
if(V_VT(var) == (VT_VARIANT|VT_BYREF))
var = V_VARIANTREF(var);
switch(V_VT(var)) {
case VT_EMPTY:
*r = jsval_undefined();
return S_OK;
case VT_NULL:
*r = jsval_null();
return S_OK;
case VT_BOOL:
*r = jsval_bool(V_BOOL(var));
return S_OK;
case VT_I4:
*r = jsval_number(V_I4(var));
return S_OK;
case VT_R8:
*r = jsval_number(V_R8(var));
return S_OK;
case VT_BSTR: {
jsstr_t *str;
if(V_BSTR(var)) {
str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var)));
if(!str)
return E_OUTOFMEMORY;
}else {
str = jsstr_null_bstr();
}
*r = jsval_string(str);
return S_OK;
}
case VT_DISPATCH: {
if(V_DISPATCH(var))
IDispatch_AddRef(V_DISPATCH(var));
*r = jsval_disp(V_DISPATCH(var));
return S_OK;
}
case VT_I2:
*r = jsval_number(V_I2(var));
return S_OK;
case VT_UI2:
*r = jsval_number(V_UI2(var));
return S_OK;
case VT_INT:
*r = jsval_number(V_INT(var));
return S_OK;
case VT_UI4:
*r = jsval_number(V_UI4(var));
return S_OK;
case VT_UI8:
/*
* Native doesn't support VT_UI8 here, but it's needed for IE9+ APIs
* (native IE9 doesn't use jscript.dll for JavaScript).
*/
*r = jsval_number(V_UI8(var));
return S_OK;
case VT_R4:
*r = jsval_number(V_R4(var));
return S_OK;
case VT_UNKNOWN:
if(V_UNKNOWN(var)) {
IDispatch *disp;
HRESULT hres;
hres = IUnknown_QueryInterface(V_UNKNOWN(var), &IID_IDispatch, (void**)&disp);
if(SUCCEEDED(hres)) {
*r = jsval_disp(disp);
return S_OK;
}
}else {
*r = jsval_disp(NULL);
return S_OK;
}
/* fall through */
default:
return jsval_variant(r, var);
}
}
//+---------------------------------------------------------------------------
//
// Function: VARIANTARGToCVar
//
// Synopsis: Converts a VARIANT to a C-language variable.
//
// Arguments: [pvarg] -- Variant to convert.
// [pfAlloc] -- BSTR allocated during conversion caller is
// now owner of this BSTR or IUnknown or IDispatch
// object allocated needs to be released.
// [vt] -- Type to convert to.
// [pv] -- Location to place C-language variable.
//
// Modifies: [pv].
//
// Returns: HRESULT.
//
// History: 2-23-94 adams Created
//
// Notes: Supports all variant pointer types, VT_I2, VT_I4, VT_R4,
// VT_R8, VT_ERROR.
//----------------------------------------------------------------------------
HRESULT VARIANTARGToCVar(VARIANT* pvarg, BOOL* pfAlloc, VARTYPE vt, void* pv, IServiceProvider* pSrvProvider, WORD wMaxstrlen)
{
HRESULT hr = S_OK;
VARIANTARG* pVArgCopy = pvarg;
VARIANTARG vargNew; // variant of new type
BOOL fAlloc;
Assert(pvarg);
Assert(pv);
if(!pfAlloc)
{
pfAlloc = &fAlloc;
}
Assert((vt&~VT_TYPEMASK) == 0 || (vt&~VT_TYPEMASK)==VT_BYREF);
// Assume no allocations yet.
*pfAlloc = FALSE;
if(vt & VT_BYREF)
{
// If the parameter is a variant pointer then everything is acceptable.
if((vt&VT_TYPEMASK) == VT_VARIANT)
{
switch(V_VT(pvarg))
{
case VT_VARIANT|VT_BYREF:
hr = ClipVarString(pvarg->pvarVal, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
default:
hr = ClipVarString(pvarg, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
}
if(hr == S_FALSE)
{
hr = S_OK;
*(PVOID*)pv = (PVOID)pvarg;
}
goto Cleanup;
}
if((V_VT(pvarg)&VT_TYPEMASK) != (vt&VT_TYPEMASK))
{
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
// Type of both original and destination or same type (however, original
// may not be a byref only the original.
if(V_ISBYREF(pvarg))
{
// Destination and original are byref and same type just copy pointer.
*(PVOID*)pv = V_BYREF(pvarg);
}
else
{
// Convert original to byref.
switch(vt & VT_TYPEMASK)
{
case VT_BOOL:
*(PVOID*)pv = (PVOID)&V_BOOL(pvarg);
break;
case VT_I2:
*(PVOID*)pv = (PVOID)&V_I2(pvarg);
break;
case VT_ERROR:
case VT_I4:
*(PVOID*)pv = (PVOID)&V_I4(pvarg);
break;
case VT_R4:
*(PVOID*)pv = (PVOID)&V_R4(pvarg);
break;
case VT_R8:
*(PVOID*)pv = (PVOID)&V_R8(pvarg);
break;
case VT_CY:
*(PVOID*)pv = (PVOID)&V_CY(pvarg);
break;
// All pointer types.
case VT_PTR:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(PVOID*)pv = (PVOID)&V_UNKNOWN(pvarg);
break;
case VT_VARIANT:
Assert("Dead code: shudn't have gotten here!");
*(PVOID*)pv = (PVOID)pvarg;
break;
default:
Assert(!"Unknown type in BYREF VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
}
goto Cleanup;
}
// If the c style parameter is the same type as the VARIANT then we'll just
// move the data. Also if the c style type is a VARIANT then there's
// nothing to convert just copy the variant to the C parameter.
else if((V_VT(pvarg)&(VT_TYPEMASK|VT_BYREF))!=vt && (vt!=VT_VARIANT))
{
// If the request type isn't the same as the variant passed in then we
// need to convert.
VariantInit(&vargNew);
pVArgCopy = &vargNew;
hr = VariantChangeTypeSpecial(pVArgCopy, pvarg, vt,pSrvProvider);
if(hr)
{
goto Cleanup;
}
*pfAlloc = (vt==VT_BSTR) || (vt==VT_UNKNOWN) || (vt==VT_DISPATCH);
}
// Move the variant data to C style data.
switch(vt)
{
case VT_BOOL:
// convert VT_TRUE and any other non-zero values to TRUE
*(VARIANT_BOOL*)pv = V_BOOL(pVArgCopy);
break;
case VT_I2:
*(short*)pv = V_I2(pVArgCopy);
break;
case VT_ERROR:
case VT_I4:
*(long*)pv = V_I4(pVArgCopy);
break;
case VT_R4:
*(float*)pv = V_R4(pVArgCopy);
break;
case VT_R8:
*(double*)pv = V_R8(pVArgCopy);
break;
case VT_CY:
*(CY*)pv = V_CY(pVArgCopy);
break;
// All Pointer types.
case VT_BSTR:
if(wMaxstrlen && FormsStringLen(V_BSTR(pVArgCopy))>wMaxstrlen)
{
hr = FormsAllocStringLen(V_BSTR(pVArgCopy), wMaxstrlen, (BSTR*)pv);
if(hr)
{
goto Cleanup;
}
if(*pfAlloc)
{
VariantClear(&vargNew);
}
else
{
*pfAlloc = TRUE;
}
goto Cleanup;
}
case VT_PTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(void**)pv = V_BYREF(pVArgCopy);
break;
case VT_VARIANT:
hr = ClipVarString(pVArgCopy, (VARIANT*)pv, pfAlloc, wMaxstrlen);
if(hr == S_FALSE)
{
hr = S_OK;
// Copy entire variant to output parameter.
*(VARIANT*)pv = *pVArgCopy;
}
break;
default:
Assert(FALSE && "Unknown type in VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
break;
}
Cleanup:
RRETURN(hr);
}
////////////////////////////////////////////////////////
// CompareVariant
//
////////////////////////////////////////////////////////
LONG CompareVariant
(
VARIANT *pVar1, //@parm [in]: Pointer to the variant in the consumer's buffer.
VARIANT *pVar2, //@parm [in]: Pointer to the variant at the backend.
BOOL fCaseSensitive
)
{
//Handle NULL cases...
if(pVar1==NULL || pVar2==NULL)
{
if(pVar1 == pVar2)
return TRUE;
return FALSE;
}
// The variant has to be the same type
if (V_VT(pVar1) != V_VT(pVar2))
return FALSE;
// Return FALSE if vt is ORed with VT_RESERVED
if (V_VT(pVar1) & VT_RESERVED)
return FALSE;
// Return TRUE is the vt is VT_EMPTY or VT_NULL
if (V_VT(pVar1)==VT_EMPTY || V_VT(pVar1)==VT_NULL)
return TRUE;
switch(V_VT(pVar1))
{
case VT_UI1:
return V_UI1(pVar1) == V_UI1(pVar2);
case VT_I2:
return V_I2(pVar1) == V_I2(pVar2);
case VT_I4:
return V_I4(pVar1) == V_I4(pVar2);
case VT_R4:
return V_R4(pVar1) == V_R4(pVar2);
case VT_R8:
return V_R8(pVar1) == V_R8(pVar2);
case VT_BOOL:
return V_BOOL(pVar1) == V_BOOL(pVar2);
case VT_ERROR:
return V_ERROR(pVar1) == V_ERROR(pVar2);
case VT_CY:
return memcmp(&V_CY(pVar1), &V_CY(pVar2),8)==0;
case VT_DATE:
return V_DATE(pVar1) == V_DATE(pVar2);
case VT_BSTR:
if(fCaseSensitive)
return wcscmp(V_BSTR(pVar1), V_BSTR(pVar2));
else
return _wcsicmp(V_BSTR(pVar1), V_BSTR(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH:
return FALSE;
case VT_I2 | VT_BYREF:
return *V_I2REF(pVar1) == *V_I2REF(pVar2);
case VT_I4 | VT_BYREF:
return *V_I4REF(pVar1) == *V_I4REF(pVar2);
case VT_R4 | VT_BYREF:
return *V_R4REF(pVar1) == *V_R4REF(pVar2);
case VT_R8 | VT_BYREF:
return *V_R8REF(pVar1) == *V_R8REF(pVar2);
case VT_BOOL | VT_BYREF:
return *V_BOOLREF(pVar1) == *V_BOOLREF(pVar2);
case VT_ERROR | VT_BYREF:
return *V_ERRORREF(pVar1) == *V_ERRORREF(pVar2);
case VT_CY | VT_BYREF:
return memcmp(V_CYREF(pVar1), V_CYREF(pVar2),8)==0;
case VT_DATE | VT_BYREF:
return *V_DATEREF(pVar1) == *V_DATEREF(pVar2);
case VT_BSTR | VT_BYREF:
if(fCaseSensitive)
return wcscmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
else
return _wcsicmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN | VT_BYREF:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH | VT_BYREF:
return FALSE;
}
return FALSE;
}
LPCTSTR COcsWmi::strCimValue(VARIANT &pVal, CIMTYPE &pType)
{
COleDateTime pOleDate;
static CString csResult;
if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY))
csResult.Empty();
else
switch (pType)
{
case CIM_ILLEGAL:
csResult = _T( "CIM_ILLEGAL");
break;
case CIM_EMPTY:
csResult = _T( "");
break;
case CIM_SINT8:
csResult.Format(_T( "%hd"),V_I1(&pVal));
break;
case CIM_UINT8:
csResult.Format(_T( "%hu"),V_UI1(&pVal));
break;
case CIM_SINT16:
csResult.Format(_T( "%d"),V_I2(&pVal));
break;
case CIM_UINT16:
csResult.Format(_T( "%u"),V_UI2(&pVal));
break;
case CIM_SINT32:
csResult.Format(_T( "%ld"),V_I4(&pVal));
break;
case CIM_UINT32:
csResult.Format(_T( "%lu"),V_UI4(&pVal));
break;
case CIM_SINT64:
csResult = V_BSTR(&pVal);
break;
case CIM_UINT64:
csResult = V_BSTR(&pVal);
break;
case CIM_REAL32:
csResult.Format(_T( "%e"),V_R4(&pVal));
break;
case CIM_REAL64:
csResult.Format(_T( "%le"),V_R8(&pVal));
break;
case CIM_BOOLEAN:
csResult = (V_BOOL(&pVal) ? _T("TRUE") : _T("FALSE"));
break;
case CIM_STRING:
csResult = V_BSTR(&pVal);
break;
case CIM_DATETIME:
pOleDate = COleDateTime( pVal);
if (pOleDate.GetStatus() == COleDateTime::valid)
csResult = pOleDate.Format( VAR_DATEVALUEONLY);
else
csResult = V_BSTR( &pVal);
break;
case CIM_REFERENCE:
csResult = V_BSTR( &pVal);
break;
case CIM_CHAR16:
csResult = V_BSTR(&pVal);
break;
case CIM_OBJECT:
csResult = _T( "CIM_OBJECT");
break;
default:
csResult = strVariantArray( pVal);
break;
}
return csResult;
}
LPCTSTR COcsWmi::strVariant( VARIANT pVal)
{
static CString strRet;
strRet = _T( "N/A");
switch(pVal.vt){
case VT_EMPTY:
case VT_NULL:
strRet = _T( "");
break;
case VT_I1:
strRet.Format(_T( "%hd"),V_I2(&pVal));
break;
case VT_I2:
strRet.Format(_T( "%d"),V_I2(&pVal));
break;
case VT_I4:
strRet.Format(_T( "%ld"),V_I4(&pVal));
break;
case VT_I8:
strRet.Format(_T( "%I64d"), V_I8(&pVal));
break;
case VT_UI1:
strRet.Format(_T( "%hu"),V_UI1(&pVal));
break;
case VT_UI2:
strRet.Format(_T( "%u"),V_UI2(&pVal));
break;
case VT_UI4:
strRet.Format(_T( "%lu"),V_UI4(&pVal));
break;
case VT_UI8:
strRet.Format(_T( "%I64u"),V_UI8(&pVal));
break;
case VT_INT:
strRet.Format(_T( "%d"),V_INT(&pVal));
break;
case VT_UINT:
strRet.Format(_T( "%u"),V_UINT(&pVal));
break;
case VT_R4:
strRet.Format(_T( "%e"),V_R4(&pVal));
break;
case VT_R8:
strRet.Format(_T( "%le"),V_R8(&pVal));
break;
case VT_CY:
strRet = COleCurrency(pVal).Format();
break;
case VT_DATE:
strRet = COleDateTime(pVal).Format( VAR_DATEVALUEONLY);
break;
case VT_BSTR:
strRet = V_BSTRT(&pVal);
break;
case VT_DISPATCH:
strRet = _T( "VT_DISPATCH");
break;
case VT_ERROR:
strRet = _T( "VT_ERROR");
break;
case VT_BOOL:
return (V_BOOL(&pVal) ? _T("TRUE") : _T("FALSE"));
case VT_VARIANT:
strRet = _T( "VT_VARIANT");
break;
case VT_UNKNOWN:
strRet = _T( "VT_UNKNOWN");
break;
case VT_VOID:
strRet = _T( "VT_VOID");
break;
case VT_HRESULT:
strRet = _T( "VT_HRESULT");
break;
case VT_PTR:
strRet = _T( "VT_PTR");
break;
case VT_SAFEARRAY:
strRet = _T( "VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet = _T( "VT_CARRAY");
break;
case VT_USERDEFINED:
strRet = _T( "VT_USERDEFINED");
break;
case VT_LPSTR:
strRet = _T( "VT_LPSTR");
break;
case VT_LPWSTR:
strRet = _T( "VT_LPWSTR");
break;
case VT_FILETIME:
strRet = _T( "VT_FILETIME");
break;
case VT_BLOB:
strRet = _T( "VT_BLOB");
break;
case VT_STREAM:
strRet = _T( "VT_STREAM");
break;
case VT_STORAGE:
strRet = _T( "VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet = _T( "VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet = _T( "VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet = _T( "VT_BLOB_OBJECT");
break;
case VT_CF:
strRet = _T( "VT_CF");
break;
case VT_CLSID:
strRet = _T( "VT_CLSID");
break;
}
return strRet;
}
static void
ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
{
V_VT(var) = vt;
if (vt == (VT_VARIANT|VT_BYREF)) {
V_VARIANTREF(var) = realvar;
} else {
if (V_VT(realvar) != (vt & ~VT_BYREF)) {
rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
}
switch(vt & ~VT_BYREF) {
case VT_I1:
V_I1REF(var) = &V_I1(realvar);
break;
case VT_UI1:
V_UI1REF(var) = &V_UI1(realvar);
break;
case VT_I2:
V_I2REF(var) = &V_I2(realvar);
break;
case VT_UI2:
V_UI2REF(var) = &V_UI2(realvar);
break;
case VT_I4:
V_I4REF(var) = &V_I4(realvar);
break;
case VT_UI4:
V_UI4REF(var) = &V_UI4(realvar);
break;
case VT_R4:
V_R4REF(var) = &V_R4(realvar);
break;
case VT_R8:
V_R8REF(var) = &V_R8(realvar);
break;
#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
#ifdef V_I8REF
case VT_I8:
V_I8REF(var) = &V_I8(realvar);
break;
#endif
#ifdef V_UI8REF
case VT_UI8:
V_UI8REF(var) = &V_UI8(realvar);
break;
#endif
#endif
case VT_INT:
V_INTREF(var) = &V_INT(realvar);
break;
case VT_UINT:
V_UINTREF(var) = &V_UINT(realvar);
break;
case VT_CY:
V_CYREF(var) = &V_CY(realvar);
break;
case VT_DATE:
V_DATEREF(var) = &V_DATE(realvar);
break;
case VT_BSTR:
V_BSTRREF(var) = &V_BSTR(realvar);
break;
case VT_DISPATCH:
V_DISPATCHREF(var) = &V_DISPATCH(realvar);
break;
case VT_ERROR:
V_ERRORREF(var) = &V_ERROR(realvar);
break;
case VT_BOOL:
V_BOOLREF(var) = &V_BOOL(realvar);
break;
case VT_UNKNOWN:
V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
break;
case VT_ARRAY:
V_ARRAYREF(var) = &V_ARRAY(realvar);
break;
default:
rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
break;
}
}
}
// IPropertyBag
STDMETHODIMP SilverlightView::Read(LPCOLESTR pszPropName,
VARIANT* pVar,
IErrorLog* pErrorLog)
{
DCHECK(pVar);
if(!pVar)
{
return E_POINTER;
}
HRESULT hr = E_INVALIDARG;
size_t i;
for(i=0; i<props_.size(); ++i)
{
if(_wcsicmp(pszPropName, props_[i].name.c_str()) == 0)
{
break;
}
}
if(i < props_.size())
{
hr = S_OK;
switch(pVar->vt)
{
case VT_EMPTY:
case VT_BSTR:
V_VT(pVar)= VT_BSTR;
V_BSTR(pVar) = ::SysAllocString(props_[i].value.c_str());
break;
case VT_BOOL:
V_VT(pVar) = VT_BOOL;
V_BOOL(pVar) = ((_wcsicmp(L"true", props_[i].value.c_str()) == 0)
? VARIANT_TRUE : VARIANT_FALSE);
break;
case VT_I2:
case VT_UI2:
{
V_VT(pVar) = pVar->vt;
V_UI2(pVar) = static_cast<unsigned short>(
wcstoul(props_[i].value.c_str(), NULL, 0));
}
break;
case VT_I4:
case VT_UI4:
case VT_INT:
case VT_UINT:
{
V_VT(pVar) = pVar->vt;
V_UINT(pVar) = static_cast<unsigned int>(
wcstoul(props_[i].value.c_str(), NULL, 0));
}
break;
case VT_R4:
V_VT(pVar) = VT_R4;
V_R4(pVar) = static_cast<float>(wcstod(props_[i].value.c_str(), NULL));
break;
case VT_R8:
V_VT(pVar) = VT_R8;
V_R8(pVar) = static_cast<double>(wcstod(props_[i].value.c_str(), NULL));
break;
default:
hr = E_INVALIDARG;
break;
}
}
return hr;
}
static void test_VarFormatFromTokens(void)
{
static WCHAR number_fmt[] = {'#','#','#',',','#','#','0','.','0','0',0};
static const WCHAR number[] = {'6',',','9','0',0};
static const WCHAR number_us[] = {'6','9','0','.','0','0',0};
static WCHAR date_fmt[] = {'d','d','-','m','m',0};
static const WCHAR date[] = {'1','2','-','1','1',0};
static const WCHAR date_us[] = {'1','1','-','1','2',0};
static WCHAR string_fmt[] = {'@',0};
static const WCHAR string_de[] = {'1',',','5',0};
static const WCHAR string_us[] = {'1','.','5',0};
BYTE buff[256];
LCID lcid;
VARIANT var;
BSTR bstr;
HRESULT hres;
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(number);
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
hres = VarTokenizeFormatString(number_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, number_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, number_us), "incorrectly formatted number: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
lcid = MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT);
hres = VarTokenizeFormatString(number_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, number_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, number), "incorrectly formatted number: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
VariantClear(&var);
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = SysAllocString(date);
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
hres = VarTokenizeFormatString(date_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, date_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, date_us), "incorrectly formatted date: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
lcid = MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT);
hres = VarTokenizeFormatString(date_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, date_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, date), "incorrectly formatted date: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
VariantClear(&var);
V_VT(&var) = VT_R4;
V_R4(&var) = 1.5;
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
hres = VarTokenizeFormatString(string_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, string_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, string_us), "incorrectly formatted string: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
lcid = MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT);
hres = VarTokenizeFormatString(string_fmt, buff, sizeof(buff), 1, 1, lcid, NULL);
ok(hres == S_OK, "VarTokenizeFormatString failed: %x\n", hres);
hres = VarFormatFromTokens(&var, string_fmt, buff, 0, &bstr, lcid);
ok(hres == S_OK, "VarFormatFromTokens failed: %x\n", hres);
ok(!strcmpW(bstr, string_de), "incorrectly formatted string: %s\n", wine_dbgstr_w(bstr));
SysFreeString(bstr);
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
Z_TYPE_P(z) = IS_STRING;
Z_STRVAL_P(z) = php_com_olestring_to_string(olestring,
&Z_STRLEN_P(z), codepage TSRMLS_CC);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage TSRMLS_CC);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage TSRMLS_CC);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage TSRMLS_CC);
default:
php_com_wrap_variant(z, v, codepage TSRMLS_CC);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
bool
variant_as_string( DEBUGHELPER *pH, const VARIANT &var, std::string *ret )
{
if (var.vt & VT_VECTOR) return false;
if (var.vt & VT_RESERVED) return false;
if (var.vt & VT_ARRAY)
return safearray_as_string( pH, reinterpret_cast<DWORDLONG>(var.parray), ret);
if (var.vt & VT_BYREF)
{
// Construct a fake variant with the byref-value in it.
VARTYPE vt = var.vt & ~VT_BYREF;
long size = vartype_len(vt);
VARIANT var2;
var2.vt = vt;
long source=reinterpret_cast<long>(var.byref);
void *dest;
if( vt == VT_VARIANT)
dest = &var2;
else
{
var2.vt=vt;
dest = &(var2.bVal);
}
if(!ReadMem(pH,source, size, dest)) return false;
std::string retval;
if( ! variant_as_string( pH, var2, &retval)) return false;
retval += "]";
*ret = "[" + retval;
return true;
}
std::ostringstream os;
switch (var.vt & VT_TYPEMASK )
{
case VT_I2: os << V_I2(&var); break;
case VT_I4: os << V_I4(&var); break;
//case VT_I8: os << V_I8(&var); break;
case VT_R4: os << V_R4(&var); break;
case VT_R8: os << V_R8(&var); break;
case VT_UNKNOWN:
case VT_DISPATCH: os << "0x" << std::hex << (long )V_DISPATCH(&var); break;
case VT_BOOL: os << (V_BOOL(&var)==VARIANT_FALSE?"False":"True"); break;
case VT_I1: os << "'" << V_I1(&var) << "'" ; break;
case VT_UI1: os << "'" << V_UI1(&var) << "'" ; break;
case VT_UI2: os << V_UI2(&var); break;
case VT_UI4: os << V_UI4(&var); break;
case VT_INT: os << V_INT(&var); break;
case VT_UINT: os << V_UINT(&var); break;
case VT_ERROR: os << "error"; break;
case VT_CY: os << (((double)(V_CY(&var).int64))/10000.); break;
case VT_DATE: return date_as_string(V_DATE(&var), ret); break;
case VT_BSTR:
{
long pBSTR = reinterpret_cast<long>( V_BSTR(&var) );
// if (!ReadMem(pH, reinterpret_cast<DWORDLONG>( V_BSTR(&var) ), &pBSTR)) return false;
std::string ret;
if (!bstr_as_string( pH, pBSTR , &ret )) return false;
os << ret;
}break;
case VT_EMPTY: os << '@'; break;
case VT_NULL: os << "null"; break;
break;
default:
return false;
}
*ret = os.str();
return true;
}
HRESULT dhGetValueV(LPCWSTR szIdentifier, void * pResult, IDispatch * pDisp, LPCOLESTR szMember, va_list * marker)
{
VARIANT vtResult;
VARTYPE returnType;
HRESULT hr;
DH_ENTER(L"GetValueV");
if (!pResult || !szIdentifier) return DH_EXIT(E_INVALIDARG, szMember);
if (*szIdentifier == L'%') szIdentifier++;
switch(*szIdentifier)
{
case L'i': returnType = VT_I2; break;
case L'I': returnType = VT_UI2; break;
case L'r': returnType = VT_R4; break;
case L'd': returnType = VT_I4; break;
case L'u': returnType = VT_UI4; break;
case L'e': returnType = VT_R8; break;
case L'b': returnType = VT_BOOL; break;
case L'v': returnType = VT_EMPTY; break;
case L'B': returnType = VT_BSTR; break;
case L'S': returnType = VT_BSTR; break;
case L's': returnType = VT_BSTR; break;
case L'T': returnType = VT_BSTR; break;
case L'o': returnType = VT_DISPATCH; break;
case L'O': returnType = VT_UNKNOWN; break;
case L't': returnType = VT_DATE; break;
case L'W': returnType = VT_DATE; break;
case L'f': returnType = VT_DATE; break;
case L'D': returnType = VT_DATE; break;
#ifndef _WIN64
case L'p': returnType = VT_I4; break;
#else
case L'p': returnType = VT_I8; break;
#endif
default:
DEBUG_NOTIFY_INVALID_IDENTIFIER(*szIdentifier);
return DH_EXIT(E_INVALIDARG, szMember);
}
hr = dhInvokeV(DISPATCH_PROPERTYGET|DISPATCH_METHOD, returnType, &vtResult, pDisp, szMember, marker);
if (FAILED(hr)) return DH_EXIT(hr, szMember);
switch(*szIdentifier)
{
case L'i':
*((WORD *) pResult) = V_I2(&vtResult);
break;
case L'I':
*((WORD *) pResult) = V_UI2(&vtResult);
break;
case L'r':
*((FLOAT *) pResult) = V_R4(&vtResult);
break;
case L'd':
*((LONG *) pResult) = V_I4(&vtResult);
break;
case L'u':
*((ULONG *) pResult) = V_UI4(&vtResult);
break;
case L'e':
*((DOUBLE *) pResult) = V_R8(&vtResult);
break;
case L'b':
*((BOOL *) pResult) = V_BOOL(&vtResult);
break;
case L'v':
*((VARIANT *) pResult) = vtResult;
break;
case L'B':
*((BSTR *) pResult) = V_BSTR(&vtResult);
break;
case L'S':
*((LPWSTR *) pResult) = V_BSTR(&vtResult);
break;
case L's':
hr = ConvertBStrToAnsiStr(V_BSTR(&vtResult), (LPSTR *) pResult);
SysFreeString(V_BSTR(&vtResult));
break;
case L'T':
if (dh_g_bIsUnicodeMode)
{
*((LPWSTR *) pResult) = V_BSTR(&vtResult);
}
else
{
hr = ConvertBStrToAnsiStr(V_BSTR(&vtResult), (LPSTR *) pResult);
SysFreeString(V_BSTR(&vtResult));
}
break;
case L'o':
*((IDispatch **) pResult) = V_DISPATCH(&vtResult);
if (V_DISPATCH(&vtResult) == NULL) hr = E_NOINTERFACE;
break;
case L'O':
*((IUnknown **) pResult) = V_UNKNOWN(&vtResult);
if (V_UNKNOWN(&vtResult) == NULL) hr = E_NOINTERFACE;
break;
case L't':
hr = ConvertVariantTimeToTimeT(V_DATE(&vtResult), (time_t *) pResult);
break;
case L'W':
hr = ConvertVariantTimeToSystemTime(V_DATE(&vtResult), (SYSTEMTIME *) pResult);
break;
case L'f':
hr = ConvertVariantTimeToFileTime(V_DATE(&vtResult), (FILETIME *) pResult);
break;
case L'D':
*((DATE *) pResult) = V_DATE(&vtResult);
break;
case L'p':
#ifndef _WIN64
*((LPVOID *) pResult) = (LPVOID) V_I4(&vtResult);
#else
*((LPVOID *) pResult) = (LPVOID) V_I8(&vtResult);
#endif
break;
}
return DH_EXIT(hr, szMember);
}
