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;
}
}
const char *debugstr_variant(const VARIANT *v)
{
if(!v)
return "(null)";
switch(V_VT(v)) {
case VT_EMPTY:
return "{VT_EMPTY}";
case VT_NULL:
return "{VT_NULL}";
case VT_I1:
return wine_dbg_sprintf("{VT_I1: %d}", V_I1(v));
case VT_I2:
return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v));
case VT_I4:
return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
case VT_INT:
return wine_dbg_sprintf("{VT_INT: %d}", V_INT(v));
case VT_R8:
return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
case VT_BSTR:
return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
case VT_DISPATCH:
return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
case VT_BOOL:
return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
case VT_UNKNOWN:
return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v));
case VT_UINT:
return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v));
case VT_BSTR|VT_BYREF:
return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}",
V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL));
case VT_ERROR:
return wine_dbg_sprintf("{VT_ERROR: 0x%08x}", V_ERROR(v));
case VT_VARIANT|VT_BYREF:
return wine_dbg_sprintf("{VT_VARIANT|VT_BYREF: %s}", debugstr_variant(V_VARIANTREF(v)));
case VT_UI1|VT_ARRAY:
return "{VT_UI1|VT_ARRAY}";
default:
return wine_dbg_sprintf("{vt %d}", V_VT(v));
}
}
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;
}
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;
}
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;
}
}
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;
}
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);
}
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 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;
}
