/* * Copyright 2011 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <assert.h> #include "vbscript.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(vbscript); #define FDEX_VERSION_MASK 0xf0000000 static inline BOOL is_func_id(vbdisp_t *This, DISPID id) { return id < This->desc->func_cnt; } static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id) { unsigned i; for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) { if(invoke_type == VBDISP_ANY) { if(!search_private && !This->desc->funcs[i].is_public) continue; if(!i && !This->desc->funcs[0].name) /* default value may not exist */ continue; }else { if(!This->desc->funcs[i].entries[invoke_type] || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public)) continue; } if(!strcmpiW(This->desc->funcs[i].name, name)) { *id = i; return TRUE; } } return FALSE; } HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id) { unsigned i; if(get_func_id(This, name, invoke_type, search_private, id)) return S_OK; for(i=0; i < This->desc->prop_cnt; i++) { if(!search_private && !This->desc->props[i].is_public) continue; if(!strcmpiW(This->desc->props[i].name, name)) { *id = i + This->desc->func_cnt; return S_OK; } } if(This->desc->typeinfo) { HRESULT hres; hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id); if(SUCCEEDED(hres)) return S_OK; } *id = -1; return DISP_E_UNKNOWNNAME; } static HRESULT get_propput_arg(script_ctx_t *ctx, const DISPPARAMS *dp, WORD flags, VARIANT *v, BOOL *is_owned) { unsigned i; for(i=0; i < dp->cNamedArgs; i++) { if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT) break; } if(i == dp->cNamedArgs) { WARN("no value to set\n"); return DISP_E_PARAMNOTOPTIONAL; } *v = dp->rgvarg[i]; if(V_VT(v) == (VT_VARIANT|VT_BYREF)) *v = *V_VARIANTREF(v); *is_owned = FALSE; if(V_VT(v) == VT_DISPATCH) { if(!(flags & DISPATCH_PROPERTYPUTREF)) { HRESULT hres; hres = get_disp_value(ctx, V_DISPATCH(v), v); if(FAILED(hres)) return hres; *is_owned = TRUE; } }else if(!(flags & DISPATCH_PROPERTYPUT)) { WARN("%s can't be assigned without DISPATCH_PROPERTYPUT flag\n", debugstr_variant(v)); return DISP_E_EXCEPTION; } return S_OK; } static HRESULT invoke_variant_prop(script_ctx_t *ctx, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res) { HRESULT hres; switch(flags) { case DISPATCH_PROPERTYGET|DISPATCH_METHOD: case DISPATCH_PROPERTYGET: if(dp->cArgs) { WARN("called with arguments\n"); return DISP_E_MEMBERNOTFOUND; /* That's what tests show */ } hres = VariantCopyInd(res, v); break; case DISPATCH_PROPERTYPUT: case DISPATCH_PROPERTYPUTREF: case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: { VARIANT put_val; BOOL own_val; hres = get_propput_arg(ctx, dp, flags, &put_val, &own_val); if(FAILED(hres)) return hres; if(arg_cnt(dp)) { FIXME("Arguments not supported\n"); return E_NOTIMPL; } if(res) V_VT(res) = VT_EMPTY; if(own_val) *v = put_val; else hres = VariantCopyInd(v, &put_val); break; } default: FIXME("unimplemented flags %x\n", flags); return E_NOTIMPL; } return hres; } static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res) { VARIANT args[8]; unsigned argn, i; switch(flags) { case DISPATCH_PROPERTYGET: if(!(prop->flags & (BP_GET|BP_GETPUT))) { FIXME("property does not support DISPATCH_PROPERTYGET\n"); return E_FAIL; } break; case DISPATCH_PROPERTYGET|DISPATCH_METHOD: if(!prop->proc && prop->flags == BP_GET) { const int vt = prop->min_args, val = prop->max_args; switch(vt) { case VT_I2: V_VT(res) = VT_I2; V_I2(res) = val; break; case VT_I4: V_VT(res) = VT_I4; V_I4(res) = val; break; case VT_BSTR: { const string_constant_t *str = (const string_constant_t*)prop->max_args; BSTR ret; ret = SysAllocStringLen(str->buf, str->len); if(!ret) return E_OUTOFMEMORY; V_VT(res) = VT_BSTR; V_BSTR(res) = ret; break; } DEFAULT_UNREACHABLE; } return S_OK; } break; case DISPATCH_METHOD: if(prop->flags & (BP_GET|BP_GETPUT)) { FIXME("Call on property\n"); return E_FAIL; } break; case DISPATCH_PROPERTYPUT: if(!(prop->flags & BP_GETPUT)) { FIXME("property does not support DISPATCH_PROPERTYPUT\n"); return E_FAIL; } FIXME("call put\n"); return E_NOTIMPL; default: FIXME("unsupported flags %x\n", flags); return E_NOTIMPL; } argn = arg_cnt(dp); if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) { FIXME("invalid number of arguments\n"); return E_FAIL; } assert(argn < ARRAY_SIZE(args)); for(i=0; i < argn; i++) { if(V_VT(dp->rgvarg+dp->cArgs-i-1) == (VT_BYREF|VT_VARIANT)) args[i] = *V_VARIANTREF(dp->rgvarg+dp->cArgs-i-1); else args[i] = dp->rgvarg[dp->cArgs-i-1]; } return prop->proc(This, args, dp->cArgs, res); } static BOOL run_terminator(vbdisp_t *This) { DISPPARAMS dp = {0}; if(This->terminator_ran) return TRUE; This->terminator_ran = TRUE; if(!This->desc->class_terminate_id) return TRUE; This->ref++; exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET], This, &dp, NULL); return !--This->ref; } static void clean_props(vbdisp_t *This) { unsigned i; if(!This->desc) return; for(i=0; i < This->desc->array_cnt; i++) { if(This->arrays[i]) { SafeArrayDestroy(This->arrays[i]); This->arrays[i] = NULL; } } for(i=0; i < This->desc->prop_cnt; i++) VariantClear(This->props+i); } static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface) { return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface); } static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) { vbdisp_t *This = impl_from_IDispatchEx(iface); if(IsEqualGUID(&IID_IUnknown, riid)) { TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else if(IsEqualGUID(&IID_IDispatch, riid)) { TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else if(IsEqualGUID(&IID_IDispatchEx, riid)) { TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else { WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); *ppv = NULL; return E_NOINTERFACE; } IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface) { vbdisp_t *This = impl_from_IDispatchEx(iface); LONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); return ref; } static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface) { vbdisp_t *This = impl_from_IDispatchEx(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref && run_terminator(This)) { clean_props(This); list_remove(&This->entry); heap_free(This->arrays); heap_free(This); } return ref; } static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo) { vbdisp_t *This = impl_from_IDispatchEx(iface); TRACE("(%p)->(%p)\n", This, pctinfo); *pctinfo = 1; return S_OK; } static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { vbdisp_t *This = impl_from_IDispatchEx(iface); TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, NULL); } static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid) { vbdisp_t *This = impl_from_IDispatchEx(iface); TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid); grfdex &= ~FDEX_VERSION_MASK; if(!This->desc) return E_UNEXPECTED; /* Tests show that fdexNameCaseSensitive is ignored */ if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive|fdexNameCaseSensitive)) { FIXME("unsupported flags %x\n", grfdex); return E_NOTIMPL; } return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid); } static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { vbdisp_t *This = impl_from_IDispatchEx(iface); TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); if(!This->desc) return E_UNEXPECTED; if(pvarRes) V_VT(pvarRes) = VT_EMPTY; if(id < 0) return DISP_E_MEMBERNOTFOUND; if(is_func_id(This, id)) { function_t *func; switch(wFlags) { case DISPATCH_PROPERTYGET: func = This->desc->funcs[id].entries[VBDISP_CALLGET]; if(!func || (func->type != FUNC_PROPGET && func->type != FUNC_DEFGET)) { WARN("no getter\n"); return DISP_E_MEMBERNOTFOUND; } return exec_script(This->desc->ctx, func, This, pdp, pvarRes); case DISPATCH_METHOD: case DISPATCH_METHOD|DISPATCH_PROPERTYGET: func = This->desc->funcs[id].entries[VBDISP_CALLGET]; if(!func) { FIXME("no invoke/getter\n"); return DISP_E_MEMBERNOTFOUND; } return exec_script(This->desc->ctx, func, This, pdp, pvarRes); case DISPATCH_PROPERTYPUT: case DISPATCH_PROPERTYPUTREF: case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: { DISPPARAMS dp = {NULL, NULL, 1, 0}; BOOL needs_release; VARIANT put_val; HRESULT hres; if(arg_cnt(pdp)) { FIXME("arguments not implemented\n"); return E_NOTIMPL; } hres = get_propput_arg(This->desc->ctx, pdp, wFlags, &put_val, &needs_release); if(FAILED(hres)) return hres; dp.rgvarg = &put_val; func = This->desc->funcs[id].entries[V_VT(&put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET]; if(!func) { FIXME("no letter/setter\n"); return DISP_E_MEMBERNOTFOUND; } hres = exec_script(This->desc->ctx, func, This, &dp, NULL); if(needs_release) VariantClear(&put_val); return hres; } default: FIXME("flags %x\n", wFlags); return DISP_E_MEMBERNOTFOUND; } } if(id < This->desc->prop_cnt + This->desc->func_cnt) return invoke_variant_prop(This->desc->ctx, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes); if(This->desc->builtin_prop_cnt) { unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i; while(min <= max) { i = (min+max)/2; if(This->desc->builtin_props[i].id == id) return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes); if(This->desc->builtin_props[i].id < id) min = i+1; else max = i-1; } } return DISP_E_MEMBERNOTFOUND; } static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%x)\n", This, id); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%x %p)\n", This, id, pbstrName); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid); return E_NOTIMPL; } static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk) { vbdisp_t *This = impl_from_IDispatchEx(iface); FIXME("(%p)->(%p)\n", This, ppunk); return E_NOTIMPL; } static IDispatchExVtbl DispatchExVtbl = { DispatchEx_QueryInterface, DispatchEx_AddRef, DispatchEx_Release, DispatchEx_GetTypeInfoCount, DispatchEx_GetTypeInfo, DispatchEx_GetIDsOfNames, DispatchEx_Invoke, DispatchEx_GetDispID, DispatchEx_InvokeEx, DispatchEx_DeleteMemberByName, DispatchEx_DeleteMemberByDispID, DispatchEx_GetMemberProperties, DispatchEx_GetMemberName, DispatchEx_GetNextDispID, DispatchEx_GetNameSpaceParent }; static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface) { return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface) : NULL; } HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret) { vbdisp_t *vbdisp; HRESULT hres = S_OK; vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] )); if(!vbdisp) return E_OUTOFMEMORY; vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl; vbdisp->ref = 1; vbdisp->desc = desc; list_add_tail(&desc->ctx->objects, &vbdisp->entry); if(desc->array_cnt) { vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays)); if(vbdisp->arrays) { unsigned i, j; for(i=0; i < desc->array_cnt; i++) { if(!desc->array_descs[i].dim_cnt) continue; vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds); if(!vbdisp->arrays[i]) { hres = E_OUTOFMEMORY; break; } } if(SUCCEEDED(hres)) { for(i=0, j=0; i < desc->prop_cnt; i++) { if(desc->props[i].is_array) { V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT; V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++; } } } }else { hres = E_OUTOFMEMORY; } } if(SUCCEEDED(hres) && desc->class_initialize_id) { DISPPARAMS dp = {0}; hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET], vbdisp, &dp, NULL); } if(FAILED(hres)) { IDispatchEx_Release(&vbdisp->IDispatchEx_iface); return hres; } *ret = vbdisp; return S_OK; } static HRESULT Procedure_invoke(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res) { script_ctx_t *ctx = This->desc->ctx; HRESULT hres; TRACE("\n"); IActiveScriptSite_OnEnterScript(ctx->site); hres = exec_script(ctx, This->desc->value_func, NULL, NULL, NULL); IActiveScriptSite_OnLeaveScript(ctx->site); return hres; } static const builtin_prop_t procedure_props[] = { {DISPID_VALUE, Procedure_invoke, 0} }; HRESULT create_procedure_disp(script_ctx_t *ctx, vbscode_t *code, IDispatch **ret) { class_desc_t *desc; vbdisp_t *vbdisp; HRESULT hres; desc = heap_alloc_zero(sizeof(*desc)); if(!desc) return E_OUTOFMEMORY; desc->ctx = ctx; desc->builtin_prop_cnt = ARRAY_SIZE(procedure_props); desc->builtin_props = procedure_props; desc->value_func = &code->main_code; hres = create_vbdisp(desc, &vbdisp); if(FAILED(hres)) { heap_free(desc); return hres; } desc->next = ctx->procs; ctx->procs = desc; *ret = (IDispatch*)&vbdisp->IDispatchEx_iface; return S_OK; } struct _ident_map_t { const WCHAR *name; BOOL is_var; union { dynamic_var_t *var; function_t *func; } u; }; static inline DISPID ident_to_id(ScriptDisp *This, ident_map_t *ident) { return (ident-This->ident_map)+1; } static inline ident_map_t *id_to_ident(ScriptDisp *This, DISPID id) { return 0 < id && id <= This->ident_map_cnt ? This->ident_map+id-1 : NULL; } static ident_map_t *add_ident(ScriptDisp *This, const WCHAR *name) { ident_map_t *ret; if(!This->ident_map_size) { This->ident_map = heap_alloc(4 * sizeof(*This->ident_map)); if(!This->ident_map) return NULL; This->ident_map_size = 4; }else if(This->ident_map_cnt == This->ident_map_size) { ident_map_t *new_map; new_map = heap_realloc(This->ident_map, 2*This->ident_map_size*sizeof(*new_map)); if(!new_map) return NULL; This->ident_map = new_map; This->ident_map_size *= 2; } ret = This->ident_map + This->ident_map_cnt++; ret->name = name; return ret; } static inline ScriptDisp *ScriptDisp_from_IDispatchEx(IDispatchEx *iface) { return CONTAINING_RECORD(iface, ScriptDisp, IDispatchEx_iface); } static HRESULT WINAPI ScriptDisp_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); if(IsEqualGUID(&IID_IUnknown, riid)) { TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else if(IsEqualGUID(&IID_IDispatch, riid)) { TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else if(IsEqualGUID(&IID_IDispatchEx, riid)) { TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv); *ppv = &This->IDispatchEx_iface; }else { WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv); *ppv = NULL; return E_NOINTERFACE; } IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } static ULONG WINAPI ScriptDisp_AddRef(IDispatchEx *iface) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); LONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); return ref; } static ULONG WINAPI ScriptDisp_Release(IDispatchEx *iface) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { assert(!This->ctx); heap_free(This->ident_map); heap_free(This); } return ref; } static HRESULT WINAPI ScriptDisp_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); TRACE("(%p)->(%p)\n", This, pctinfo); *pctinfo = 1; return S_OK; } static HRESULT WINAPI ScriptDisp_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_GetIDsOfNames(IDispatchEx *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); UINT i; HRESULT hres; TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId); for(i=0; i < cNames; i++) { hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i); if(FAILED(hres)) return hres; } return S_OK; } static HRESULT WINAPI ScriptDisp_Invoke(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid), lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr); return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, NULL); } static HRESULT WINAPI ScriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); dynamic_var_t *var; ident_map_t *ident; function_t *func; TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid); if(!This->ctx) return E_UNEXPECTED; for(ident = This->ident_map; ident < This->ident_map+This->ident_map_cnt; ident++) { if(!strcmpiW(ident->name, bstrName)) { *pid = ident_to_id(This, ident); return S_OK; } } for(var = This->ctx->global_vars; var; var = var->next) { if(!strcmpiW(var->name, bstrName)) { ident = add_ident(This, var->name); if(!ident) return E_OUTOFMEMORY; ident->is_var = TRUE; ident->u.var = var; *pid = ident_to_id(This, ident); return S_OK; } } for(func = This->ctx->global_funcs; func; func = func->next) { if(!strcmpiW(func->name, bstrName)) { ident = add_ident(This, func->name); if(!ident) return E_OUTOFMEMORY; ident->is_var = FALSE; ident->u.func = func; *pid = ident_to_id(This, ident); return S_OK; } } *pid = -1; return DISP_E_UNKNOWNNAME; } static HRESULT WINAPI ScriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp, VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); ident_map_t *ident; HRESULT hres; TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller); ident = id_to_ident(This, id); if(!ident) return DISP_E_MEMBERNOTFOUND; if(ident->is_var) { if(ident->u.var->is_const) { FIXME("const not supported\n"); return E_NOTIMPL; } return invoke_variant_prop(This->ctx, &ident->u.var->v, wFlags, pdp, pvarRes); } switch(wFlags) { case DISPATCH_METHOD: case DISPATCH_METHOD|DISPATCH_PROPERTYGET: IActiveScriptSite_OnEnterScript(This->ctx->site); hres = exec_script(This->ctx, ident->u.func, NULL, pdp, pvarRes); IActiveScriptSite_OnLeaveScript(This->ctx->site); break; default: FIXME("Unsupported flags %x\n", wFlags); hres = E_NOTIMPL; } return hres; } static HRESULT WINAPI ScriptDisp_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_DeleteMemberByDispID(IDispatchEx *iface, DISPID id) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%x)\n", This, id); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%x %p)\n", This, id, pbstrName); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid); return E_NOTIMPL; } static HRESULT WINAPI ScriptDisp_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk) { ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface); FIXME("(%p)->(%p)\n", This, ppunk); return E_NOTIMPL; } static IDispatchExVtbl ScriptDispVtbl = { ScriptDisp_QueryInterface, ScriptDisp_AddRef, ScriptDisp_Release, ScriptDisp_GetTypeInfoCount, ScriptDisp_GetTypeInfo, ScriptDisp_GetIDsOfNames, ScriptDisp_Invoke, ScriptDisp_GetDispID, ScriptDisp_InvokeEx, ScriptDisp_DeleteMemberByName, ScriptDisp_DeleteMemberByDispID, ScriptDisp_GetMemberProperties, ScriptDisp_GetMemberName, ScriptDisp_GetNextDispID, ScriptDisp_GetNameSpaceParent }; HRESULT create_script_disp(script_ctx_t *ctx, ScriptDisp **ret) { ScriptDisp *script_disp; script_disp = heap_alloc_zero(sizeof(*script_disp)); if(!script_disp) return E_OUTOFMEMORY; script_disp->IDispatchEx_iface.lpVtbl = &ScriptDispVtbl; script_disp->ref = 1; script_disp->ctx = ctx; *ret = script_disp; return S_OK; } void collect_objects(script_ctx_t *ctx) { vbdisp_t *iter, *iter2; LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry) run_terminator(iter); while(!list_empty(&ctx->objects)) { iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry); IDispatchEx_AddRef(&iter->IDispatchEx_iface); clean_props(iter); iter->desc = NULL; list_remove(&iter->entry); list_init(&iter->entry); IDispatchEx_Release(&iter->IDispatchEx_iface); } } HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id) { IDispatchEx *dispex; vbdisp_t *vbdisp; HRESULT hres; vbdisp = unsafe_impl_from_IDispatch(disp); if(vbdisp) return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id); hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { TRACE("using IDispatch\n"); return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id); } hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id); IDispatchEx_Release(dispex); return hres; } #define RPC_E_SERVER_UNAVAILABLE 0x800706ba HRESULT map_hres(HRESULT hres) { if(SUCCEEDED(hres) || HRESULT_FACILITY(hres) == FACILITY_VBS) return hres; switch(hres) { case E_NOTIMPL: return MAKE_VBSERROR(VBSE_ACTION_NOT_SUPPORTED); case E_NOINTERFACE: return MAKE_VBSERROR(VBSE_OLE_NOT_SUPPORTED); case DISP_E_UNKNOWNINTERFACE: return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD); case DISP_E_MEMBERNOTFOUND: return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD); case DISP_E_PARAMNOTFOUND: return MAKE_VBSERROR(VBSE_NAMED_PARAM_NOT_FOUND); case DISP_E_TYPEMISMATCH: return MAKE_VBSERROR(VBSE_TYPE_MISMATCH); case DISP_E_UNKNOWNNAME: return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD); case DISP_E_NONAMEDARGS: return MAKE_VBSERROR(VBSE_NAMED_ARGS_NOT_SUPPORTED); case DISP_E_BADVARTYPE: return MAKE_VBSERROR(VBSE_INVALID_TYPELIB_VARIABLE); case DISP_E_OVERFLOW: return MAKE_VBSERROR(VBSE_OVERFLOW); case DISP_E_BADINDEX: return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS); case DISP_E_UNKNOWNLCID: return MAKE_VBSERROR(VBSE_LOCALE_SETTING_NOT_SUPPORTED); case DISP_E_ARRAYISLOCKED: return MAKE_VBSERROR(VBSE_ARRAY_LOCKED); case DISP_E_BADPARAMCOUNT: return MAKE_VBSERROR(VBSE_FUNC_ARITY_MISMATCH); case DISP_E_PARAMNOTOPTIONAL: return MAKE_VBSERROR(VBSE_PARAMETER_NOT_OPTIONAL); case DISP_E_NOTACOLLECTION: return MAKE_VBSERROR(VBSE_NOT_ENUM); case TYPE_E_DLLFUNCTIONNOTFOUND: return MAKE_VBSERROR(VBSE_INVALID_DLL_FUNCTION_NAME); case TYPE_E_TYPEMISMATCH: return MAKE_VBSERROR(VBSE_TYPE_MISMATCH); case TYPE_E_OUTOFBOUNDS: return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS); case TYPE_E_IOERROR: return MAKE_VBSERROR(VBSE_IO_ERROR); case TYPE_E_CANTCREATETMPFILE: return MAKE_VBSERROR(VBSE_CANT_CREATE_TMP_FILE); case STG_E_FILENOTFOUND: return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND); case STG_E_PATHNOTFOUND: return MAKE_VBSERROR(VBSE_PATH_NOT_FOUND); case STG_E_TOOMANYOPENFILES: return MAKE_VBSERROR(VBSE_TOO_MANY_FILES); case STG_E_ACCESSDENIED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case STG_E_INSUFFICIENTMEMORY: return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY); case STG_E_NOMOREFILES: return MAKE_VBSERROR(VBSE_TOO_MANY_FILES); case STG_E_DISKISWRITEPROTECTED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case STG_E_WRITEFAULT: return MAKE_VBSERROR(VBSE_IO_ERROR); case STG_E_READFAULT: return MAKE_VBSERROR(VBSE_IO_ERROR); case STG_E_SHAREVIOLATION: return MAKE_VBSERROR(VBSE_PATH_FILE_ACCESS); case STG_E_LOCKVIOLATION: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case STG_E_FILEALREADYEXISTS: return MAKE_VBSERROR(VBSE_FILE_ALREADY_EXISTS); case STG_E_MEDIUMFULL: return MAKE_VBSERROR(VBSE_DISK_FULL); case STG_E_INVALIDNAME: return MAKE_VBSERROR(VBSE_FILE_NOT_FOUND); case STG_E_INUSE: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case STG_E_NOTCURRENT: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case STG_E_CANTSAVE: return MAKE_VBSERROR(VBSE_IO_ERROR); case REGDB_E_CLASSNOTREG: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); case MK_E_UNAVAILABLE: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); case MK_E_INVALIDEXTENSION: return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND); case MK_E_CANTOPENFILE: return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND); case CO_E_CLASSSTRING: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); case CO_E_APPNOTFOUND: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); case CO_E_APPDIDNTREG: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); case E_ACCESSDENIED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED); case E_OUTOFMEMORY: return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY); case E_INVALIDARG: return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL); case RPC_E_SERVER_UNAVAILABLE: return MAKE_VBSERROR(VBSE_SERVER_NOT_FOUND); case CO_E_SERVER_EXEC_FAILURE: return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT); } return hres; } HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv) { const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0); IDispatchEx *dispex; EXCEPINFO ei; HRESULT hres; memset(&ei, 0, sizeof(ei)); if(retv) V_VT(retv) = VT_EMPTY; hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(FAILED(hres)) { UINT err = 0; TRACE("using IDispatch\n"); return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err); } hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */); IDispatchEx_Release(dispex); return hres; } HRESULT get_disp_value(script_ctx_t *ctx, IDispatch *disp, VARIANT *v) { DISPPARAMS dp = {NULL}; return disp_call(ctx, disp, DISPID_VALUE, &dp, v); } HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp) { IDispatchEx *dispex; EXCEPINFO ei = {0}; HRESULT hres; hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex); if(SUCCEEDED(hres)) { hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, NULL, &ei, NULL /* FIXME! */); IDispatchEx_Release(dispex); }else { ULONG err = 0; TRACE("using IDispatch\n"); hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err); } return hres; }