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;
}
