git.oblomov.eu Git - wine/blob - dlls/vbscript/vbdisp.c

   1 /*
   2  * Copyright 2011 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "vbscript.h"
  20
  21 #include "wine/debug.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  24
  25 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
  26 {
  27     return id < This->desc->func_cnt;
  28 }
  29
  30 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  31 {
  32     unsigned i;
  33
  34     for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) {
  35         if(invoke_type == VBDISP_ANY) {
  36             if(!search_private && !This->desc->funcs[i].is_public)
  37                 continue;
  38             if(!i && !This->desc->funcs[0].name) /* default value may not exist */
  39                 continue;
  40         }else {
  41             if(!This->desc->funcs[i].entries[invoke_type]
  42                 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
  43                 continue;
  44         }
  45
  46         if(!strcmpiW(This->desc->funcs[i].name, name)) {
  47             *id = i;
  48             return TRUE;
  49         }
  50     }
  51
  52     return FALSE;
  53 }
  54
  55 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  56 {
  57     unsigned i;
  58
  59     if(get_func_id(This, name, invoke_type, search_private, id))
  60         return S_OK;
  61
  62     for(i=0; i < This->desc->prop_cnt; i++) {
  63         if(!search_private && !This->desc->props[i].is_public)
  64             continue;
  65
  66         if(!strcmpiW(This->desc->props[i].name, name)) {
  67             *id = i + This->desc->func_cnt;
  68             return S_OK;
  69         }
  70     }
  71
  72     *id = -1;
  73     return DISP_E_UNKNOWNNAME;
  74 }
  75
  76 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
  77 {
  78     unsigned i;
  79
  80     for(i=0; i < dp->cNamedArgs; i++) {
  81         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
  82             return dp->rgvarg+i;
  83     }
  84
  85     return NULL;
  86 }
  87
  88 static HRESULT invoke_variant_prop(vbdisp_t *This, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
  89 {
  90     HRESULT hres;
  91
  92     switch(flags) {
  93     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
  94         if(dp->cArgs) {
  95             WARN("called with arguments\n");
  96             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
  97         }
  98
  99         hres = VariantCopy(res, v);
 100         break;
 101
 102     case DISPATCH_PROPERTYPUT: {
 103         VARIANT *put_val;
 104
 105         put_val = get_propput_arg(dp);
 106         if(!put_val) {
 107             WARN("no value to set\n");
 108             return DISP_E_PARAMNOTOPTIONAL;
 109         }
 110
 111         if(res)
 112             V_VT(res) = VT_EMPTY;
 113
 114         hres = VariantCopy(v, put_val);
 115         break;
 116     }
 117
 118     default:
 119         FIXME("unimplemented flags %x\n", flags);
 120         return E_NOTIMPL;
 121     }
 122
 123     return hres;
 124 }
 125
 126 static void run_terminator(vbdisp_t *This)
 127 {
 128     if(This->terminator_ran)
 129         return;
 130     This->terminator_ran = TRUE;
 131
 132     if(This->desc->class_terminate_id) {
 133         DISPPARAMS dp = {0};
 134
 135         This->ref++;
 136         exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
 137                 (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 138         This->ref--;
 139     }
 140
 141 }
 142
 143 static void clean_props(vbdisp_t *This)
 144 {
 145     unsigned i;
 146
 147     if(!This->desc)
 148         return;
 149
 150     for(i=0; i < This->desc->prop_cnt; i++)
 151         VariantClear(This->props+i);
 152 }
 153
 154 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 155 {
 156     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
 157 }
 158
 159 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 160 {
 161     vbdisp_t *This = impl_from_IDispatchEx(iface);
 162
 163     if(IsEqualGUID(&IID_IUnknown, riid)) {
 164         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 165         *ppv = &This->IDispatchEx_iface;
 166     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 167         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 168         *ppv = &This->IDispatchEx_iface;
 169     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 170         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 171         *ppv = &This->IDispatchEx_iface;
 172     }else {
 173         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 174         *ppv = NULL;
 175         return E_NOINTERFACE;
 176     }
 177
 178     IUnknown_AddRef((IUnknown*)*ppv);
 179     return S_OK;
 180 }
 181
 182 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 183 {
 184     vbdisp_t *This = impl_from_IDispatchEx(iface);
 185     LONG ref = InterlockedIncrement(&This->ref);
 186
 187     TRACE("(%p) ref=%d\n", This, ref);
 188
 189     return ref;
 190 }
 191
 192 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 193 {
 194     vbdisp_t *This = impl_from_IDispatchEx(iface);
 195     LONG ref = InterlockedDecrement(&This->ref);
 196
 197     TRACE("(%p) ref=%d\n", This, ref);
 198
 199     if(!ref)
 200         run_terminator(This);
 201     if(!ref) {
 202         clean_props(This);
 203         list_remove(&This->entry);
 204         heap_free(This);
 205     }
 206
 207     return ref;
 208 }
 209
 210 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 211 {
 212     vbdisp_t *This = impl_from_IDispatchEx(iface);
 213
 214     TRACE("(%p)->(%p)\n", This, pctinfo);
 215
 216     *pctinfo = 1;
 217     return S_OK;
 218 }
 219
 220 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 221                                               ITypeInfo **ppTInfo)
 222 {
 223     vbdisp_t *This = impl_from_IDispatchEx(iface);
 224     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 229                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 230                                                 DISPID *rgDispId)
 231 {
 232     vbdisp_t *This = impl_from_IDispatchEx(iface);
 233     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 234           lcid, rgDispId);
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 239                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 240                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 241 {
 242     vbdisp_t *This = impl_from_IDispatchEx(iface);
 243     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 244           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 249 {
 250     vbdisp_t *This = impl_from_IDispatchEx(iface);
 251
 252     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 253
 254     if(!This->desc)
 255         return E_UNEXPECTED;
 256
 257     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive)) {
 258         FIXME("unsupported flags %x\n", grfdex);
 259         return E_NOTIMPL;
 260     }
 261
 262     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
 263 }
 264
 265 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 266         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 267 {
 268     vbdisp_t *This = impl_from_IDispatchEx(iface);
 269
 270     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 271
 272     if(!This->desc)
 273         return E_UNEXPECTED;
 274
 275     if(pvarRes)
 276         V_VT(pvarRes) = VT_EMPTY;
 277
 278     if(id < 0)
 279         return DISP_E_MEMBERNOTFOUND;
 280
 281     if(is_func_id(This, id)) {
 282         function_t *func;
 283
 284         switch(wFlags) {
 285         case DISPATCH_METHOD:
 286         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 287             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 288             if(!func) {
 289                 FIXME("no invoke/getter\n");
 290                 return DISP_E_MEMBERNOTFOUND;
 291             }
 292
 293             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
 294         case DISPATCH_PROPERTYPUT: {
 295             VARIANT *put_val;
 296             DISPPARAMS dp = {NULL, NULL, 1, 0};
 297
 298             if(arg_cnt(pdp)) {
 299                 FIXME("arguments not implemented\n");
 300                 return E_NOTIMPL;
 301             }
 302
 303             put_val = get_propput_arg(pdp);
 304             if(!put_val) {
 305                 WARN("no value to set\n");
 306                 return DISP_E_PARAMNOTOPTIONAL;
 307             }
 308
 309             dp.rgvarg = put_val;
 310             func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
 311             if(!func) {
 312                 FIXME("no letter/setter\n");
 313                 return DISP_E_MEMBERNOTFOUND;
 314             }
 315
 316             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 317         }
 318         default:
 319             FIXME("flags %x\n", wFlags);
 320             return DISP_E_MEMBERNOTFOUND;
 321         }
 322     }
 323
 324     if(id < This->desc->prop_cnt + This->desc->func_cnt)
 325         return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
 326
 327     return DISP_E_MEMBERNOTFOUND;
 328 }
 329
 330 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 331 {
 332     vbdisp_t *This = impl_from_IDispatchEx(iface);
 333     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 338 {
 339     vbdisp_t *This = impl_from_IDispatchEx(iface);
 340     FIXME("(%p)->(%x)\n", This, id);
 341     return E_NOTIMPL;
 342 }
 343
 344 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 345 {
 346     vbdisp_t *This = impl_from_IDispatchEx(iface);
 347     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 352 {
 353     vbdisp_t *This = impl_from_IDispatchEx(iface);
 354     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 355     return E_NOTIMPL;
 356 }
 357
 358 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 359 {
 360     vbdisp_t *This = impl_from_IDispatchEx(iface);
 361     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 366 {
 367     vbdisp_t *This = impl_from_IDispatchEx(iface);
 368     FIXME("(%p)->(%p)\n", This, ppunk);
 369     return E_NOTIMPL;
 370 }
 371
 372 static IDispatchExVtbl DispatchExVtbl = {
 373     DispatchEx_QueryInterface,
 374     DispatchEx_AddRef,
 375     DispatchEx_Release,
 376     DispatchEx_GetTypeInfoCount,
 377     DispatchEx_GetTypeInfo,
 378     DispatchEx_GetIDsOfNames,
 379     DispatchEx_Invoke,
 380     DispatchEx_GetDispID,
 381     DispatchEx_InvokeEx,
 382     DispatchEx_DeleteMemberByName,
 383     DispatchEx_DeleteMemberByDispID,
 384     DispatchEx_GetMemberProperties,
 385     DispatchEx_GetMemberName,
 386     DispatchEx_GetNextDispID,
 387     DispatchEx_GetNameSpaceParent
 388 };
 389
 390 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 391 {
 392     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
 393         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
 394         : NULL;
 395 }
 396
 397 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 398 {
 399     vbdisp_t *vbdisp;
 400
 401     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
 402     if(!vbdisp)
 403         return E_OUTOFMEMORY;
 404
 405     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 406     vbdisp->ref = 1;
 407     vbdisp->desc = desc;
 408
 409     if(desc->class_initialize_id) {
 410         DISPPARAMS dp = {0};
 411         HRESULT hres;
 412
 413         hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
 414                            (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
 415         if(FAILED(hres)) {
 416             IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
 417             return hres;
 418         }
 419     }
 420
 421     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 422     *ret = vbdisp;
 423     return S_OK;
 424 }
 425
 426 void collect_objects(script_ctx_t *ctx)
 427 {
 428     vbdisp_t *iter, *iter2;
 429
 430     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
 431         run_terminator(iter);
 432
 433     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry) {
 434         clean_props(iter);
 435         iter->desc = NULL;
 436     }
 437 }
 438
 439 HRESULT init_global(script_ctx_t *ctx)
 440 {
 441     ctx->script_desc.ctx = ctx;
 442     return create_vbdisp(&ctx->script_desc, &ctx->script_obj);
 443 }
 444
 445 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
 446 {
 447     IDispatchEx *dispex;
 448     vbdisp_t *vbdisp;
 449     HRESULT hres;
 450
 451     vbdisp = unsafe_impl_from_IDispatch(disp);
 452     if(vbdisp)
 453         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
 454
 455     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 456     if(FAILED(hres)) {
 457         TRACE("unsing IDispatch\n");
 458         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 459     }
 460
 461     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
 462     IDispatchEx_Release(dispex);
 463     return hres;
 464 }
 465
 466 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
 467 {
 468     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
 469     IDispatchEx *dispex;
 470     EXCEPINFO ei;
 471     HRESULT hres;
 472
 473     memset(&ei, 0, sizeof(ei));
 474     if(retv)
 475         V_VT(retv) = VT_EMPTY;
 476
 477     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 478     if(FAILED(hres)) {
 479         UINT err = 0;
 480
 481         TRACE("using IDispatch\n");
 482         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
 483     }
 484
 485     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
 486     IDispatchEx_Release(dispex);
 487     return hres;
 488 }
 489
 490 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val)
 491 {
 492     DISPID propput_dispid = DISPID_PROPERTYPUT;
 493     DISPPARAMS dp  = {val, &propput_dispid, 1, 1};
 494     IDispatchEx *dispex;
 495     EXCEPINFO ei = {0};
 496     HRESULT hres;
 497
 498     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 499     if(SUCCEEDED(hres)) {
 500         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL /* FIXME! */);
 501         IDispatchEx_Release(dispex);
 502     }else {
 503         ULONG err = 0;
 504
 505         TRACE("using IDispatch\n");
 506         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, &err);
 507     }
 508
 509     return hres;
 510 }