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 <assert.h>
  20
  21 #include "vbscript.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  26
  27 #define FDEX_VERSION_MASK 0xf0000000
  28
  29 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
  30 {
  31     return id < This->desc->func_cnt;
  32 }
  33
  34 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  35 {
  36     unsigned i;
  37
  38     for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) {
  39         if(invoke_type == VBDISP_ANY) {
  40             if(!search_private && !This->desc->funcs[i].is_public)
  41                 continue;
  42             if(!i && !This->desc->funcs[0].name) /* default value may not exist */
  43                 continue;
  44         }else {
  45             if(!This->desc->funcs[i].entries[invoke_type]
  46                 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
  47                 continue;
  48         }
  49
  50         if(!strcmpiW(This->desc->funcs[i].name, name)) {
  51             *id = i;
  52             return TRUE;
  53         }
  54     }
  55
  56     return FALSE;
  57 }
  58
  59 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  60 {
  61     unsigned i;
  62
  63     if(get_func_id(This, name, invoke_type, search_private, id))
  64         return S_OK;
  65
  66     for(i=0; i < This->desc->prop_cnt; i++) {
  67         if(!search_private && !This->desc->props[i].is_public)
  68             continue;
  69
  70         if(!strcmpiW(This->desc->props[i].name, name)) {
  71             *id = i + This->desc->func_cnt;
  72             return S_OK;
  73         }
  74     }
  75
  76     if(This->desc->typeinfo) {
  77         HRESULT hres;
  78
  79         hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id);
  80         if(SUCCEEDED(hres))
  81             return S_OK;
  82     }
  83
  84     *id = -1;
  85     return DISP_E_UNKNOWNNAME;
  86 }
  87
  88 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
  89 {
  90     unsigned i;
  91
  92     for(i=0; i < dp->cNamedArgs; i++) {
  93         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
  94             return dp->rgvarg+i;
  95     }
  96
  97     return NULL;
  98 }
  99
 100 static HRESULT invoke_variant_prop(VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
 101 {
 102     HRESULT hres;
 103
 104     switch(flags) {
 105     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 106     case DISPATCH_PROPERTYGET:
 107         if(dp->cArgs) {
 108             WARN("called with arguments\n");
 109             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
 110         }
 111
 112         hres = VariantCopy(res, v);
 113         break;
 114
 115     case DISPATCH_PROPERTYPUT: {
 116         VARIANT *put_val;
 117
 118         put_val = get_propput_arg(dp);
 119         if(!put_val) {
 120             WARN("no value to set\n");
 121             return DISP_E_PARAMNOTOPTIONAL;
 122         }
 123
 124         if(res)
 125             V_VT(res) = VT_EMPTY;
 126
 127         hres = VariantCopy(v, put_val);
 128         break;
 129     }
 130
 131     default:
 132         FIXME("unimplemented flags %x\n", flags);
 133         return E_NOTIMPL;
 134     }
 135
 136     return hres;
 137 }
 138
 139 static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
 140 {
 141     VARIANT args[8];
 142     unsigned argn, i;
 143
 144     switch(flags) {
 145     case DISPATCH_PROPERTYGET:
 146         if(!(prop->flags & (BP_GET|BP_GETPUT))) {
 147             FIXME("property does not support DISPATCH_PROPERTYGET\n");
 148             return E_FAIL;
 149         }
 150         break;
 151     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 152         if(!prop->proc && prop->flags == BP_GET) {
 153             assert((INT16)prop->min_args == prop->min_args);
 154             V_VT(res) = VT_I2;
 155             V_I2(res) = prop->min_args;
 156             return S_OK;
 157         }
 158         break;
 159     case DISPATCH_METHOD:
 160         if(prop->flags & (BP_GET|BP_GETPUT)) {
 161             FIXME("Call on property\n");
 162             return E_FAIL;
 163         }
 164         break;
 165     case DISPATCH_PROPERTYPUT:
 166         if(!(prop->flags & BP_GETPUT)) {
 167             FIXME("property does not support DISPATCH_PROPERTYPUT\n");
 168             return E_FAIL;
 169         }
 170
 171         FIXME("call put\n");
 172         return E_NOTIMPL;
 173     default:
 174         FIXME("unsupported flags %x\n", flags);
 175         return E_NOTIMPL;
 176     }
 177
 178     argn = arg_cnt(dp);
 179
 180     if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) {
 181         FIXME("invalid number of arguments\n");
 182         return E_FAIL;
 183     }
 184
 185     assert(argn < sizeof(args)/sizeof(*args));
 186
 187     for(i=0; i < argn; i++) {
 188         if(V_VT(dp->rgvarg+dp->cArgs-i-1) == (VT_BYREF|VT_VARIANT))
 189             args[i] = *V_VARIANTREF(dp->rgvarg+dp->cArgs-i-1);
 190         else
 191             args[i] = dp->rgvarg[dp->cArgs-i-1];
 192     }
 193
 194     return prop->proc(This, args, dp->cArgs, res);
 195 }
 196
 197 static BOOL run_terminator(vbdisp_t *This)
 198 {
 199     DISPPARAMS dp = {0};
 200
 201     if(This->terminator_ran)
 202         return TRUE;
 203     This->terminator_ran = TRUE;
 204
 205     if(!This->desc->class_terminate_id)
 206         return TRUE;
 207
 208     This->ref++;
 209     exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
 210             (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 211     return !--This->ref;
 212 }
 213
 214 static void clean_props(vbdisp_t *This)
 215 {
 216     unsigned i;
 217
 218     if(!This->desc)
 219         return;
 220
 221     for(i=0; i < This->desc->prop_cnt; i++)
 222         VariantClear(This->props+i);
 223 }
 224
 225 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 226 {
 227     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
 228 }
 229
 230 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 231 {
 232     vbdisp_t *This = impl_from_IDispatchEx(iface);
 233
 234     if(IsEqualGUID(&IID_IUnknown, riid)) {
 235         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 236         *ppv = &This->IDispatchEx_iface;
 237     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 238         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 239         *ppv = &This->IDispatchEx_iface;
 240     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 241         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 242         *ppv = &This->IDispatchEx_iface;
 243     }else {
 244         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 245         *ppv = NULL;
 246         return E_NOINTERFACE;
 247     }
 248
 249     IUnknown_AddRef((IUnknown*)*ppv);
 250     return S_OK;
 251 }
 252
 253 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 254 {
 255     vbdisp_t *This = impl_from_IDispatchEx(iface);
 256     LONG ref = InterlockedIncrement(&This->ref);
 257
 258     TRACE("(%p) ref=%d\n", This, ref);
 259
 260     return ref;
 261 }
 262
 263 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 264 {
 265     vbdisp_t *This = impl_from_IDispatchEx(iface);
 266     LONG ref = InterlockedDecrement(&This->ref);
 267
 268     TRACE("(%p) ref=%d\n", This, ref);
 269
 270     if(!ref && run_terminator(This)) {
 271         clean_props(This);
 272         list_remove(&This->entry);
 273         heap_free(This);
 274     }
 275
 276     return ref;
 277 }
 278
 279 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 280 {
 281     vbdisp_t *This = impl_from_IDispatchEx(iface);
 282
 283     TRACE("(%p)->(%p)\n", This, pctinfo);
 284
 285     *pctinfo = 1;
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 290                                               ITypeInfo **ppTInfo)
 291 {
 292     vbdisp_t *This = impl_from_IDispatchEx(iface);
 293     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 298                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 299                                                 DISPID *rgDispId)
 300 {
 301     vbdisp_t *This = impl_from_IDispatchEx(iface);
 302     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 303           lcid, rgDispId);
 304     return E_NOTIMPL;
 305 }
 306
 307 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 308                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 309                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 310 {
 311     vbdisp_t *This = impl_from_IDispatchEx(iface);
 312     FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 313           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 318 {
 319     vbdisp_t *This = impl_from_IDispatchEx(iface);
 320
 321     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 322
 323     grfdex &= ~FDEX_VERSION_MASK;
 324
 325     if(!This->desc)
 326         return E_UNEXPECTED;
 327
 328     /* Tests show that fdexNameCaseSensitive is ignored */
 329
 330     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive|fdexNameCaseSensitive)) {
 331         FIXME("unsupported flags %x\n", grfdex);
 332         return E_NOTIMPL;
 333     }
 334
 335     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
 336 }
 337
 338 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 339         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 340 {
 341     vbdisp_t *This = impl_from_IDispatchEx(iface);
 342
 343     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 344
 345     if(!This->desc)
 346         return E_UNEXPECTED;
 347
 348     if(pvarRes)
 349         V_VT(pvarRes) = VT_EMPTY;
 350
 351     if(id < 0)
 352         return DISP_E_MEMBERNOTFOUND;
 353
 354     if(is_func_id(This, id)) {
 355         function_t *func;
 356
 357         switch(wFlags) {
 358         case DISPATCH_METHOD:
 359         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 360             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 361             if(!func) {
 362                 FIXME("no invoke/getter\n");
 363                 return DISP_E_MEMBERNOTFOUND;
 364             }
 365
 366             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
 367         case DISPATCH_PROPERTYPUT: {
 368             VARIANT *put_val;
 369             DISPPARAMS dp = {NULL, NULL, 1, 0};
 370
 371             if(arg_cnt(pdp)) {
 372                 FIXME("arguments not implemented\n");
 373                 return E_NOTIMPL;
 374             }
 375
 376             put_val = get_propput_arg(pdp);
 377             if(!put_val) {
 378                 WARN("no value to set\n");
 379                 return DISP_E_PARAMNOTOPTIONAL;
 380             }
 381
 382             dp.rgvarg = put_val;
 383             func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
 384             if(!func) {
 385                 FIXME("no letter/setter\n");
 386                 return DISP_E_MEMBERNOTFOUND;
 387             }
 388
 389             return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
 390         }
 391         default:
 392             FIXME("flags %x\n", wFlags);
 393             return DISP_E_MEMBERNOTFOUND;
 394         }
 395     }
 396
 397     if(id < This->desc->prop_cnt + This->desc->func_cnt)
 398         return invoke_variant_prop(This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
 399
 400     if(This->desc->builtin_prop_cnt) {
 401         unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
 402
 403         while(min <= max) {
 404             i = (min+max)/2;
 405             if(This->desc->builtin_props[i].id == id)
 406                 return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
 407             if(This->desc->builtin_props[i].id < id)
 408                 min = i+1;
 409             else
 410                 max = i-1;
 411         }
 412     }
 413
 414     return DISP_E_MEMBERNOTFOUND;
 415 }
 416
 417 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 418 {
 419     vbdisp_t *This = impl_from_IDispatchEx(iface);
 420     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 425 {
 426     vbdisp_t *This = impl_from_IDispatchEx(iface);
 427     FIXME("(%p)->(%x)\n", This, id);
 428     return E_NOTIMPL;
 429 }
 430
 431 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 432 {
 433     vbdisp_t *This = impl_from_IDispatchEx(iface);
 434     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 439 {
 440     vbdisp_t *This = impl_from_IDispatchEx(iface);
 441     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 442     return E_NOTIMPL;
 443 }
 444
 445 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 446 {
 447     vbdisp_t *This = impl_from_IDispatchEx(iface);
 448     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 449     return E_NOTIMPL;
 450 }
 451
 452 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 453 {
 454     vbdisp_t *This = impl_from_IDispatchEx(iface);
 455     FIXME("(%p)->(%p)\n", This, ppunk);
 456     return E_NOTIMPL;
 457 }
 458
 459 static IDispatchExVtbl DispatchExVtbl = {
 460     DispatchEx_QueryInterface,
 461     DispatchEx_AddRef,
 462     DispatchEx_Release,
 463     DispatchEx_GetTypeInfoCount,
 464     DispatchEx_GetTypeInfo,
 465     DispatchEx_GetIDsOfNames,
 466     DispatchEx_Invoke,
 467     DispatchEx_GetDispID,
 468     DispatchEx_InvokeEx,
 469     DispatchEx_DeleteMemberByName,
 470     DispatchEx_DeleteMemberByDispID,
 471     DispatchEx_GetMemberProperties,
 472     DispatchEx_GetMemberName,
 473     DispatchEx_GetNextDispID,
 474     DispatchEx_GetNameSpaceParent
 475 };
 476
 477 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 478 {
 479     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
 480         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
 481         : NULL;
 482 }
 483
 484 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 485 {
 486     vbdisp_t *vbdisp;
 487
 488     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
 489     if(!vbdisp)
 490         return E_OUTOFMEMORY;
 491
 492     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 493     vbdisp->ref = 1;
 494     vbdisp->desc = desc;
 495
 496     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 497
 498     if(desc->class_initialize_id) {
 499         DISPPARAMS dp = {0};
 500         HRESULT hres;
 501
 502         hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
 503                            (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
 504         if(FAILED(hres)) {
 505             IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
 506             return hres;
 507         }
 508     }
 509
 510     *ret = vbdisp;
 511     return S_OK;
 512 }
 513
 514 static HRESULT Procedure_invoke(vbdisp_t *This, VARIANT *args, unsigned args_cnt, VARIANT *res)
 515 {
 516     script_ctx_t *ctx = This->desc->ctx;
 517     HRESULT hres;
 518
 519     TRACE("\n");
 520
 521     IActiveScriptSite_OnEnterScript(ctx->site);
 522     hres = exec_script(ctx, This->desc->value_func, NULL, NULL, NULL);
 523     IActiveScriptSite_OnLeaveScript(ctx->site);
 524
 525     return hres;
 526 }
 527
 528 static const builtin_prop_t procedure_props[] = {
 529     {DISPID_VALUE,  Procedure_invoke, 0}
 530 };
 531
 532 HRESULT create_procedure_disp(script_ctx_t *ctx, vbscode_t *code, IDispatch **ret)
 533 {
 534     class_desc_t *desc;
 535     vbdisp_t *vbdisp;
 536     HRESULT hres;
 537
 538     desc = heap_alloc_zero(sizeof(*desc));
 539     if(!desc)
 540         return E_OUTOFMEMORY;
 541
 542     desc->ctx = ctx;
 543     desc->builtin_prop_cnt = sizeof(procedure_props)/sizeof(*procedure_props);
 544     desc->builtin_props = procedure_props;
 545     desc->value_func = &code->main_code;
 546
 547     hres = create_vbdisp(desc, &vbdisp);
 548     if(FAILED(hres)) {
 549         heap_free(desc);
 550         return hres;
 551     }
 552
 553     desc->next = ctx->procs;
 554     ctx->procs = desc;
 555
 556     *ret = (IDispatch*)&vbdisp->IDispatchEx_iface;
 557     return S_OK;
 558 }
 559
 560 struct _ident_map_t {
 561     const WCHAR *name;
 562     BOOL is_var;
 563     union {
 564         dynamic_var_t *var;
 565         function_t *func;
 566     } u;
 567 };
 568
 569 static inline DISPID ident_to_id(ScriptDisp *This, ident_map_t *ident)
 570 {
 571     return (ident-This->ident_map)+1;
 572 }
 573
 574 static inline ident_map_t *id_to_ident(ScriptDisp *This, DISPID id)
 575 {
 576     return 0 < id && id <= This->ident_map_cnt ? This->ident_map+id-1 : NULL;
 577 }
 578
 579 static ident_map_t *add_ident(ScriptDisp *This, const WCHAR *name)
 580 {
 581     ident_map_t *ret;
 582
 583     if(!This->ident_map_size) {
 584         This->ident_map = heap_alloc(4 * sizeof(*This->ident_map));
 585         if(!This->ident_map)
 586             return NULL;
 587         This->ident_map_size = 4;
 588     }else if(This->ident_map_cnt == This->ident_map_size) {
 589         ident_map_t *new_map;
 590
 591         new_map = heap_realloc(This->ident_map, 2*This->ident_map_size*sizeof(*new_map));
 592         if(!new_map)
 593             return NULL;
 594         This->ident_map = new_map;
 595         This->ident_map_size *= 2;
 596     }
 597
 598     ret = This->ident_map + This->ident_map_cnt++;
 599     ret->name = name;
 600     return ret;
 601 }
 602
 603 static inline ScriptDisp *ScriptDisp_from_IDispatchEx(IDispatchEx *iface)
 604 {
 605     return CONTAINING_RECORD(iface, ScriptDisp, IDispatchEx_iface);
 606 }
 607
 608 static HRESULT WINAPI ScriptDisp_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 609 {
 610     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 611
 612     if(IsEqualGUID(&IID_IUnknown, riid)) {
 613         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 614         *ppv = &This->IDispatchEx_iface;
 615     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 616         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 617         *ppv = &This->IDispatchEx_iface;
 618     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 619         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 620         *ppv = &This->IDispatchEx_iface;
 621     }else {
 622         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 623         *ppv = NULL;
 624         return E_NOINTERFACE;
 625     }
 626
 627     IUnknown_AddRef((IUnknown*)*ppv);
 628     return S_OK;
 629 }
 630
 631 static ULONG WINAPI ScriptDisp_AddRef(IDispatchEx *iface)
 632 {
 633     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 634     LONG ref = InterlockedIncrement(&This->ref);
 635
 636     TRACE("(%p) ref=%d\n", This, ref);
 637
 638     return ref;
 639 }
 640
 641 static ULONG WINAPI ScriptDisp_Release(IDispatchEx *iface)
 642 {
 643     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 644     LONG ref = InterlockedDecrement(&This->ref);
 645
 646     TRACE("(%p) ref=%d\n", This, ref);
 647
 648     if(!ref) {
 649         assert(!This->ctx);
 650         heap_free(This->ident_map);
 651         heap_free(This);
 652     }
 653
 654     return ref;
 655 }
 656
 657 static HRESULT WINAPI ScriptDisp_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 658 {
 659     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 660
 661     TRACE("(%p)->(%p)\n", This, pctinfo);
 662
 663     *pctinfo = 1;
 664     return S_OK;
 665 }
 666
 667 static HRESULT WINAPI ScriptDisp_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 668                                               ITypeInfo **ppTInfo)
 669 {
 670     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 671     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 672     return E_NOTIMPL;
 673 }
 674
 675 static HRESULT WINAPI ScriptDisp_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 676         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 677 {
 678     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 679     UINT i;
 680     HRESULT hres;
 681
 682     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 683           lcid, rgDispId);
 684
 685     for(i=0; i < cNames; i++) {
 686         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
 687         if(FAILED(hres))
 688             return hres;
 689     }
 690
 691     return S_OK;
 692 }
 693
 694 static HRESULT WINAPI ScriptDisp_Invoke(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 695          WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 696 {
 697     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 698
 699     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 700           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 701
 702     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
 703             pDispParams, pVarResult, pExcepInfo, NULL);
 704 }
 705
 706 static HRESULT WINAPI ScriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 707 {
 708     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 709     dynamic_var_t *var;
 710     ident_map_t *ident;
 711     function_t *func;
 712
 713     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 714
 715     if(!This->ctx)
 716         return E_UNEXPECTED;
 717
 718     for(ident = This->ident_map; ident < This->ident_map+This->ident_map_cnt; ident++) {
 719         if(!strcmpiW(ident->name, bstrName)) {
 720             *pid = ident_to_id(This, ident);
 721             return S_OK;
 722         }
 723     }
 724
 725     for(var = This->ctx->global_vars; var; var = var->next) {
 726         if(!strcmpiW(var->name, bstrName)) {
 727             ident = add_ident(This, var->name);
 728             if(!ident)
 729                 return E_OUTOFMEMORY;
 730
 731             ident->is_var = TRUE;
 732             ident->u.var = var;
 733             *pid = ident_to_id(This, ident);
 734             return S_OK;
 735         }
 736     }
 737
 738     for(func = This->ctx->global_funcs; func; func = func->next) {
 739         if(!strcmpiW(func->name, bstrName)) {
 740             ident = add_ident(This, func->name);
 741             if(!ident)
 742                 return E_OUTOFMEMORY;
 743
 744             ident->is_var = FALSE;
 745             ident->u.func = func;
 746             *pid =  ident_to_id(This, ident);
 747             return S_OK;
 748         }
 749     }
 750
 751     *pid = -1;
 752     return DISP_E_UNKNOWNNAME;
 753 }
 754
 755 static HRESULT WINAPI ScriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 756         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 757 {
 758     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 759     ident_map_t *ident;
 760     HRESULT hres;
 761
 762     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 763
 764     ident = id_to_ident(This, id);
 765     if(!ident)
 766         return DISP_E_MEMBERNOTFOUND;
 767
 768     if(ident->is_var) {
 769         if(ident->u.var->is_const) {
 770             FIXME("const not supported\n");
 771             return E_NOTIMPL;
 772         }
 773
 774         return invoke_variant_prop(&ident->u.var->v, wFlags, pdp, pvarRes);
 775     }
 776
 777     switch(wFlags) {
 778     case DISPATCH_METHOD:
 779     case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 780         IActiveScriptSite_OnEnterScript(This->ctx->site);
 781         hres = exec_script(This->ctx, ident->u.func, NULL, pdp, pvarRes);
 782         IActiveScriptSite_OnLeaveScript(This->ctx->site);
 783         break;
 784     default:
 785         FIXME("Unsupported flags %x\n", wFlags);
 786         hres = E_NOTIMPL;
 787     }
 788
 789     return hres;
 790 }
 791
 792 static HRESULT WINAPI ScriptDisp_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 793 {
 794     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 795     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 796     return E_NOTIMPL;
 797 }
 798
 799 static HRESULT WINAPI ScriptDisp_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 800 {
 801     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 802     FIXME("(%p)->(%x)\n", This, id);
 803     return E_NOTIMPL;
 804 }
 805
 806 static HRESULT WINAPI ScriptDisp_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 807 {
 808     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 809     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI ScriptDisp_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 814 {
 815     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 816     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 817     return E_NOTIMPL;
 818 }
 819
 820 static HRESULT WINAPI ScriptDisp_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 821 {
 822     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 823     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 824     return E_NOTIMPL;
 825 }
 826
 827 static HRESULT WINAPI ScriptDisp_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 828 {
 829     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
 830     FIXME("(%p)->(%p)\n", This, ppunk);
 831     return E_NOTIMPL;
 832 }
 833
 834 static IDispatchExVtbl ScriptDispVtbl = {
 835     ScriptDisp_QueryInterface,
 836     ScriptDisp_AddRef,
 837     ScriptDisp_Release,
 838     ScriptDisp_GetTypeInfoCount,
 839     ScriptDisp_GetTypeInfo,
 840     ScriptDisp_GetIDsOfNames,
 841     ScriptDisp_Invoke,
 842     ScriptDisp_GetDispID,
 843     ScriptDisp_InvokeEx,
 844     ScriptDisp_DeleteMemberByName,
 845     ScriptDisp_DeleteMemberByDispID,
 846     ScriptDisp_GetMemberProperties,
 847     ScriptDisp_GetMemberName,
 848     ScriptDisp_GetNextDispID,
 849     ScriptDisp_GetNameSpaceParent
 850 };
 851
 852 HRESULT create_script_disp(script_ctx_t *ctx, ScriptDisp **ret)
 853 {
 854     ScriptDisp *script_disp;
 855
 856     script_disp = heap_alloc_zero(sizeof(*script_disp));
 857     if(!script_disp)
 858         return E_OUTOFMEMORY;
 859
 860     script_disp->IDispatchEx_iface.lpVtbl = &ScriptDispVtbl;
 861     script_disp->ref = 1;
 862     script_disp->ctx = ctx;
 863
 864     *ret = script_disp;
 865     return S_OK;
 866 }
 867
 868 void collect_objects(script_ctx_t *ctx)
 869 {
 870     vbdisp_t *iter, *iter2;
 871
 872     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
 873         run_terminator(iter);
 874
 875     while(!list_empty(&ctx->objects)) {
 876         iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
 877
 878         IDispatchEx_AddRef(&iter->IDispatchEx_iface);
 879         clean_props(iter);
 880         iter->desc = NULL;
 881         list_remove(&iter->entry);
 882         list_init(&iter->entry);
 883         IDispatchEx_Release(&iter->IDispatchEx_iface);
 884     }
 885 }
 886
 887 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
 888 {
 889     IDispatchEx *dispex;
 890     vbdisp_t *vbdisp;
 891     HRESULT hres;
 892
 893     vbdisp = unsafe_impl_from_IDispatch(disp);
 894     if(vbdisp)
 895         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
 896
 897     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 898     if(FAILED(hres)) {
 899         TRACE("using IDispatch\n");
 900         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 901     }
 902
 903     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
 904     IDispatchEx_Release(dispex);
 905     return hres;
 906 }
 907
 908 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
 909 {
 910     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
 911     IDispatchEx *dispex;
 912     EXCEPINFO ei;
 913     HRESULT hres;
 914
 915     memset(&ei, 0, sizeof(ei));
 916     if(retv)
 917         V_VT(retv) = VT_EMPTY;
 918
 919     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 920     if(FAILED(hres)) {
 921         UINT err = 0;
 922
 923         TRACE("using IDispatch\n");
 924         return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
 925     }
 926
 927     hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
 928     IDispatchEx_Release(dispex);
 929     return hres;
 930 }
 931
 932 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp)
 933 {
 934     IDispatchEx *dispex;
 935     EXCEPINFO ei = {0};
 936     HRESULT hres;
 937
 938     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 939     if(SUCCEEDED(hres)) {
 940         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, NULL /* FIXME! */);
 941         IDispatchEx_Release(dispex);
 942     }else {
 943         ULONG err = 0;
 944
 945         TRACE("using IDispatch\n");
 946         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, &err);
 947     }
 948
 949     return hres;
 950 }