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