STDMETHODIMP CBasic::inoutSequenceObject(LPSAFEARRAY* val) { HRESULT hr = S_OK; SAFEARRAY *arTemp = NULL; if (FAILED(hr = SafeArrayCopy(*val, &arTemp))) return hr; if (FAILED(hr = SafeArrayCopy(m_arObject, val))) return hr; m_arObject = arTemp; return hr; }
/* The array contains VARIANT according to IDL. If the VARIANTs contain strings then we append "out" to each string. */ STDMETHODIMP CBasic::inoutArray(LPSAFEARRAY *val) { SAFEARRAY* aAr = NULL; HRESULT hr = S_OK; if (FAILED(hr = SafeArrayCopy(*val, &aAr))) return hr; if (FAILED(hr = SafeArrayCopy(m_safearray, val))) return hr; if (FAILED(hr = SafeArrayCopy(aAr, & m_safearray))) return hr; return S_OK; }
STDMETHODIMP CBasic::outArray(LPSAFEARRAY *val) { HRESULT hr = S_OK; if (FAILED(hr = SafeArrayCopy(m_safearray, val))) return false; return S_OK; }
STDMETHODIMP CPyCOMTest::GetLastVarArgs(SAFEARRAY **result) { if (result==NULL) return E_POINTER; if (!pLastArray) return E_FAIL; return SafeArrayCopy(pLastArray, result); }
bool com_array_reader::convert(VARIANT * pVarSrc) { reset(); if (!pVarSrc) return false; if ((pVarSrc->vt & VT_ARRAY) && pVarSrc->parray) { return (SUCCEEDED(SafeArrayCopy(pVarSrc->parray, &m_psa))); } else if ((pVarSrc->vt & VT_TYPEMASK) == VT_DISPATCH) { IDispatch * pdisp = pVarSrc->pdispVal; if (pVarSrc->vt & VT_BYREF) { pdisp = *(pVarSrc->ppdispVal); } if (pdisp) { // {3EEF9758-35FC-11D1-8CE4-00C04FC2B092} //const GUID guid_array_instance = //{ 0x3eef9758, 0x35fc, 0x11d1, { 0x8c, 0xe4, 0x00, 0xc0, 0x4f, 0xc2, 0xb0, 0x92 } }; return convert_jsarray(pdisp); } } return false; }
STDMETHODIMP CPyCOMTest::SetVarArgs(SAFEARRAY *vararg) { if (pLastArray) { SafeArrayDestroy(pLastArray); pLastArray = NULL; } return SafeArrayCopy(vararg, &pLastArray); }
STDMETHODIMP CBasic::put_prpArray(LPSAFEARRAY newVal) { HRESULT hr = S_OK; if (FAILED(hr = SafeArrayDestroy( m_PrpArray))) return hr; if (FAILED(hr = SafeArrayCopy( newVal, &m_PrpArray))) return hr; return hr; }
STDMETHODIMP CBasic::get_prpArray(LPSAFEARRAY *pVal) { if( !pVal) return E_POINTER; HRESULT hr = S_OK; if (FAILED(hr = SafeArrayCopy( m_PrpArray, pVal))) return hr; return hr; }
STDMETHODIMP CBasic::inArray(LPSAFEARRAY val) { HRESULT hr = S_OK; if (FAILED(hr = SafeArrayDestroy(m_safearray))) return hr; if (FAILED(hr = SafeArrayCopy(val, &m_safearray))) return hr; return S_OK; }
STDMETHODIMP CBasic::inSequenceObject(LPSAFEARRAY val) { HRESULT hr = S_OK; if (FAILED(hr = SafeArrayDestroy(m_arObject))) return hr; if (FAILED(hr = SafeArrayCopy(val, & m_arObject))) return hr; return hr; }
STDMETHODIMP CBasic::inMulDimArrayByte(LPSAFEARRAY val) { HRESULT hr = S_OK; if (FAILED(hr = SafeArrayDestroy(m_arByteDim2))) return hr; if (FAILED(hr = SafeArrayCopy(val, & m_arByteDim2))) return hr; return hr; }
/* val2 contains the variable argument list. If no such arguments are supplied then the safearray is invalid. SafeArrayCopy then returns E_INVALIDARG */ STDMETHODIMP CBasic::varargfunc1(/*[in]*/ long val1,/*[in]*/ LPSAFEARRAY val2) { m_long = val1; HRESULT hr = S_OK; if (FAILED(hr = SafeArrayDestroy(m_safearray))) return hr; if (FAILED(hr = SafeArrayCopy(val2, & m_safearray))) { if (hr != E_INVALIDARG) return hr; } return S_OK; }
HRESULT create_vbarray(script_ctx_t *ctx, SAFEARRAY *sa, jsdisp_t **ret) { VBArrayInstance *vbarray; HRESULT hres; hres = alloc_vbarray(ctx, NULL, &vbarray); if(FAILED(hres)) return hres; hres = SafeArrayCopy(sa, &vbarray->safearray); if(FAILED(hres)) { jsdisp_release(&vbarray->dispex); return hres; } *ret = &vbarray->dispex; return S_OK; }
static HRESULT VBArrayConstr_value(script_ctx_t *ctx, vdisp_t *vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r) { VBArrayInstance *vbarray; HRESULT hres; TRACE("\n"); switch(flags) { case DISPATCH_METHOD: if(argc<1 || !is_variant(argv[0]) || V_VT(get_variant(argv[0])) != (VT_ARRAY|VT_VARIANT)) return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL); return jsval_copy(argv[0], r); case DISPATCH_CONSTRUCT: if(argc<1 || !is_variant(argv[0]) || V_VT(get_variant(argv[0])) != (VT_ARRAY|VT_VARIANT)) return throw_type_error(ctx, JS_E_VBARRAY_EXPECTED, NULL); hres = alloc_vbarray(ctx, NULL, &vbarray); if(FAILED(hres)) return hres; hres = SafeArrayCopy(V_ARRAY(get_variant(argv[0])), &vbarray->safearray); if(FAILED(hres)) { jsdisp_release(&vbarray->dispex); return hres; } *r = jsval_obj(&vbarray->dispex); break; default: FIXME("unimplemented flags: %x\n", flags); return E_NOTIMPL; } return S_OK; }
STDMETHODIMP C_ECBLoader::get_Styles(STRING_ARRAY *pVal) { if (!pVal) { return E_POINTER; } try { if (*pVal) { SafeArrayDestroy(*pVal); } int len = styles.GetLength(); SAFEARRAYBOUND rgsabound[] = { len, 0 }; SAFEARRAY* psa = SafeArrayCreate(VT_BSTR, 1, rgsabound); BSTR *bs; SafeArrayAccessData(psa, (LPVOID*)&bs); for (int n = 0; n < len; n++) { *bs++ = styles[n]->toBSTR(); } SafeArrayUnaccessData(psa); SafeArrayCopy(psa, pVal); SafeArrayDestroy(psa); } catch (C_STLNonStackException const &exception) { exception.Log(_T("Exception in C_ECBLoader::get_Styles")); } return S_OK; }
STDMETHODIMP CBasic::outSequenceObject(LPSAFEARRAY* val) { HRESULT hr = S_OK; hr = SafeArrayCopy(m_arObject, val); return S_OK; }
STDMETHODIMP CBasic::outSequenceDouble(LPSAFEARRAY* val) { HRESULT hr= S_OK; hr = SafeArrayCopy(m_arDouble, val); return hr; }
STDMETHODIMP CBasic::outSequenceFloat(LPSAFEARRAY* val) { HRESULT hr= S_OK; hr = SafeArrayCopy(m_arFloat, val); return hr; }
STDMETHODIMP CBasic::varargfunc2(/*[out]*/ long* val1, /*[out]*/ SAFEARRAY ** val2) { *val1 = m_long; HRESULT hr = SafeArrayCopy(m_safearray, val2); return hr; }
static HRESULT WINAPI IRecordInfoImpl_RecordCopy(IRecordInfo *iface, PVOID pvExisting, PVOID pvNew) { IRecordInfoImpl *This = impl_from_IRecordInfo(iface); HRESULT hr = S_OK; int i; TRACE("(%p)->(%p %p)\n", This, pvExisting, pvNew); if(!pvExisting || !pvNew) return E_INVALIDARG; /* release already stored data */ IRecordInfo_RecordClear(iface, pvNew); for (i = 0; i < This->n_vars; i++) { void *src, *dest; if (This->fields[i].varkind != VAR_PERINSTANCE) { ERR("varkind != VAR_PERINSTANCE\n"); continue; } src = ((BYTE*)pvExisting) + This->fields[i].offset; dest = ((BYTE*)pvNew) + This->fields[i].offset; switch (This->fields[i].vt) { case VT_BSTR: { BSTR src_str = *(BSTR*)src; if (src_str) { BSTR str = SysAllocString(*(BSTR*)src); if (!str) hr = E_OUTOFMEMORY; *(BSTR*)dest = str; } else *(BSTR*)dest = NULL; break; } case VT_UNKNOWN: case VT_DISPATCH: { IUnknown *unk = *(IUnknown**)src; *(IUnknown**)dest = unk; if (unk) IUnknown_AddRef(unk); break; } case VT_SAFEARRAY: hr = SafeArrayCopy(src, dest); break; default: { /* copy directly for types that don't need deep copy */ int len = get_type_size(NULL, This->fields[i].vt); memcpy(dest, src, len); break; } } if (FAILED(hr)) break; } if (FAILED(hr)) IRecordInfo_RecordClear(iface, pvNew); return hr; }
STDMETHODIMP CBasic::outSequenceString(LPSAFEARRAY* val) { HRESULT hr= S_OK; hr = SafeArrayCopy(m_arString, val); return hr; }