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; } }
tstring QueryRunner::formatValue(const WCL::Variant& value, const tstring& format) { try { tstring formattedValue = TXT("<unknown format>"); if (format == Formats::STRING) { formattedValue = value.format(); } else if (format == Formats::DATETIME) { if (!tryConvertDateTime(WCL::getValue<tstring>(value), formattedValue)) formattedValue = TXT("<non-datetime value>"); } else if (format == Formats::BYTES) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value)) + TXT(" B"); } else if (format == Formats::K_BYTES) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value) / 1024u) + TXT(" KB"); } else if (format == Formats::M_BYTES) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value) / (1024u*1024u)) + TXT(" MB"); } else if (format == Formats::G_BYTES) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value) / (1024u*1024u*1024u)) + TXT(" GB"); } else if (format == Formats::KB_AS_MB) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value) / 1024u) + TXT(" MB"); } else if (format == Formats::KB_AS_GB) { WCL::Variant uint64Value(value, VT_UI8); formattedValue = formatIntegerValue(V_UI8(&uint64Value) / (1024u*1024u)) + TXT(" GB"); } return formattedValue; } catch (const WCL::ComException& /*e*/) { return TXT("#VAL"); } }
static inline HRESULT add_prop_ull_as_str( IDxDiagContainer* cont, LPCWSTR prop, ULONGLONG data ) { HRESULT hr; VARIANT var; V_VT( &var ) = VT_UI8; V_UI8( &var ) = data; VariantChangeType( &var, &var, 0, VT_BSTR ); hr = IDxDiagContainerImpl_AddProp( cont, prop, &var ); VariantClear( &var ); return hr; }
static void setWindowText(HWND dialog, UINT field, IPropertyBagPtr statistics, const _bstr_t& key) { VARIANT var; ::VariantInit(&var); V_VT(&var) = VT_UI8; if (FAILED(statistics->Read(key, &var, 0))) { ::VariantClear(&var); return; } unsigned long long value = V_UI8(&var); String valueStr = WTF::String::number(value); setWindowText(dialog, field, _bstr_t(valueStr.utf8().data())); ::VariantClear(&var); }
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; } } }
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; }
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; }
HRESULT CContextPlugin::WriteContextInformation( HANDLE hFile, IWMSContext *pContext ) { HRESULT hr = S_OK; ContextNameHint *pContextHintValues = NULL; DWORD nValue = 0; WMS_CONTEXT_TYPE wmsContextType = WMS_UNKNOWN_CONTEXT_TYPE; WCHAR wstrBuffer[MAX_PATH]; DWORD cbWritten = 0; DWORD dwRet = 0; if( NULL == pContext ) { // There is no Context, nothing to write return( hr ); } hr = pContext->GetContextType( &wmsContextType ); if( FAILED( hr ) ) { return( hr ); } ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) ); switch( wmsContextType ) { case WMS_USER_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_USER_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_UserContextHintValues); break; case WMS_PRESENTATION_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer, MAX_PATH,CONTEXT_SAMPLE_PRESENTATION_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_PresentationContextHintValues); break; case WMS_COMMAND_REQUEST_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_REQUEST_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues); break; case WMS_COMMAND_RESPONSE_CONTEXT_TYPE: // Create a header for this context type wcsncpy_s( wstrBuffer,MAX_PATH, CONTEXT_SAMPLE_COMMAND_RESPONSE_CONTEXT_HEADER, MAX_PATH ); pContextHintValues = const_cast<ContextNameHint *>(CContextPlugin::s_CommandContextHintValues); break; } if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) ) { dwRet = GetLastError(); hr = HRESULT_FROM_WIN32( dwRet ); // Failed to write the header should we still continue // No! return( hr ); } if( NULL == pContextHintValues ) { return( E_UNEXPECTED ); } // Now we loop until -1 and Write the data while( ( NULL != pContextHintValues[nValue].wstrContextName ) && ( -1 != pContextHintValues[nValue].lContextHint ) ) { VARIANT varValue; VariantInit( &varValue ); ZeroMemory( wstrBuffer, MAX_PATH * sizeof( WCHAR ) ); hr = pContext->GetValue( pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, &varValue, 0 ); if( SUCCEEDED( hr ) ) { // Write string with data information switch( V_VT( &varValue ) ) { case VT_BSTR: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_BSTR_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_BSTR( &varValue ) ); break; case VT_I4: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_I4_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_I4( &varValue ), V_I4( &varValue ) ); break; case VT_UI8: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UI8_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UI8( &varValue ) ); break; case VT_CY: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_CY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_CY( &varValue ) ); break; case VT_DATE: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DATE_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DATE( &varValue ) ); break; case VT_DECIMAL: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DECIMAL_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DECIMAL( &varValue ) ); break; case VT_UNKNOWN: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_UNKNOWN_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_UNKNOWN( &varValue ) ); break; case VT_DISPATCH: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_DISPATCH_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_DISPATCH( &varValue ) ); break; default: _snwprintf_s( wstrBuffer,MAX_PATH, MAX_PATH, CONTEXT_SAMPLE_ARRAY_TYPE_STRING, pContextHintValues[nValue].wstrContextName, pContextHintValues[nValue].lContextHint, V_ARRAY( &varValue ) ); break; } if( !::WriteFile( hFile, (LPVOID) wstrBuffer, DWORD(wcslen( wstrBuffer ) * sizeof( WCHAR )), &cbWritten, NULL ) ) { dwRet = GetLastError(); hr = HRESULT_FROM_WIN32( dwRet ); } } else { // Value probably didn't exist for this event, don't worry about it // good place to put breakpoint hr = S_OK; } // It doesn't hurt to do a VariantClear on an Empty Variant, this way we won't leak anything. VariantClear( &varValue ); nValue ++; } return( hr ); }
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); } }