bool CXmlUtil::SetTextCDATA(const XMLDOMDocumentPtr& doc, const XMLDOMElementPtr& ele, const wchar_t* value) { bool bRet = false; VARIANT_BOOL bHasChild; LocalHResult hr; if (doc != NULL && ele != NULL) { if (SUCCEEDED(hr = ele->hasChildNodes(&bHasChild)) && bHasChild) { XMLDOMNodePtr pCDATA, pNewNode; hr = ele->get_firstChild(&pCDATA); hr = ele->removeChild(pCDATA, &pNewNode); } VARIANT type; V_VT(&type) = VT_INT; V_INT(&type) = XML::NODE_CDATA_SECTION; XMLDOMNodePtr pCDATA = NULL; hr = doc->createNode(type, NULL, NULL, &pCDATA); if (pCDATA != NULL) { hr = pCDATA->put_text(_bstr_t(value)); bRet = SUCCEEDED(hr = ele->appendChild(pCDATA, NULL)); } } return bRet; }
HRESULT variant_to_jsval(VARIANT *var, jsval_t *r) { 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; str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var))); if(!str) return E_OUTOFMEMORY; if(!V_BSTR(var)) str->length_flags |= JSSTR_FLAG_NULLBSTR; *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_INT: *r = jsval_number(V_INT(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; } } /* fall through */ default: return jsval_variant(r, var); } }
bool CXmlUtil::NewXMLFile(XMLDOMDocumentPtr& doc, const wchar_t* pszRootName, const wchar_t* pszEncoding, const wchar_t* pszNameSpace, const wchar_t* comment) { LocalHResult hr; doc = NULL; if (FAILED(hr = doc.CreateInstance(CLSID_XmlDocument60)) && FAILED(hr = doc.CreateInstance(CLSID_XmlDocument40))) { #ifdef X3LOG_WARNING2 X3LOG_WARNING2(L"@ConfigXml:IDS_CREATEINSTANCE_FAIL", L"CLSID_XmlDocument"); #endif return false; } XMLDOMNodePtr pDocNode (doc); std::wstring strHeader = L"version=\"1.0\" encoding=\""; strHeader += pszEncoding; strHeader += L"\""; XMLDOMProcessingInstructionPtr pHeader; hr = doc->createProcessingInstruction( _bstr_t(L"xml"), _bstr_t(strHeader.c_str()), &pHeader); hr = pDocNode->appendChild(pHeader, NULL); if (IsNotEmpty(comment)) { XMLDOMComment* pComment = NULL; hr = doc->createComment(_bstr_t(comment), &pComment); if (pComment != NULL) { hr = doc->appendChild(XMLDOMNodePtr(pComment), NULL); pComment->Release(); } } // Create root node if (IsNotEmpty(pszRootName)) { VARIANT type; V_VT(&type) = VT_INT; V_INT(&type) = XML::NODE_ELEMENT; XMLDOMNodePtr pRoot; hr = doc->createNode(type, _bstr_t(pszRootName), _bstr_t(pszNameSpace), &pRoot); hr = pDocNode->appendChild(pRoot, NULL); } return true; }
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; }
/******************************************************************* * GAMEUX_updateStatisticsFile * * Helper function updating data stored in statistics file * * Parameters: * data [I] pointer to struct containing * statistics data */ static HRESULT GAMEUX_updateStatisticsFile(struct GAMEUX_STATS *stats) { static const WCHAR sStatistics[] = {'S','t','a','t','i','s','t','i','c','s',0}; static const WCHAR sCategory[] = {'C','a','t','e','g','o','r','y',0}; static const WCHAR sIndex[] = {'I','n','d','e','x',0}; static const WCHAR sStatistic[] = {'S','t','a','t','i','s','t','i','c',0}; static const WCHAR sName[] = {'N','a','m','e',0}; static const WCHAR sValue[] = {'V','a','l','u','e',0}; HRESULT hr = S_OK; IXMLDOMDocument *document; IXMLDOMElement *root, *categoryElement, *statisticsElement; IXMLDOMNode *categoryNode, *statisticsNode; VARIANT vStatsFilePath, vValue; BSTR bstrStatistics = NULL, bstrCategory = NULL, bstrIndex = NULL, bstrStatistic = NULL, bstrName = NULL, bstrValue = NULL; int i, j; TRACE("(%p)\n", stats); V_VT(&vStatsFilePath) = VT_BSTR; V_BSTR(&vStatsFilePath) = SysAllocString(stats->sStatsFile); if(!V_BSTR(&vStatsFilePath)) hr = E_OUTOFMEMORY; if(SUCCEEDED(hr)) hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&document); if(SUCCEEDED(hr)) { bstrStatistics = SysAllocString(sStatistics); if(!bstrStatistics) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) hr = IXMLDOMDocument_createElement(document, bstrStatistics, &root); if(SUCCEEDED(hr)) { bstrCategory = SysAllocString(sCategory); if(!bstrCategory) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { bstrIndex = SysAllocString(sIndex); if(!bstrIndex) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { bstrStatistic = SysAllocString(sStatistic); if(!bstrStatistic) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { bstrName = SysAllocString(sName); if(!bstrName) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { bstrValue = SysAllocString(sValue); if(!bstrValue) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) for(i=0; i<MAX_CATEGORIES; ++i) { if(lstrlenW(stats->categories[i].sName)==0) continue; V_VT(&vValue) = VT_INT; V_INT(&vValue) = NODE_ELEMENT; hr = IXMLDOMDocument_createNode(document, vValue, bstrCategory, NULL, &categoryNode); if(SUCCEEDED(hr)) hr = IXMLDOMNode_QueryInterface(categoryNode, &IID_IXMLDOMElement, (LPVOID*)&categoryElement); V_INT(&vValue) = i; if(SUCCEEDED(hr)) hr = IXMLDOMElement_setAttribute(categoryElement, bstrIndex, vValue); if(SUCCEEDED(hr)) { V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = SysAllocString(stats->categories[i].sName); if(!V_BSTR(&vValue)) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { TRACE("storing category %d: %s\n", i, debugstr_w(V_BSTR(&vValue))); hr = IXMLDOMElement_setAttribute(categoryElement, bstrName, vValue); } SysFreeString(V_BSTR(&vValue)); if(SUCCEEDED(hr)) { for(j=0; j<MAX_STATS_PER_CATEGORY; ++j) { if(lstrlenW(stats->categories[i].stats[j].sName)==0) continue; V_VT(&vValue) = VT_INT; V_INT(&vValue) = NODE_ELEMENT; hr = IXMLDOMDocument_createNode(document, vValue, bstrStatistic, NULL, &statisticsNode); if(SUCCEEDED(hr)) hr = IXMLDOMNode_QueryInterface(statisticsNode, &IID_IXMLDOMElement, (LPVOID*)&statisticsElement); V_INT(&vValue) = j; if(SUCCEEDED(hr)) hr = IXMLDOMElement_setAttribute(statisticsElement, bstrIndex, vValue); if(SUCCEEDED(hr)) { V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sName); if(!V_BSTR(&vValue)) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue))); hr = IXMLDOMElement_setAttribute(statisticsElement, bstrName, vValue); } SysFreeString(V_BSTR(&vValue)); if(SUCCEEDED(hr)) { V_VT(&vValue) = VT_BSTR; V_BSTR(&vValue) = SysAllocString(stats->categories[i].stats[j].sValue); if(!V_BSTR(&vValue)) hr = E_OUTOFMEMORY; } if(SUCCEEDED(hr)) { TRACE(" storing statistic %d: name: %s\n", j, debugstr_w(V_BSTR(&vValue))); hr = IXMLDOMElement_setAttribute(statisticsElement, bstrValue, vValue); } SysFreeString(V_BSTR(&vValue)); if(SUCCEEDED(hr)) hr = IXMLDOMNode_appendChild(categoryNode, statisticsNode, &statisticsNode); IXMLDOMElement_Release(statisticsElement); IXMLDOMNode_Release(statisticsNode); } } if(SUCCEEDED(hr)) hr = IXMLDOMElement_appendChild(root, categoryNode, &categoryNode); IXMLDOMElement_Release(categoryElement); IXMLDOMNode_Release(categoryNode); if(FAILED(hr)) break; } if(SUCCEEDED(hr)) hr = IXMLDOMDocument_putref_documentElement(document, root); IXMLDOMElement_Release(root); TRACE("saving game statistics in %s file\n", debugstr_w(stats->sStatsFile)); if(SUCCEEDED(hr)) hr = GAMEUX_createStatsDirectory(stats->sStatsFile); if(SUCCEEDED(hr)) hr = IXMLDOMDocument_save(document, vStatsFilePath); IXMLDOMDocument_Release(document); SysFreeString(bstrValue); SysFreeString(bstrName); SysFreeString(bstrStatistic); SysFreeString(bstrIndex); SysFreeString(bstrCategory); SysFreeString(bstrStatistics); SysFreeString(V_BSTR(&vStatsFilePath)); TRACE("ret=0x%x\n", hr); return hr; }
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; } } }
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; }
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; }
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; }
void SMTPServersNT( CCFXRequest* pRequest ) { USES_CONVERSION; #ifdef _DEBUG CString tmp; pRequest->Write("DEBUGGING: ENTRY: SMTPServersNT<br>"); #endif // fields CCFXStringSet* pColumns = pRequest->CreateStringSet(); int iServer = pColumns->AddString( "Server" ); int iState = pColumns->AddString( "State" ); int iDescription = pColumns->AddString( "Description" ); int iBindings = pColumns->AddString( "Bindings" ); int iVersion = pColumns->AddString( "Version" ); int iMessageSizeLimit = pColumns->AddString( "MessageSizeLimit" ); int iSessionSizeLimit = pColumns->AddString( "SessionSizeLimit" ); int iMessagesPerConnectionLimit = pColumns->AddString( "MessagesPerConnectionLimit" ); int iRecipientsPerMessageLimit = pColumns->AddString( "RecipientsPerMessageLimit" ); int iBadMailDirectory = pColumns->AddString( "BadMailDirectory" ); int iNonDeliveryMailTo = pColumns->AddString( "NonDeliveryMailTo" ); int iBadMailTo = pColumns->AddString( "BadMailTo" ); int iRetryInterval = pColumns->AddString( "RetryInterval" ); int iDelayNotification = pColumns->AddString( "DelayNotification" ); int iExpirationTimeout = pColumns->AddString( "ExpirationTimeout" ); int iHopCount = pColumns->AddString( "HopCount" ); int iMasqueradeDomain = pColumns->AddString( "MasqueradeDomain" ); int iFullyQualifiedDomainName = pColumns->AddString( "FullyQualifiedDomainName" ); int iSmartHost = pColumns->AddString( "SmartHost" ); int iEnableReverseDnsLookup = pColumns->AddString( "EnableReverseDnsLookup" ); CCFXQuery* pQuery = pRequest->AddQuery( get_query_variable(), pColumns ); // optional CString strinComputer = pRequest->GetAttribute( "COMPUTER" ); pRequest->SetVariable( "IISComputer", strinComputer ); CString computer; if( strinComputer.IsEmpty() ) computer="LocalHost"; else computer=strinComputer; // HRESULT hr,hr2,hrw; CString pathe; // pathe.Format("IIS://%s/SmtpSVC",computer); #ifdef _DEBUG tmp.Format("DEBUGGING: Trying container %s...<br>",pathe); pRequest->Write(tmp); #endif IADsContainer *pContainer=NULL; hr=ADsGetObject(A2W(pathe), IID_IADsContainer, (void**)&pContainer); log_COMError(__LINE__,hr); // if(SUCCEEDED(hr)) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif #ifdef _DEBUG pRequest->Write("DEBUGGING: enumerating container...<br>"); #endif // IEnumVARIANT *pEnum=NULL; hrw = ADsBuildEnumerator(pContainer, &pEnum); log_COMError(__LINE__,hrw); // hr2=pContainer->Release(); log_COMError(__LINE__,hr2); // if(SUCCEEDED(hrw)) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // VARIANT var; ULONG ulElements=1; // while ( (SUCCEEDED(hrw)) && (ulElements==1) ) { #ifdef _DEBUG tmp.Format("DEBUGGING: enumerating %d elements...<br>",ulElements); pRequest->Write(tmp); #endif // hrw = ADsEnumerateNext(pEnum, 1, &var, &ulElements); log_COMError(__LINE__,hrw); // if(SUCCEEDED(hrw) && (ulElements==1) ) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // CString strServer; CString strState; CString strDescription; CString strBindings; CString strVersion; CString strMessageSizeLimit; CString strSessionSizeLimit; CString strMessagesPerConnectionLimit; CString strRecipientsPerMessageLimit; CString strBadMailDirectory; CString strNonDeliveryMailTo; CString strBadMailTo; CString strRetryInterval; CString strDelayNotification; CString strExpirationTimeout; CString strHopCount; CString strMasqueradeDomain; CString strFullyQualifiedDomainName; CString strSmartHost; CString strEnableReverseDnsLookup; // IADs *pADs=(IADs*)var.pdispVal; // BSTR bstrName; hr2 = pADs->get_Name(&bstrName); log_COMError(__LINE__,hr2); if(SUCCEEDED(hr2)) strServer=bstrName; BSTR bstrClass; hr2 = pADs->get_Class(&bstrClass); log_COMError(__LINE__,hr2); CString strClass; if(SUCCEEDED(hr2)) strClass=bstrClass; #ifdef _DEBUG tmp.Format("DEBUGGING: server %s class %s...<br>",strServer,strClass); pRequest->Write(tmp); #endif // if(strClass.Compare("IIsSmtpServer")==0) { #ifdef _DEBUG pRequest->Write("DEBUGGING: success<br>"); #endif // VARIANT var; VariantInit(&var); // hr2 = pADs->Get(L"ServerState",&var); if(SUCCEEDED(hr2)) { switch(V_INT(&var)) { case MD_SERVER_STATE_STARTING: strState="Starting"; break; case MD_SERVER_STATE_STARTED: strState="Started"; break; case MD_SERVER_STATE_STOPPING: strState="Stopping"; break; case MD_SERVER_STATE_STOPPED: strState="Stopped"; break; case MD_SERVER_STATE_PAUSING: strState="Pausing"; break; case MD_SERVER_STATE_PAUSED: strState="Paused"; break; case MD_SERVER_STATE_CONTINUING: strState="Continuing"; break; default: strState="Unknown"; } } VariantClear(&var); hr2 = pADs->Get(L"ServerComment",&var); if(SUCCEEDED(hr2)) strDescription = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"ServerBindings",&var); if(SUCCEEDED(hr2)) { VARIANTARRAYtoCString(var,strBindings,pRequest,';'); } VariantClear(&var); hr2 = pADs->Get(L"SmtpServiceVersion",&var); if(SUCCEEDED(hr2)) strVersion.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxMessageSize",&var); if(SUCCEEDED(hr2)) strMessageSizeLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxSessionSize",&var); if(SUCCEEDED(hr2)) strSessionSizeLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxBatchedMessages",&var); if(SUCCEEDED(hr2)) strMessagesPerConnectionLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MaxRecipients",&var); if(SUCCEEDED(hr2)) strRecipientsPerMessageLimit.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"BadMailDirectory",&var); if(SUCCEEDED(hr2)) strBadMailDirectory = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SendNdrTo",&var); if(SUCCEEDED(hr2)) strNonDeliveryMailTo = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SendBadTo",&var); if(SUCCEEDED(hr2)) strBadMailTo = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmtpRemoteProgressiveRetry",&var); if(SUCCEEDED(hr2)) strRetryInterval = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmtpLocalDelayExpireMinutes",&var); if(SUCCEEDED(hr2)) strDelayNotification.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"SmtpLocalNDRExpireMinutes",&var); if(SUCCEEDED(hr2)) strExpirationTimeout.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"HopCount",&var); if(SUCCEEDED(hr2)) strHopCount.Format("%d",V_INT(&var)); VariantClear(&var); hr2 = pADs->Get(L"MasqueradeDomain",&var); if(SUCCEEDED(hr2)) strMasqueradeDomain = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"FullyQualifiedDomainName",&var); if(SUCCEEDED(hr2)) strFullyQualifiedDomainName = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"SmartHost",&var); if(SUCCEEDED(hr2)) strSmartHost = V_BSTR(&var) ; VariantClear(&var); hr2 = pADs->Get(L"EnableReverseDnsLookup",&var); if(SUCCEEDED(hr2)) strEnableReverseDnsLookup.Format("%d",abs(V_BOOL(&var))); VariantClear(&var); // int iRow = pQuery->AddRow(); pQuery->SetData( iRow, iServer, strServer ); pQuery->SetData( iRow, iState, strState ); pQuery->SetData( iRow, iDescription, strDescription ); pQuery->SetData( iRow, iBindings, strBindings ); pQuery->SetData( iRow, iVersion, strVersion ); pQuery->SetData( iRow, iMessageSizeLimit, strMessageSizeLimit ); pQuery->SetData( iRow, iSessionSizeLimit, strSessionSizeLimit ); pQuery->SetData( iRow, iMessagesPerConnectionLimit, strMessagesPerConnectionLimit ); pQuery->SetData( iRow, iRecipientsPerMessageLimit, strRecipientsPerMessageLimit ); pQuery->SetData( iRow, iBadMailDirectory, strBadMailDirectory ); pQuery->SetData( iRow, iNonDeliveryMailTo, strNonDeliveryMailTo ); pQuery->SetData( iRow, iBadMailTo, strBadMailTo ); pQuery->SetData( iRow, iRetryInterval, strRetryInterval ); pQuery->SetData( iRow, iDelayNotification, strDelayNotification ); pQuery->SetData( iRow, iExpirationTimeout, strExpirationTimeout ); pQuery->SetData( iRow, iHopCount, strHopCount ); pQuery->SetData( iRow, iMasqueradeDomain, strMasqueradeDomain ); pQuery->SetData( iRow, iFullyQualifiedDomainName, strFullyQualifiedDomainName ); pQuery->SetData( iRow, iSmartHost, strSmartHost ); pQuery->SetData( iRow, iEnableReverseDnsLookup, strEnableReverseDnsLookup ); } // hr2=pADs->Release(); log_COMError(__LINE__,hr2); // SysFreeString(bstrClass); SysFreeString(bstrName); } } } // hr2 = ADsFreeEnumerator(pEnum); log_COMError(__LINE__,hr2); } #ifdef _DEBUG pRequest->Write("DEBUGGING: EXIT: SMTPServersNT<br>"); #endif }
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); } }