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     if(This->desc->typeinfo) {
  73         HRESULT hres;
  74
  75         hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id);
  76         if(SUCCEEDED(hres))
  77             return S_OK;
  78     }
  79
  80     *id = -1;
  81     return DISP_E_UNKNOWNNAME;
  82 }
  83
  84 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
  85 {
  86     unsigned i;
  87
  88     for(i=0; i < dp->cNamedArgs; i++) {
  89         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
  90             return dp->rgvarg+i;
  91     }
  92
  93     return NULL;
  94 }
  95
  96 static HRESULT invoke_variant_prop(vbdisp_t *This, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
  97 {
  98     HRESULT hres;
  99
 100     switch(flags) {
 101     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 102         if(dp->cArgs) {
 103             WARN("called with arguments\n");
 104             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
 105         }
 106
 107         hres = VariantCopy(res, v);
 108         break;
 109
 110     case DISPATCH_PROPERTYPUT: {
 111         VARIANT *put_val;
 112
 113         put_val = get_propput_arg(dp);
 114         if(!put_val) {
 115             WARN("no value to set\n");
 116             return DISP_E_PARAMNOTOPTIONAL;
 117         }
 118
 119         if(res)
 120             V_VT(res) = VT_EMPTY;
 121
 122         hres = VariantCopy(v, put_val);
 123         break;
 124     }
 125
 126     default:
 127         FIXME("unimplemented flags %x\n", flags);
 128         return E_NOTIMPL;
 129     }
 130
 131     return hres;
 132 }
 133
 134 static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
 135 {
 136     switch(flags) {
 137     case DISPATCH_PROPERTYGET:
 138         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
 139             FIXME("property does not support DISPATCH_PROPERTYGET\n");
 140             return E_FAIL;
 141         }
 142         break;
 143     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 144         break;
 145     case DISPATCH_METHOD:
 146         if(prop->flags & (BP_GET|BP_GETPUT)) {
 147             FIXME("Call on property\n");
 148             return E_FAIL;
 149         }
 150         break;
 151     case DISPATCH_PROPERTYPUT:
 152         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
 153             FIXME("property does not support DISPATCH_PROPERTYPUT\n");
 154             return E_FAIL;
 155         }
 156
 157         FIXME("call put\n");
 158         return E_NOTIMPL;
 159     default:
 160         FIXME("unsupported flags %x\n", flags);
 161         return E_NOTIMPL;
 162     }
 163
 164     if(arg_cnt(dp) < prop->min_args || arg_cnt(dp) > (prop->max_args ? prop->max_args : prop->min_args)) {
 165         FIXME("invalid number of arguments\n");
 166         return E_FAIL;
 167     }
 168
 169     return prop->proc(This, dp->rgvarg, dp->cArgs, res);
 170 }
 171
 172 static BOOL run_terminator(vbdisp_t *This)
 173 {
 174     DISPPARAMS dp = {0};
 175
 176     if(This->terminator_ran)
 177         return TRUE;
 178     This->terminator_ran = TRUE;
 179
 180     if(!This->desc->class_terminate_id)
 181         return TRUE;
 182
 183     This->ref++;
 184     exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
 185             (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 186     return !--This->ref;
 187 }
 188
 189 static void clean_props(vbdisp_t *This)
 190 {
 191     unsigned i;
 192
 193     if(!This->desc)
 194         return;
 195
 196     for(i=0; i < This->desc->prop_cnt; i++)
 197         VariantClear(This->props+i);
 198 }
 199
 200 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 201 {
 202     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
 203 }
 204
 205 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 206 {
 207     vbdisp_t *This = impl_from_IDispatchEx(iface);
 208
 209     if(IsEqualGUID(&IID_IUnknown, riid)) {
 210         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 211         *ppv = &This->IDispatchEx_iface;
 212     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 213         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 214         *ppv = &This->IDispatchEx_iface;
 215     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 216         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 217         *ppv = &This->IDispatchEx_iface;
 218     }else {
 219         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 220         *ppv = NULL;
 221         return E_NOINTERFACE;
 222     }
 223
 224     IUnknown_AddRef((IUnknown*)*ppv);
 225     return S_OK;
 226 }
 227
 228 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 229 {
 230     vbdisp_t *This = impl_from_IDispatchEx(iface);
 231     LONG ref = InterlockedIncrement(&This->ref);
 232
 233     TRACE("(%p) ref=%d\n", This, ref);
 234
 235     return ref;
 236 }
 237
 238 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 239 {
 240     vbdisp_t *This = impl_from_IDispatchEx(iface);
 241     LONG ref = InterlockedDecrement(&This->ref);
 242
 243     TRACE("(%p) ref=%d\n", This, ref);
 244
 245     if(!ref && run_terminator(This)) {
 246         clean_props(This);
 247         list_remove(&This->entry);
 248         heap_free(This);
 249     }
 250
 251     return ref;
 252 }
 253
 254 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 255 {
 256     vbdisp_t *This = impl_from_IDispatchEx(iface);
 257
 258     TRACE("(%p)->(%p)\n", This, pctinfo);
 259
 260     *pctinfo = 1;
 261     return S_OK;
 262 }
 263
 264 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 265                                               ITypeInfo **ppTInfo)
 266 {
 267     vbdisp_t *This = impl_from_IDispatchEx(iface);
 268     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 273                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 274                                                 DISPID *rgDispId)
 275 {
 276     vbdisp_t *This = impl_from_IDispatchEx(iface);
 277     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 278           lcid, rgDispId);
 279     return E_NOTIMPL;
 280 }
 281
 282 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 283                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 284                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 285 {
 286     vbdisp_t *This = impl_from_IDispatchEx(iface);
 287     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 288           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 293 {
 294     vbdisp_t *This = impl_from_IDispatchEx(iface);
 295
 296     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 297
 298     if(!This->desc)
 299         return E_UNEXPECTED;
 300
 301     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive)) {
 302         FIXME("unsupported flags %x\n", grfdex);
 303         return E_NOTIMPL;
 304     }
 305
 306     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
 307 }
 308
 309 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 310         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 311 {
 312     vbdisp_t *This = impl_from_IDispatchEx(iface);
 313
 314     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 315
 316     if(!This->desc)
 317         return E_UNEXPECTED;
 318
 319     if(pvarRes)
 320         V_VT(pvarRes) = VT_EMPTY;
 321
 322     if(id < 0)
 323         return DISP_E_MEMBERNOTFOUND;
 324
 325     if(is_func_id(This, id)) {
 326         function_t *func;
 327
 328         switch(wFlags) {
 329         case DISPATCH_METHOD:
 330         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 331             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 332             if(!func) {
 333                 FIXME("no invoke/getter\n");
 334                 return DISP_E_MEMBERNOTFOUND;
 335             }
 336
 337             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
 338         case DISPATCH_PROPERTYPUT: {
 339             VARIANT *put_val;
 340             DISPPARAMS dp = {NULL, NULL, 1, 0};
 341
 342             if(arg_cnt(pdp)) {
 343                 FIXME("arguments not implemented\n");
 344                 return E_NOTIMPL;
 345             }
 346
 347             put_val = get_propput_arg(pdp);
 348             if(!put_val) {
 349                 WARN("no value to set\n");
 350                 return DISP_E_PARAMNOTOPTIONAL;
 351             }
 352
 353             dp.rgvarg = put_val;
 354             func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
 355             if(!func) {
 356                 FIXME("no letter/setter\n");
 357                 return DISP_E_MEMBERNOTFOUND;
 358             }
 359
 360             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 361         }
 362         default:
 363             FIXME("flags %x\n", wFlags);
 364             return DISP_E_MEMBERNOTFOUND;
 365         }
 366     }
 367
 368     if(id < This->desc->prop_cnt + This->desc->func_cnt)
 369         return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
 370
 371     if(This->desc->builtin_prop_cnt) {
 372         unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
 373
 374         while(min <= max) {
 375             i = (min+max)/2;
 376             if(This->desc->builtin_props[i].id == id)
 377                 return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
 378             if(This->desc->builtin_props[i].id < id)
 379                 min = i+1;
 380             else
 381                 max = i-1;
 382         }
 383     }
 384
 385     return DISP_E_MEMBERNOTFOUND;
 386 }
 387
 388 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 389 {
 390     vbdisp_t *This = impl_from_IDispatchEx(iface);
 391     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 396 {
 397     vbdisp_t *This = impl_from_IDispatchEx(iface);
 398     FIXME("(%p)->(%x)\n", This, id);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 403 {
 404     vbdisp_t *This = impl_from_IDispatchEx(iface);
 405     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 410 {
 411     vbdisp_t *This = impl_from_IDispatchEx(iface);
 412     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 417 {
 418     vbdisp_t *This = impl_from_IDispatchEx(iface);
 419     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 424 {
 425     vbdisp_t *This = impl_from_IDispatchEx(iface);
 426     FIXME("(%p)->(%p)\n", This, ppunk);
 427     return E_NOTIMPL;
 428 }
 429
 430 static IDispatchExVtbl DispatchExVtbl = {
 431     DispatchEx_QueryInterface,
 432     DispatchEx_AddRef,
 433     DispatchEx_Release,
 434     DispatchEx_GetTypeInfoCount,
 435     DispatchEx_GetTypeInfo,
 436     DispatchEx_GetIDsOfNames,
 437     DispatchEx_Invoke,
 438     DispatchEx_GetDispID,
 439     DispatchEx_InvokeEx,
 440     DispatchEx_DeleteMemberByName,
 441     DispatchEx_DeleteMemberByDispID,
 442     DispatchEx_GetMemberProperties,
 443     DispatchEx_GetMemberName,
 444     DispatchEx_GetNextDispID,
 445     DispatchEx_GetNameSpaceParent
 446 };
 447
 448 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 449 {
 450     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
 451         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
 452         : NULL;
 453 }
 454
 455 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 456 {
 457     vbdisp_t *vbdisp;
 458
 459     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
 460     if(!vbdisp)
 461         return E_OUTOFMEMORY;
 462
 463     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 464     vbdisp->ref = 1;
 465     vbdisp->desc = desc;
 466
 467     if(desc->class_initialize_id) {
 468         DISPPARAMS dp = {0};
 469         HRESULT hres;
 470
 471         hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
 472                            (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
 473         if(FAILED(hres)) {
 474             IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
 475             return hres;
 476         }
 477     }
 478
 479     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 480     *ret = vbdisp;
 481     return S_OK;
 482 }
 483
 484 void collect_objects(script_ctx_t *ctx)
 485 {
 486     vbdisp_t *iter, *iter2;
 487
 488     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
 489         run_terminator(iter);
 490
 491     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry) {
 492         IDispatchEx_AddRef(&iter->IDispatchEx_iface);
 493         clean_props(iter);
 494         iter->desc = NULL;
 495         IDispatchEx_Release(&iter->IDispatchEx_iface);
 496     }
 497 }
 498
 499 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
 500 {
 501     IDispatchEx *dispex;
 502     vbdisp_t *vbdisp;
 503     HRESULT hres;
 504
 505     vbdisp = unsafe_impl_from_IDispatch(disp);
 506     if(vbdisp)
 507         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
 508
 509     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 510     if(FAILED(hres)) {
 511         TRACE("unsing IDispatch\n");
 512         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 513     }
 514
 515     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
 516     IDispatchEx_Release(dispex);
 517     return hres;
 518 }
 519
 520 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
 521 {
 522     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
 523     IDispatchEx *dispex;
 524     EXCEPINFO ei;
 525     HRESULT hres;
 526
 527     memset(&ei, 0, sizeof(ei));
 528     if(retv)
 529         V_VT(retv) = VT_EMPTY;
 530
 531     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 532     if(FAILED(hres)) {
 533         UINT err = 0;
 534
 535         TRACE("using IDispatch\n");
 536         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
 537     }
 538
 539     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
 540     IDispatchEx_Release(dispex);
 541     return hres;
 542 }
 543
 544 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val)
 545 {
 546     DISPID propput_dispid = DISPID_PROPERTYPUT;
 547     DISPPARAMS dp  = {val, &propput_dispid, 1, 1};
 548     IDispatchEx *dispex;
 549     EXCEPINFO ei = {0};
 550     HRESULT hres;
 551
 552     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 553     if(SUCCEEDED(hres)) {
 554         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL /* FIXME! */);
 555         IDispatchEx_Release(dispex);
 556     }else {
 557         ULONG err = 0;
 558
 559         TRACE("using IDispatch\n");
 560         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, &err);
 561     }
 562
 563     return hres;
 564 }