static LONG get_var_int(const VARIANT *var) { switch(V_VT(var)) { case VT_I1: case VT_UI1: return V_UI1(var); case VT_I2: case VT_UI2: return V_UI2(var); case VT_I4: case VT_UI4: return V_UI4(var); case VT_I8: case VT_UI8: return V_UI8(var); case VT_INT: case VT_UINT: return V_UINT(var); default: FIXME("unsupported variant type %d\n", V_VT(var)); return 0; } }
DWORD COcsWmi::dwCimValue(VARIANT &pVal, CIMTYPE &pType) { if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY)) return 0; else switch (pType) { case CIM_SINT8: return V_I1(&pVal); case CIM_UINT8: return V_UI1(&pVal); case CIM_SINT16: return V_I2(&pVal); case CIM_UINT16: return V_UI2(&pVal); case CIM_SINT32: return V_I4(&pVal); case CIM_UINT32: return V_UI4(&pVal); case CIM_BOOLEAN: return (V_BOOL(&pVal) ? 1 : 0); default: return 0; } }
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; } } }
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; } } }
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; }
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; }
// 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; }
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 HRESULT ExtractArgument(VARIANT * pvArg, WCHAR chIdentifier, BOOL * pbFreeArg, va_list * marker) { HRESULT hr = NOERROR; *pbFreeArg = FALSE; if (chIdentifier == L'T') chIdentifier = (dh_g_bIsUnicodeMode ? L'S' : L's'); switch (chIdentifier) { case L'i': V_VT(pvArg) = VT_I2; V_I2(pvArg) = va_arg(*marker, WORD); break; case L'I': V_VT(pvArg) = VT_UI2; V_UI2(pvArg) = va_arg(*marker, WORD); break; case L'd': V_VT(pvArg) = VT_I4; V_I4(pvArg) = va_arg(*marker, LONG); break; case L'u': V_VT(pvArg) = VT_UI4; V_UI4(pvArg) = va_arg(*marker, ULONG); break; case L'e': V_VT(pvArg) = VT_R8; V_R8(pvArg) = *va_arg(*marker, DOUBLE *); break; case L'r': V_VT(pvArg) = VT_R4; V_R4(pvArg) = *va_arg(*marker, FLOAT *); break; case L'b': V_VT(pvArg) = VT_BOOL; V_BOOL(pvArg) = ( va_arg(*marker, BOOL) ? VARIANT_TRUE : VARIANT_FALSE ); break; case L'v': *pvArg = *va_arg(*marker, VARIANT *); break; case L'm': V_VT(pvArg) = VT_ERROR; V_ERROR(pvArg) = DISP_E_PARAMNOTFOUND; break; case L'B': V_VT(pvArg) = VT_BSTR; V_BSTR(pvArg) = va_arg(*marker, BSTR); break; case L'S': { LPOLESTR szTemp = va_arg(*marker, LPOLESTR); V_VT(pvArg) = VT_BSTR; V_BSTR(pvArg) = SysAllocString(szTemp); if (V_BSTR(pvArg) == NULL && szTemp != NULL) hr = E_OUTOFMEMORY; *pbFreeArg = TRUE; break; } case L's': V_VT(pvArg) = VT_BSTR; hr = ConvertAnsiStrToBStr(va_arg(*marker, LPSTR), &V_BSTR(pvArg)); *pbFreeArg = TRUE; break; case L'o': V_VT(pvArg) = VT_DISPATCH; V_DISPATCH(pvArg) = va_arg(*marker, IDispatch *); break; case L'O': V_VT(pvArg) = VT_UNKNOWN; V_UNKNOWN(pvArg) = va_arg(*marker, IUnknown *); break; case L'D': V_VT(pvArg) = VT_DATE; V_DATE(pvArg) = *va_arg(*marker, DATE *); break; case L't': V_VT(pvArg) = VT_DATE; hr = ConvertTimeTToVariantTime(va_arg(*marker, time_t), &V_DATE(pvArg)); break; case L'W': V_VT(pvArg) = VT_DATE; hr = ConvertSystemTimeToVariantTime(va_arg(*marker, SYSTEMTIME *), &V_DATE(pvArg)); break; case L'f': V_VT(pvArg) = VT_DATE; hr = ConvertFileTimeToVariantTime(va_arg(*marker, FILETIME *), &V_DATE(pvArg)); break; case L'p': #ifndef _WIN64 V_VT(pvArg) = VT_I4; V_I4(pvArg) = (LONG) va_arg(*marker, LPVOID); #else V_VT(pvArg) = VT_I8; V_I8(pvArg) = (LONGLONG) va_arg(*marker, LPVOID); #endif break; default: hr = E_INVALIDARG; DEBUG_NOTIFY_INVALID_IDENTIFIER(chIdentifier); break; } return hr; }
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; }
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); } }
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; }
unsigned __int64 COcsWmi::u64CimValue(VARIANT &pVal, CIMTYPE &pType) { CString csResult; if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY)) return 0; else switch (pType) { case CIM_SINT8: return V_I1(&pVal); case CIM_UINT8: return V_UI1(&pVal); case CIM_SINT16: return V_I2(&pVal); case CIM_UINT16: return V_UI2(&pVal); case CIM_SINT32: return V_I4(&pVal); case CIM_UINT32: return V_UI4(&pVal); case CIM_SINT64: csResult = V_BSTR(&pVal); return _ttoi64( csResult); case CIM_UINT64: csResult = V_BSTR(&pVal); return _ttoi64( csResult); case CIM_BOOLEAN: return (V_BOOL(&pVal) ? 1 : 0); default: return 0; } }
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); }