| /* |
| * 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 < sizeof(args)/sizeof(*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 = sizeof(procedure_props)/sizeof(*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; |
| } |
