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 static const GUID GUID_VBScriptTypeInfo = {0xc59c6b12,0xf6c1,0x11cf,{0x88,0x35,0x00,0xa0,0xc9,0x11,0xe8,0xb2}};
  28
  29 #define DISPID_FUNCTION_MASK 0x20000000
  30 #define FDEX_VERSION_MASK 0xf0000000
  31
  32 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
  33 {
  34     return id < This->desc->func_cnt;
  35 }
  36
  37 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  38 {
  39     unsigned i;
  40
  41     for(i = 0; i < This->desc->func_cnt; i++) {
  42         if(invoke_type == VBDISP_ANY) {
  43             if(!search_private && !This->desc->funcs[i].is_public)
  44                 continue;
  45         }else {
  46             if(!This->desc->funcs[i].entries[invoke_type]
  47                 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
  48                 continue;
  49         }
  50
  51         if(This->desc->funcs[i].name && !wcsicmp(This->desc->funcs[i].name, name)) {
  52             *id = i;
  53             return TRUE;
  54         }
  55     }
  56
  57     return FALSE;
  58 }
  59
  60 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
  61 {
  62     unsigned i;
  63
  64     if(get_func_id(This, name, invoke_type, search_private, id))
  65         return S_OK;
  66
  67     for(i=0; i < This->desc->prop_cnt; i++) {
  68         if(!search_private && !This->desc->props[i].is_public)
  69             continue;
  70
  71         if(!wcsicmp(This->desc->props[i].name, name)) {
  72             *id = i + This->desc->func_cnt;
  73             return S_OK;
  74         }
  75     }
  76
  77     *id = -1;
  78     return DISP_E_UNKNOWNNAME;
  79 }
  80
  81 static HRESULT get_propput_arg(script_ctx_t *ctx, const DISPPARAMS *dp, WORD flags, VARIANT *v, BOOL *is_owned)
  82 {
  83     unsigned i;
  84
  85     for(i=0; i < dp->cNamedArgs; i++) {
  86         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
  87             break;
  88     }
  89     if(i == dp->cNamedArgs) {
  90         WARN("no value to set\n");
  91         return DISP_E_PARAMNOTOPTIONAL;
  92     }
  93
  94     *v = dp->rgvarg[i];
  95     if(V_VT(v) == (VT_VARIANT|VT_BYREF))
  96         *v = *V_VARIANTREF(v);
  97     *is_owned = FALSE;
  98
  99     if(V_VT(v) == VT_DISPATCH) {
 100         if(!(flags & DISPATCH_PROPERTYPUTREF)) {
 101             HRESULT hres;
 102
 103             hres = get_disp_value(ctx, V_DISPATCH(v), v);
 104             if(FAILED(hres))
 105                 return hres;
 106
 107             *is_owned = TRUE;
 108         }
 109     }else if(!(flags & DISPATCH_PROPERTYPUT)) {
 110         WARN("%s can't be assigned without DISPATCH_PROPERTYPUT flag\n", debugstr_variant(v));
 111         return DISP_E_EXCEPTION;
 112     }
 113
 114     return S_OK;
 115 }
 116
 117 static HRESULT invoke_variant_prop(script_ctx_t *ctx, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
 118 {
 119     HRESULT hres;
 120
 121     switch(flags) {
 122     case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
 123     case DISPATCH_PROPERTYGET:
 124         if(dp->cArgs) {
 125             WARN("called with arguments\n");
 126             return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
 127         }
 128
 129         hres = VariantCopyInd(res, v);
 130         break;
 131
 132     case DISPATCH_PROPERTYPUT:
 133     case DISPATCH_PROPERTYPUTREF:
 134     case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: {
 135         VARIANT put_val;
 136         BOOL own_val;
 137
 138         hres = get_propput_arg(ctx, dp, flags, &put_val, &own_val);
 139         if(FAILED(hres))
 140             return hres;
 141
 142         if(arg_cnt(dp)) {
 143             FIXME("Arguments not supported\n");
 144             return E_NOTIMPL;
 145         }
 146
 147         if(res)
 148             V_VT(res) = VT_EMPTY;
 149
 150         if(own_val)
 151             *v = put_val;
 152         else
 153             hres = VariantCopyInd(v, &put_val);
 154         break;
 155     }
 156
 157     default:
 158         FIXME("unimplemented flags %x\n", flags);
 159         return E_NOTIMPL;
 160     }
 161
 162     return hres;
 163 }
 164
 165 static HRESULT invoke_vbdisp(vbdisp_t *This, DISPID id, DWORD flags, BOOL extern_caller, DISPPARAMS *params, VARIANT *res)
 166 {
 167     if(id < 0)
 168         return DISP_E_MEMBERNOTFOUND;
 169
 170     if(is_func_id(This, id)) {
 171         function_t *func;
 172
 173         TRACE("%p->%s\n", This, debugstr_w(This->desc->funcs[id].name));
 174
 175         switch(flags) {
 176         case DISPATCH_PROPERTYGET:
 177             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 178             if(!func || func->type != FUNC_PROPGET) {
 179                 WARN("no getter\n");
 180                 return DISP_E_MEMBERNOTFOUND;
 181             }
 182
 183             return exec_script(This->desc->ctx, extern_caller, func, This, params, res);
 184
 185         case DISPATCH_METHOD:
 186         case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
 187             func = This->desc->funcs[id].entries[VBDISP_CALLGET];
 188             if(!func) {
 189                 FIXME("no invoke/getter\n");
 190                 return DISP_E_MEMBERNOTFOUND;
 191             }
 192
 193             return exec_script(This->desc->ctx, extern_caller, func, This, params, res);
 194
 195         case DISPATCH_PROPERTYPUT:
 196         case DISPATCH_PROPERTYPUTREF:
 197         case DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF: {
 198             DISPPARAMS dp = {NULL, NULL, 1, 0};
 199             BOOL needs_release;
 200             VARIANT buf[6];
 201             HRESULT hres;
 202             INT i;
 203
 204             dp.cArgs = arg_cnt(params) + 1;
 205             if(dp.cArgs > ARRAY_SIZE(buf)) {
 206                 dp.rgvarg = heap_alloc(dp.cArgs*sizeof(VARIANT));
 207                 if(!dp.rgvarg)
 208                     return E_OUTOFMEMORY;
 209             }else {
 210                 dp.rgvarg = buf;
 211             }
 212
 213             hres = get_propput_arg(This->desc->ctx, params, flags, dp.rgvarg, &needs_release);
 214             if(FAILED(hres)) {
 215                 if(dp.rgvarg != buf)
 216                     heap_free(dp.rgvarg);
 217                 return hres;
 218             }
 219
 220             func = This->desc->funcs[id].entries[V_VT(dp.rgvarg) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
 221             if(!func) {
 222                 FIXME("no letter/setter\n");
 223                 if(dp.rgvarg != buf)
 224                     heap_free(dp.rgvarg);
 225                 return DISP_E_MEMBERNOTFOUND;
 226             }
 227
 228             for(i=1; i < dp.cArgs; i++) {
 229                 dp.rgvarg[i]=params->rgvarg[params->cNamedArgs+i-1];
 230             }
 231
 232             hres = exec_script(This->desc->ctx, extern_caller, func, This, &dp, NULL);
 233             if(needs_release)
 234                 VariantClear(dp.rgvarg);
 235             if(dp.rgvarg != buf)
 236                 heap_free(dp.rgvarg);
 237             return hres;
 238         }
 239         default:
 240             FIXME("flags %x\n", flags);
 241             return DISP_E_MEMBERNOTFOUND;
 242         }
 243     }
 244
 245     if(id >= This->desc->prop_cnt + This->desc->func_cnt)
 246         return DISP_E_MEMBERNOTFOUND;
 247
 248     TRACE("%p->%s\n", This, debugstr_w(This->desc->props[id - This->desc->func_cnt].name));
 249     return invoke_variant_prop(This->desc->ctx, This->props+(id-This->desc->func_cnt), flags, params, res);
 250 }
 251
 252 static BOOL run_terminator(vbdisp_t *This)
 253 {
 254     DISPPARAMS dp = {0};
 255
 256     if(This->terminator_ran)
 257         return TRUE;
 258     This->terminator_ran = TRUE;
 259
 260     if(!This->desc->class_terminate_id)
 261         return TRUE;
 262
 263     This->ref++;
 264     exec_script(This->desc->ctx, FALSE, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
 265             This, &dp, NULL);
 266     return !--This->ref;
 267 }
 268
 269 static void clean_props(vbdisp_t *This)
 270 {
 271     unsigned i;
 272
 273     if(!This->desc)
 274         return;
 275
 276     for(i=0; i < This->desc->array_cnt; i++) {
 277         if(This->arrays[i]) {
 278             SafeArrayDestroy(This->arrays[i]);
 279             This->arrays[i] = NULL;
 280         }
 281     }
 282
 283     for(i=0; i < This->desc->prop_cnt; i++)
 284         VariantClear(This->props+i);
 285 }
 286
 287 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
 288 {
 289     return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
 290 }
 291
 292 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 293 {
 294     vbdisp_t *This = impl_from_IDispatchEx(iface);
 295
 296     if(IsEqualGUID(&IID_IUnknown, riid)) {
 297         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 298         *ppv = &This->IDispatchEx_iface;
 299     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 300         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 301         *ppv = &This->IDispatchEx_iface;
 302     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 303         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 304         *ppv = &This->IDispatchEx_iface;
 305     }else {
 306         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 307         *ppv = NULL;
 308         return E_NOINTERFACE;
 309     }
 310
 311     IUnknown_AddRef((IUnknown*)*ppv);
 312     return S_OK;
 313 }
 314
 315 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 316 {
 317     vbdisp_t *This = impl_from_IDispatchEx(iface);
 318     LONG ref = InterlockedIncrement(&This->ref);
 319
 320     TRACE("(%p) ref=%d\n", This, ref);
 321
 322     return ref;
 323 }
 324
 325 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 326 {
 327     vbdisp_t *This = impl_from_IDispatchEx(iface);
 328     LONG ref = InterlockedDecrement(&This->ref);
 329
 330     TRACE("(%p) ref=%d\n", This, ref);
 331
 332     if(!ref && run_terminator(This)) {
 333         clean_props(This);
 334         list_remove(&This->entry);
 335         heap_free(This->arrays);
 336         heap_free(This);
 337     }
 338
 339     return ref;
 340 }
 341
 342 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 343 {
 344     vbdisp_t *This = impl_from_IDispatchEx(iface);
 345
 346     TRACE("(%p)->(%p)\n", This, pctinfo);
 347
 348     *pctinfo = 1;
 349     return S_OK;
 350 }
 351
 352 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
 353                                               ITypeInfo **ppTInfo)
 354 {
 355     vbdisp_t *This = impl_from_IDispatchEx(iface);
 356     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 361                                                 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
 362                                                 DISPID *rgDispId)
 363 {
 364     vbdisp_t *This = impl_from_IDispatchEx(iface);
 365     FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 366           lcid, rgDispId);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 371                                         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 372                                         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 373 {
 374     vbdisp_t *This = impl_from_IDispatchEx(iface);
 375
 376     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 377           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 378
 379     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, NULL);
 380 }
 381
 382 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 383 {
 384     vbdisp_t *This = impl_from_IDispatchEx(iface);
 385
 386     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 387
 388     grfdex &= ~FDEX_VERSION_MASK;
 389
 390     if(!This->desc)
 391         return E_UNEXPECTED;
 392
 393     /* Tests show that fdexNameCaseSensitive is ignored */
 394
 395     if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive|fdexNameCaseSensitive)) {
 396         FIXME("unsupported flags %x\n", grfdex);
 397         return E_NOTIMPL;
 398     }
 399
 400     return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
 401 }
 402
 403 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 404         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 405 {
 406     vbdisp_t *This = impl_from_IDispatchEx(iface);
 407
 408     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 409
 410     if(!This->desc)
 411         return E_UNEXPECTED;
 412
 413     if(pvarRes)
 414         V_VT(pvarRes) = VT_EMPTY;
 415
 416     return invoke_vbdisp(This, id, wFlags, TRUE, pdp, pvarRes);
 417 }
 418
 419 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 420 {
 421     vbdisp_t *This = impl_from_IDispatchEx(iface);
 422     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 427 {
 428     vbdisp_t *This = impl_from_IDispatchEx(iface);
 429     FIXME("(%p)->(%x)\n", This, id);
 430     return E_NOTIMPL;
 431 }
 432
 433 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 434 {
 435     vbdisp_t *This = impl_from_IDispatchEx(iface);
 436     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 441 {
 442     vbdisp_t *This = impl_from_IDispatchEx(iface);
 443     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 448 {
 449     vbdisp_t *This = impl_from_IDispatchEx(iface);
 450     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 455 {
 456     vbdisp_t *This = impl_from_IDispatchEx(iface);
 457     FIXME("(%p)->(%p)\n", This, ppunk);
 458     return E_NOTIMPL;
 459 }
 460
 461 static IDispatchExVtbl DispatchExVtbl = {
 462     DispatchEx_QueryInterface,
 463     DispatchEx_AddRef,
 464     DispatchEx_Release,
 465     DispatchEx_GetTypeInfoCount,
 466     DispatchEx_GetTypeInfo,
 467     DispatchEx_GetIDsOfNames,
 468     DispatchEx_Invoke,
 469     DispatchEx_GetDispID,
 470     DispatchEx_InvokeEx,
 471     DispatchEx_DeleteMemberByName,
 472     DispatchEx_DeleteMemberByDispID,
 473     DispatchEx_GetMemberProperties,
 474     DispatchEx_GetMemberName,
 475     DispatchEx_GetNextDispID,
 476     DispatchEx_GetNameSpaceParent
 477 };
 478
 479 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
 480 {
 481     return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
 482         ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
 483         : NULL;
 484 }
 485
 486 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
 487 {
 488     vbdisp_t *vbdisp;
 489     HRESULT hres = S_OK;
 490
 491     vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
 492     if(!vbdisp)
 493         return E_OUTOFMEMORY;
 494
 495     vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
 496     vbdisp->ref = 1;
 497     vbdisp->desc = desc;
 498
 499     list_add_tail(&desc->ctx->objects, &vbdisp->entry);
 500
 501     if(desc->array_cnt) {
 502         vbdisp->arrays = heap_alloc_zero(desc->array_cnt * sizeof(*vbdisp->arrays));
 503         if(vbdisp->arrays) {
 504             unsigned i, j;
 505
 506             for(i=0; i < desc->array_cnt; i++) {
 507                 if(!desc->array_descs[i].dim_cnt)
 508                     continue;
 509
 510                 vbdisp->arrays[i] = SafeArrayCreate(VT_VARIANT, desc->array_descs[i].dim_cnt, desc->array_descs[i].bounds);
 511                 if(!vbdisp->arrays[i]) {
 512                     hres = E_OUTOFMEMORY;
 513                     break;
 514                 }
 515             }
 516
 517             if(SUCCEEDED(hres)) {
 518                 for(i=0, j=0; i < desc->prop_cnt; i++) {
 519                     if(desc->props[i].is_array) {
 520                         V_VT(vbdisp->props+i) = VT_ARRAY|VT_BYREF|VT_VARIANT;
 521                         V_ARRAYREF(vbdisp->props+i) = vbdisp->arrays + j++;
 522                     }
 523                 }
 524             }
 525         }else {
 526             hres = E_OUTOFMEMORY;
 527         }
 528     }
 529
 530     if(SUCCEEDED(hres) && desc->class_initialize_id) {
 531         DISPPARAMS dp = {0};
 532         hres = exec_script(desc->ctx, FALSE, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
 533                            vbdisp, &dp, NULL);
 534     }
 535
 536     if(FAILED(hres)) {
 537         IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
 538         return hres;
 539     }
 540
 541     *ret = vbdisp;
 542     return S_OK;
 543 }
 544
 545 struct typeinfo_func {
 546     function_t *func;
 547     MEMBERID memid;
 548 };
 549
 550 typedef struct {
 551     ITypeInfo ITypeInfo_iface;
 552     ITypeComp ITypeComp_iface;
 553     LONG ref;
 554
 555     UINT num_vars;
 556     UINT num_funcs;
 557     struct typeinfo_func *funcs;
 558
 559     ScriptDisp *disp;
 560 } ScriptTypeInfo;
 561
 562 static function_t *get_func_from_memid(const ScriptTypeInfo *typeinfo, MEMBERID memid)
 563 {
 564     UINT a = 0, b = typeinfo->num_funcs;
 565
 566     if (!(memid & DISPID_FUNCTION_MASK)) return NULL;
 567
 568     while (a < b)
 569     {
 570         UINT i = (a + b - 1) / 2;
 571
 572         if (memid == typeinfo->funcs[i].memid)
 573             return typeinfo->funcs[i].func;
 574         else if (memid < typeinfo->funcs[i].memid)
 575             b = i;
 576         else
 577             a = i + 1;
 578     }
 579     return NULL;
 580 }
 581
 582 static inline ScriptTypeInfo *ScriptTypeInfo_from_ITypeInfo(ITypeInfo *iface)
 583 {
 584     return CONTAINING_RECORD(iface, ScriptTypeInfo, ITypeInfo_iface);
 585 }
 586
 587 static inline ScriptTypeInfo *ScriptTypeInfo_from_ITypeComp(ITypeComp *iface)
 588 {
 589     return CONTAINING_RECORD(iface, ScriptTypeInfo, ITypeComp_iface);
 590 }
 591
 592 static HRESULT WINAPI ScriptTypeInfo_QueryInterface(ITypeInfo *iface, REFIID riid, void **ppv)
 593 {
 594     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 595
 596     if (IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_ITypeInfo, riid))
 597         *ppv = &This->ITypeInfo_iface;
 598     else if (IsEqualGUID(&IID_ITypeComp, riid))
 599         *ppv = &This->ITypeComp_iface;
 600     else
 601     {
 602         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 603         *ppv = NULL;
 604         return E_NOINTERFACE;
 605     }
 606
 607     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 608     IUnknown_AddRef((IUnknown*)*ppv);
 609     return S_OK;
 610 }
 611
 612 static ULONG WINAPI ScriptTypeInfo_AddRef(ITypeInfo *iface)
 613 {
 614     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 615     LONG ref = InterlockedIncrement(&This->ref);
 616
 617     TRACE("(%p) ref=%d\n", This, ref);
 618
 619     return ref;
 620 }
 621
 622 static ULONG WINAPI ScriptTypeInfo_Release(ITypeInfo *iface)
 623 {
 624     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 625     LONG ref = InterlockedDecrement(&This->ref);
 626     UINT i;
 627
 628     TRACE("(%p) ref=%d\n", This, ref);
 629
 630     if (!ref)
 631     {
 632         for (i = 0; i < This->num_funcs; i++)
 633             release_vbscode(This->funcs[i].func->code_ctx);
 634
 635         IDispatchEx_Release(&This->disp->IDispatchEx_iface);
 636         heap_free(This->funcs);
 637         heap_free(This);
 638     }
 639     return ref;
 640 }
 641
 642 static HRESULT WINAPI ScriptTypeInfo_GetTypeAttr(ITypeInfo *iface, TYPEATTR **ppTypeAttr)
 643 {
 644     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 645     TYPEATTR *attr;
 646
 647     TRACE("(%p)->(%p)\n", This, ppTypeAttr);
 648
 649     if (!ppTypeAttr) return E_INVALIDARG;
 650
 651     attr = heap_alloc_zero(sizeof(*attr));
 652     if (!attr) return E_OUTOFMEMORY;
 653
 654     attr->guid = GUID_VBScriptTypeInfo;
 655     attr->lcid = LOCALE_USER_DEFAULT;
 656     attr->memidConstructor = MEMBERID_NIL;
 657     attr->memidDestructor = MEMBERID_NIL;
 658     attr->cbSizeInstance = 4;
 659     attr->typekind = TKIND_DISPATCH;
 660     attr->cFuncs = This->num_funcs;
 661     attr->cVars = This->num_vars;
 662     attr->cImplTypes = 1;
 663     attr->cbSizeVft = sizeof(IDispatchVtbl);
 664     attr->cbAlignment = 4;
 665     attr->wTypeFlags = TYPEFLAG_FDISPATCHABLE;
 666     attr->wMajorVerNum = VBSCRIPT_MAJOR_VERSION;
 667     attr->wMinorVerNum = VBSCRIPT_MINOR_VERSION;
 668
 669     *ppTypeAttr = attr;
 670     return S_OK;
 671 }
 672
 673 static HRESULT WINAPI ScriptTypeInfo_GetTypeComp(ITypeInfo *iface, ITypeComp **ppTComp)
 674 {
 675     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 676
 677     TRACE("(%p)->(%p)\n", This, ppTComp);
 678
 679     if (!ppTComp) return E_INVALIDARG;
 680
 681     *ppTComp = &This->ITypeComp_iface;
 682     ITypeInfo_AddRef(iface);
 683     return S_OK;
 684 }
 685
 686 static HRESULT WINAPI ScriptTypeInfo_GetFuncDesc(ITypeInfo *iface, UINT index, FUNCDESC **ppFuncDesc)
 687 {
 688     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 689     function_t *func;
 690     FUNCDESC *desc;
 691     UINT i;
 692
 693     TRACE("(%p)->(%u %p)\n", This, index, ppFuncDesc);
 694
 695     if (!ppFuncDesc) return E_INVALIDARG;
 696     if (index >= This->num_funcs) return TYPE_E_ELEMENTNOTFOUND;
 697     func = This->funcs[index].func;
 698
 699     /* Store the parameter array after the FUNCDESC structure */
 700     desc = heap_alloc_zero(sizeof(*desc) + sizeof(ELEMDESC) * func->arg_cnt);
 701     if (!desc) return E_OUTOFMEMORY;
 702
 703     desc->memid = This->funcs[index].memid;
 704     desc->funckind = FUNC_DISPATCH;
 705     desc->invkind = INVOKE_FUNC;
 706     desc->callconv = CC_STDCALL;
 707     desc->cParams = func->arg_cnt;
 708     desc->elemdescFunc.tdesc.vt = (func->type == FUNC_SUB) ? VT_VOID : VT_VARIANT;
 709
 710     if (func->arg_cnt) desc->lprgelemdescParam = (ELEMDESC*)(desc + 1);
 711     for (i = 0; i < func->arg_cnt; i++)
 712         desc->lprgelemdescParam[i].tdesc.vt = VT_VARIANT;
 713
 714     *ppFuncDesc = desc;
 715     return S_OK;
 716 }
 717
 718 static HRESULT WINAPI ScriptTypeInfo_GetVarDesc(ITypeInfo *iface, UINT index, VARDESC **ppVarDesc)
 719 {
 720     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 721     VARDESC *desc;
 722
 723     TRACE("(%p)->(%u %p)\n", This, index, ppVarDesc);
 724
 725     if (!ppVarDesc) return E_INVALIDARG;
 726     if (index >= This->num_vars) return TYPE_E_ELEMENTNOTFOUND;
 727
 728     desc = heap_alloc_zero(sizeof(*desc));
 729     if (!desc) return E_OUTOFMEMORY;
 730
 731     desc->memid = index + 1;
 732     desc->varkind = VAR_DISPATCH;
 733     desc->elemdescVar.tdesc.vt = VT_VARIANT;
 734
 735     *ppVarDesc = desc;
 736     return S_OK;
 737 }
 738
 739 static HRESULT WINAPI ScriptTypeInfo_GetNames(ITypeInfo *iface, MEMBERID memid, BSTR *rgBstrNames,
 740         UINT cMaxNames, UINT *pcNames)
 741 {
 742     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 743     ITypeInfo *disp_typeinfo;
 744     function_t *func;
 745     HRESULT hr;
 746     UINT i = 0;
 747
 748     TRACE("(%p)->(%d %p %u %p)\n", This, memid, rgBstrNames, cMaxNames, pcNames);
 749
 750     if (!rgBstrNames || !pcNames) return E_INVALIDARG;
 751     if (memid <= 0) return TYPE_E_ELEMENTNOTFOUND;
 752
 753     func = get_func_from_memid(This, memid);
 754     if (!func && memid > This->num_vars)
 755     {
 756         hr = get_dispatch_typeinfo(&disp_typeinfo);
 757         if (FAILED(hr)) return hr;
 758
 759         return ITypeInfo_GetNames(disp_typeinfo, memid, rgBstrNames, cMaxNames, pcNames);
 760     }
 761
 762     *pcNames = 0;
 763     if (!cMaxNames) return S_OK;
 764
 765     if (func)
 766     {
 767         UINT num = min(cMaxNames, func->arg_cnt + 1);
 768
 769         rgBstrNames[0] = SysAllocString(func->name);
 770         if (!rgBstrNames[0]) return E_OUTOFMEMORY;
 771
 772         for (i = 1; i < num; i++)
 773         {
 774             if (!(rgBstrNames[i] = SysAllocString(func->args[i - 1].name)))
 775             {
 776                 do SysFreeString(rgBstrNames[--i]); while (i);
 777                 return E_OUTOFMEMORY;
 778             }
 779         }
 780     }
 781     else
 782     {
 783         rgBstrNames[0] = SysAllocString(This->disp->global_vars[memid - 1]->name);
 784         if (!rgBstrNames[0]) return E_OUTOFMEMORY;
 785         i++;
 786     }
 787
 788     *pcNames = i;
 789     return S_OK;
 790 }
 791
 792 static HRESULT WINAPI ScriptTypeInfo_GetRefTypeOfImplType(ITypeInfo *iface, UINT index, HREFTYPE *pRefType)
 793 {
 794     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 795
 796     TRACE("(%p)->(%u %p)\n", This, index, pRefType);
 797
 798     /* We only inherit from IDispatch */
 799     if (!pRefType) return E_INVALIDARG;
 800     if (index != 0) return TYPE_E_ELEMENTNOTFOUND;
 801
 802     *pRefType = 1;
 803     return S_OK;
 804 }
 805
 806 static HRESULT WINAPI ScriptTypeInfo_GetImplTypeFlags(ITypeInfo *iface, UINT index, INT *pImplTypeFlags)
 807 {
 808     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 809
 810     TRACE("(%p)->(%u %p)\n", This, index, pImplTypeFlags);
 811
 812     if (!pImplTypeFlags) return E_INVALIDARG;
 813     if (index != 0) return TYPE_E_ELEMENTNOTFOUND;
 814
 815     *pImplTypeFlags = 0;
 816     return S_OK;
 817 }
 818
 819 static HRESULT WINAPI ScriptTypeInfo_GetIDsOfNames(ITypeInfo *iface, LPOLESTR *rgszNames, UINT cNames,
 820         MEMBERID *pMemId)
 821 {
 822     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 823     ITypeInfo *disp_typeinfo;
 824     const WCHAR *name;
 825     HRESULT hr = S_OK;
 826     int i, j, arg;
 827
 828     TRACE("(%p)->(%p %u %p)\n", This, rgszNames, cNames, pMemId);
 829
 830     if (!rgszNames || !cNames || !pMemId) return E_INVALIDARG;
 831
 832     for (i = 0; i < cNames; i++) pMemId[i] = MEMBERID_NIL;
 833     name = rgszNames[0];
 834
 835     for (i = 0; i < This->num_funcs; i++)
 836     {
 837         function_t *func = This->funcs[i].func;
 838
 839         if (wcsicmp(name, func->name)) continue;
 840         pMemId[0] = This->funcs[i].memid;
 841
 842         for (j = 1; j < cNames; j++)
 843         {
 844             name = rgszNames[j];
 845             for (arg = func->arg_cnt; --arg >= 0;)
 846                 if (!wcsicmp(name, func->args[arg].name))
 847                     break;
 848             if (arg >= 0)
 849                 pMemId[j] = arg;
 850             else
 851                 hr = DISP_E_UNKNOWNNAME;
 852         }
 853         return hr;
 854     }
 855
 856     for (i = 0; i < This->num_vars; i++)
 857     {
 858         if (wcsicmp(name, This->disp->global_vars[i]->name)) continue;
 859         pMemId[0] = i + 1;
 860         return S_OK;
 861     }
 862
 863     /* Look into the inherited IDispatch */
 864     hr = get_dispatch_typeinfo(&disp_typeinfo);
 865     if (FAILED(hr)) return hr;
 866
 867     return ITypeInfo_GetIDsOfNames(disp_typeinfo, rgszNames, cNames, pMemId);
 868 }
 869
 870 static HRESULT WINAPI ScriptTypeInfo_Invoke(ITypeInfo *iface, PVOID pvInstance, MEMBERID memid, WORD wFlags,
 871         DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 872 {
 873     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 874     ITypeInfo *disp_typeinfo;
 875     IDispatch *disp;
 876     HRESULT hr;
 877
 878     TRACE("(%p)->(%p %d %d %p %p %p %p)\n", This, pvInstance, memid, wFlags,
 879           pDispParams, pVarResult, pExcepInfo, puArgErr);
 880
 881     if (!pvInstance) return E_INVALIDARG;
 882     if (memid <= 0) return TYPE_E_ELEMENTNOTFOUND;
 883
 884     if (!get_func_from_memid(This, memid) && memid > This->num_vars)
 885     {
 886         hr = get_dispatch_typeinfo(&disp_typeinfo);
 887         if (FAILED(hr)) return hr;
 888
 889         return ITypeInfo_Invoke(disp_typeinfo, pvInstance, memid, wFlags, pDispParams,
 890                                 pVarResult, pExcepInfo, puArgErr);
 891     }
 892
 893     hr = IUnknown_QueryInterface((IUnknown*)pvInstance, &IID_IDispatch, (void**)&disp);
 894     if (FAILED(hr)) return hr;
 895
 896     hr = IDispatch_Invoke(disp, memid, &IID_NULL, LOCALE_USER_DEFAULT, wFlags,
 897                           pDispParams, pVarResult, pExcepInfo, puArgErr);
 898     IDispatch_Release(disp);
 899
 900     return hr;
 901 }
 902
 903 static HRESULT WINAPI ScriptTypeInfo_GetDocumentation(ITypeInfo *iface, MEMBERID memid, BSTR *pBstrName,
 904         BSTR *pBstrDocString, DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
 905 {
 906     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 907     ITypeInfo *disp_typeinfo;
 908     function_t *func;
 909     HRESULT hr;
 910
 911     TRACE("(%p)->(%d %p %p %p %p)\n", This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
 912
 913     if (pBstrDocString) *pBstrDocString = NULL;
 914     if (pdwHelpContext) *pdwHelpContext = 0;
 915     if (pBstrHelpFile) *pBstrHelpFile = NULL;
 916
 917     if (memid == MEMBERID_NIL)
 918     {
 919         if (pBstrName && !(*pBstrName = SysAllocString(L"VBScriptTypeInfo")))
 920             return E_OUTOFMEMORY;
 921         if (pBstrDocString &&
 922             !(*pBstrDocString = SysAllocString(L"Visual Basic Scripting Type Info")))
 923         {
 924             if (pBstrName) SysFreeString(*pBstrName);
 925             return E_OUTOFMEMORY;
 926         }
 927         return S_OK;
 928     }
 929     if (memid <= 0) return TYPE_E_ELEMENTNOTFOUND;
 930
 931     func = get_func_from_memid(This, memid);
 932     if (!func && memid > This->num_vars)
 933     {
 934         hr = get_dispatch_typeinfo(&disp_typeinfo);
 935         if (FAILED(hr)) return hr;
 936
 937         return ITypeInfo_GetDocumentation(disp_typeinfo, memid, pBstrName, pBstrDocString,
 938                                           pdwHelpContext, pBstrHelpFile);
 939     }
 940
 941     if (pBstrName)
 942     {
 943         *pBstrName = SysAllocString(func ? func->name : This->disp->global_vars[memid - 1]->name);
 944         if (!*pBstrName) return E_OUTOFMEMORY;
 945     }
 946     return S_OK;
 947 }
 948
 949 static HRESULT WINAPI ScriptTypeInfo_GetDllEntry(ITypeInfo *iface, MEMBERID memid, INVOKEKIND invKind,
 950         BSTR *pBstrDllName, BSTR *pBstrName, WORD *pwOrdinal)
 951 {
 952     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 953     ITypeInfo *disp_typeinfo;
 954     HRESULT hr;
 955
 956     TRACE("(%p)->(%d %d %p %p %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
 957
 958     if (pBstrDllName) *pBstrDllName = NULL;
 959     if (pBstrName) *pBstrName = NULL;
 960     if (pwOrdinal) *pwOrdinal = 0;
 961
 962     if (!get_func_from_memid(This, memid) && memid > This->num_vars)
 963     {
 964         hr = get_dispatch_typeinfo(&disp_typeinfo);
 965         if (FAILED(hr)) return hr;
 966
 967         return ITypeInfo_GetDllEntry(disp_typeinfo, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
 968     }
 969     return TYPE_E_BADMODULEKIND;
 970 }
 971
 972 static HRESULT WINAPI ScriptTypeInfo_GetRefTypeInfo(ITypeInfo *iface, HREFTYPE hRefType, ITypeInfo **ppTInfo)
 973 {
 974     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 975     HRESULT hr;
 976
 977     TRACE("(%p)->(%x %p)\n", This, hRefType, ppTInfo);
 978
 979     if (!ppTInfo || (INT)hRefType < 0) return E_INVALIDARG;
 980
 981     if (hRefType & ~3) return E_FAIL;
 982     if (hRefType & 1)
 983     {
 984         hr = get_dispatch_typeinfo(ppTInfo);
 985         if (FAILED(hr)) return hr;
 986     }
 987     else
 988         *ppTInfo = iface;
 989
 990     ITypeInfo_AddRef(*ppTInfo);
 991     return S_OK;
 992 }
 993
 994 static HRESULT WINAPI ScriptTypeInfo_AddressOfMember(ITypeInfo *iface, MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
 995 {
 996     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
 997     ITypeInfo *disp_typeinfo;
 998     HRESULT hr;
 999
1000     TRACE("(%p)->(%d %d %p)\n", This, memid, invKind, ppv);
1001
1002     if (!ppv) return E_INVALIDARG;
1003     *ppv = NULL;
1004
1005     if (!get_func_from_memid(This, memid) && memid > This->num_vars)
1006     {
1007         hr = get_dispatch_typeinfo(&disp_typeinfo);
1008         if (FAILED(hr)) return hr;
1009
1010         return ITypeInfo_AddressOfMember(disp_typeinfo, memid, invKind, ppv);
1011     }
1012     return TYPE_E_BADMODULEKIND;
1013 }
1014
1015 static HRESULT WINAPI ScriptTypeInfo_CreateInstance(ITypeInfo *iface, IUnknown *pUnkOuter, REFIID riid, PVOID *ppvObj)
1016 {
1017     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1018
1019     TRACE("(%p)->(%p %s %p)\n", This, pUnkOuter, debugstr_guid(riid), ppvObj);
1020
1021     if (!ppvObj) return E_INVALIDARG;
1022
1023     *ppvObj = NULL;
1024     return TYPE_E_BADMODULEKIND;
1025 }
1026
1027 static HRESULT WINAPI ScriptTypeInfo_GetMops(ITypeInfo *iface, MEMBERID memid, BSTR *pBstrMops)
1028 {
1029     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1030     ITypeInfo *disp_typeinfo;
1031     HRESULT hr;
1032
1033     TRACE("(%p)->(%d %p)\n", This, memid, pBstrMops);
1034
1035     if (!pBstrMops) return E_INVALIDARG;
1036
1037     if (!get_func_from_memid(This, memid) && memid > This->num_vars)
1038     {
1039         hr = get_dispatch_typeinfo(&disp_typeinfo);
1040         if (FAILED(hr)) return hr;
1041
1042         return ITypeInfo_GetMops(disp_typeinfo, memid, pBstrMops);
1043     }
1044
1045     *pBstrMops = NULL;
1046     return S_OK;
1047 }
1048
1049 static HRESULT WINAPI ScriptTypeInfo_GetContainingTypeLib(ITypeInfo *iface, ITypeLib **ppTLib, UINT *pIndex)
1050 {
1051     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1052
1053     FIXME("(%p)->(%p %p)\n", This, ppTLib, pIndex);
1054
1055     return E_NOTIMPL;
1056 }
1057
1058 static void WINAPI ScriptTypeInfo_ReleaseTypeAttr(ITypeInfo *iface, TYPEATTR *pTypeAttr)
1059 {
1060     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1061
1062     TRACE("(%p)->(%p)\n", This, pTypeAttr);
1063
1064     heap_free(pTypeAttr);
1065 }
1066
1067 static void WINAPI ScriptTypeInfo_ReleaseFuncDesc(ITypeInfo *iface, FUNCDESC *pFuncDesc)
1068 {
1069     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1070
1071     TRACE("(%p)->(%p)\n", This, pFuncDesc);
1072
1073     heap_free(pFuncDesc);
1074 }
1075
1076 static void WINAPI ScriptTypeInfo_ReleaseVarDesc(ITypeInfo *iface, VARDESC *pVarDesc)
1077 {
1078     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeInfo(iface);
1079
1080     TRACE("(%p)->(%p)\n", This, pVarDesc);
1081
1082     heap_free(pVarDesc);
1083 }
1084
1085 static const ITypeInfoVtbl ScriptTypeInfoVtbl = {
1086     ScriptTypeInfo_QueryInterface,
1087     ScriptTypeInfo_AddRef,
1088     ScriptTypeInfo_Release,
1089     ScriptTypeInfo_GetTypeAttr,
1090     ScriptTypeInfo_GetTypeComp,
1091     ScriptTypeInfo_GetFuncDesc,
1092     ScriptTypeInfo_GetVarDesc,
1093     ScriptTypeInfo_GetNames,
1094     ScriptTypeInfo_GetRefTypeOfImplType,
1095     ScriptTypeInfo_GetImplTypeFlags,
1096     ScriptTypeInfo_GetIDsOfNames,
1097     ScriptTypeInfo_Invoke,
1098     ScriptTypeInfo_GetDocumentation,
1099     ScriptTypeInfo_GetDllEntry,
1100     ScriptTypeInfo_GetRefTypeInfo,
1101     ScriptTypeInfo_AddressOfMember,
1102     ScriptTypeInfo_CreateInstance,
1103     ScriptTypeInfo_GetMops,
1104     ScriptTypeInfo_GetContainingTypeLib,
1105     ScriptTypeInfo_ReleaseTypeAttr,
1106     ScriptTypeInfo_ReleaseFuncDesc,
1107     ScriptTypeInfo_ReleaseVarDesc
1108 };
1109
1110 static HRESULT WINAPI ScriptTypeComp_QueryInterface(ITypeComp *iface, REFIID riid, void **ppv)
1111 {
1112     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeComp(iface);
1113     return ITypeInfo_QueryInterface(&This->ITypeInfo_iface, riid, ppv);
1114 }
1115
1116 static ULONG WINAPI ScriptTypeComp_AddRef(ITypeComp *iface)
1117 {
1118     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeComp(iface);
1119     return ITypeInfo_AddRef(&This->ITypeInfo_iface);
1120 }
1121
1122 static ULONG WINAPI ScriptTypeComp_Release(ITypeComp *iface)
1123 {
1124     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeComp(iface);
1125     return ITypeInfo_Release(&This->ITypeInfo_iface);
1126 }
1127
1128 static HRESULT WINAPI ScriptTypeComp_Bind(ITypeComp *iface, LPOLESTR szName, ULONG lHashVal, WORD wFlags,
1129         ITypeInfo **ppTInfo, DESCKIND *pDescKind, BINDPTR *pBindPtr)
1130 {
1131     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeComp(iface);
1132     UINT flags = wFlags ? wFlags : ~0;
1133     ITypeInfo *disp_typeinfo;
1134     ITypeComp *disp_typecomp;
1135     HRESULT hr;
1136     UINT i;
1137
1138     TRACE("(%p)->(%s %08x %d %p %p %p)\n", This, debugstr_w(szName), lHashVal,
1139           wFlags, ppTInfo, pDescKind, pBindPtr);
1140
1141     if (!szName || !ppTInfo || !pDescKind || !pBindPtr)
1142         return E_INVALIDARG;
1143
1144     for (i = 0; i < This->num_funcs; i++)
1145     {
1146         if (wcsicmp(szName, This->funcs[i].func->name)) continue;
1147         if (!(flags & INVOKE_FUNC)) return TYPE_E_TYPEMISMATCH;
1148
1149         hr = ITypeInfo_GetFuncDesc(&This->ITypeInfo_iface, i, &pBindPtr->lpfuncdesc);
1150         if (FAILED(hr)) return hr;
1151
1152         *pDescKind = DESCKIND_FUNCDESC;
1153         *ppTInfo = &This->ITypeInfo_iface;
1154         ITypeInfo_AddRef(*ppTInfo);
1155         return S_OK;
1156     }
1157
1158     for (i = 0; i < This->num_vars; i++)
1159     {
1160         if (wcsicmp(szName, This->disp->global_vars[i]->name)) continue;
1161         if (!(flags & INVOKE_PROPERTYGET)) return TYPE_E_TYPEMISMATCH;
1162
1163         hr = ITypeInfo_GetVarDesc(&This->ITypeInfo_iface, i, &pBindPtr->lpvardesc);
1164         if (FAILED(hr)) return hr;
1165
1166         *pDescKind = DESCKIND_VARDESC;
1167         *ppTInfo = &This->ITypeInfo_iface;
1168         ITypeInfo_AddRef(*ppTInfo);
1169         return S_OK;
1170     }
1171
1172     /* Look into the inherited IDispatch */
1173     hr = get_dispatch_typeinfo(&disp_typeinfo);
1174     if (FAILED(hr)) return hr;
1175
1176     hr = ITypeInfo_GetTypeComp(disp_typeinfo, &disp_typecomp);
1177     if (FAILED(hr)) return hr;
1178
1179     hr = ITypeComp_Bind(disp_typecomp, szName, lHashVal, wFlags, ppTInfo, pDescKind, pBindPtr);
1180     ITypeComp_Release(disp_typecomp);
1181     return hr;
1182 }
1183
1184 static HRESULT WINAPI ScriptTypeComp_BindType(ITypeComp *iface, LPOLESTR szName, ULONG lHashVal,
1185         ITypeInfo **ppTInfo, ITypeComp **ppTComp)
1186 {
1187     ScriptTypeInfo *This = ScriptTypeInfo_from_ITypeComp(iface);
1188     ITypeInfo *disp_typeinfo;
1189     ITypeComp *disp_typecomp;
1190     HRESULT hr;
1191
1192     TRACE("(%p)->(%s %08x %p %p)\n", This, debugstr_w(szName), lHashVal, ppTInfo, ppTComp);
1193
1194     if (!szName || !ppTInfo || !ppTComp)
1195         return E_INVALIDARG;
1196
1197     /* Look into the inherited IDispatch */
1198     hr = get_dispatch_typeinfo(&disp_typeinfo);
1199     if (FAILED(hr)) return hr;
1200
1201     hr = ITypeInfo_GetTypeComp(disp_typeinfo, &disp_typecomp);
1202     if (FAILED(hr)) return hr;
1203
1204     hr = ITypeComp_BindType(disp_typecomp, szName, lHashVal, ppTInfo, ppTComp);
1205     ITypeComp_Release(disp_typecomp);
1206     return hr;
1207 }
1208
1209 static const ITypeCompVtbl ScriptTypeCompVtbl = {
1210     ScriptTypeComp_QueryInterface,
1211     ScriptTypeComp_AddRef,
1212     ScriptTypeComp_Release,
1213     ScriptTypeComp_Bind,
1214     ScriptTypeComp_BindType
1215 };
1216
1217 static inline ScriptDisp *ScriptDisp_from_IDispatchEx(IDispatchEx *iface)
1218 {
1219     return CONTAINING_RECORD(iface, ScriptDisp, IDispatchEx_iface);
1220 }
1221
1222 static HRESULT WINAPI ScriptDisp_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
1223 {
1224     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1225
1226     if(IsEqualGUID(&IID_IUnknown, riid)) {
1227         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1228         *ppv = &This->IDispatchEx_iface;
1229     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1230         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1231         *ppv = &This->IDispatchEx_iface;
1232     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
1233         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1234         *ppv = &This->IDispatchEx_iface;
1235     }else {
1236         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1237         *ppv = NULL;
1238         return E_NOINTERFACE;
1239     }
1240
1241     IUnknown_AddRef((IUnknown*)*ppv);
1242     return S_OK;
1243 }
1244
1245 static ULONG WINAPI ScriptDisp_AddRef(IDispatchEx *iface)
1246 {
1247     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1248     LONG ref = InterlockedIncrement(&This->ref);
1249
1250     TRACE("(%p) ref=%d\n", This, ref);
1251
1252     return ref;
1253 }
1254
1255 static ULONG WINAPI ScriptDisp_Release(IDispatchEx *iface)
1256 {
1257     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1258     LONG ref = InterlockedDecrement(&This->ref);
1259     unsigned i;
1260
1261     TRACE("(%p) ref=%d\n", This, ref);
1262
1263     if(!ref) {
1264         assert(!This->ctx);
1265
1266         for (i = 0; i < This->global_vars_cnt; i++)
1267             release_dynamic_var(This->global_vars[i]);
1268
1269         heap_pool_free(&This->heap);
1270         heap_free(This->global_vars);
1271         heap_free(This->global_funcs);
1272         heap_free(This);
1273     }
1274
1275     return ref;
1276 }
1277
1278 static HRESULT WINAPI ScriptDisp_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
1279 {
1280     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1281
1282     TRACE("(%p)->(%p)\n", This, pctinfo);
1283
1284     *pctinfo = 1;
1285     return S_OK;
1286 }
1287
1288 static HRESULT WINAPI ScriptDisp_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid, ITypeInfo **ret)
1289 {
1290     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1291     ScriptTypeInfo *type_info;
1292     UINT num_funcs = 0;
1293     unsigned i, j;
1294
1295     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ret);
1296
1297     if(iTInfo)
1298         return DISP_E_BADINDEX;
1299
1300     if(!(type_info = heap_alloc(sizeof(*type_info))))
1301         return E_OUTOFMEMORY;
1302
1303     for(i = 0; i < This->global_funcs_cnt; i++)
1304         if(This->global_funcs[i]->is_public)
1305             num_funcs++;
1306
1307     type_info->ITypeInfo_iface.lpVtbl = &ScriptTypeInfoVtbl;
1308     type_info->ITypeComp_iface.lpVtbl = &ScriptTypeCompVtbl;
1309     type_info->ref = 1;
1310     type_info->num_funcs = num_funcs;
1311     type_info->num_vars = This->global_vars_cnt;
1312     type_info->disp = This;
1313
1314     type_info->funcs = heap_alloc(sizeof(*type_info->funcs) * num_funcs);
1315     if(!type_info->funcs)
1316     {
1317         heap_free(type_info);
1318         return E_OUTOFMEMORY;
1319     }
1320
1321     for(j = 0, i = 0; i < This->global_funcs_cnt; i++)
1322     {
1323         if(!This->global_funcs[i]->is_public) continue;
1324
1325         type_info->funcs[j].memid = i + 1 + DISPID_FUNCTION_MASK;
1326         type_info->funcs[j].func = This->global_funcs[i];
1327         grab_vbscode(This->global_funcs[i]->code_ctx);
1328         j++;
1329     }
1330
1331     IDispatchEx_AddRef(&This->IDispatchEx_iface);
1332
1333     *ret = &type_info->ITypeInfo_iface;
1334     return S_OK;
1335 }
1336
1337 static HRESULT WINAPI ScriptDisp_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1338         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
1339 {
1340     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1341     UINT i;
1342     HRESULT hres;
1343
1344     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1345           lcid, rgDispId);
1346
1347     for(i=0; i < cNames; i++) {
1348         hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
1349         if(FAILED(hres))
1350             return hres;
1351     }
1352
1353     return S_OK;
1354 }
1355
1356 static HRESULT WINAPI ScriptDisp_Invoke(IDispatchEx *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1357          WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1358 {
1359     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1360
1361     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1362           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1363
1364     return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
1365             pDispParams, pVarResult, pExcepInfo, NULL);
1366 }
1367
1368 static HRESULT WINAPI ScriptDisp_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
1369 {
1370     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1371     unsigned i;
1372
1373     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
1374
1375     if(!This->ctx)
1376         return E_UNEXPECTED;
1377
1378     for(i = 0; i < This->global_vars_cnt; i++) {
1379         if(!wcsicmp(This->global_vars[i]->name, bstrName)) {
1380             *pid = i + 1;
1381             return S_OK;
1382         }
1383     }
1384
1385     for(i = 0; i < This->global_funcs_cnt; i++) {
1386         if(!wcsicmp(This->global_funcs[i]->name, bstrName)) {
1387             *pid = i + 1 + DISPID_FUNCTION_MASK;
1388             return S_OK;
1389         }
1390     }
1391
1392     *pid = -1;
1393     return DISP_E_UNKNOWNNAME;
1394 }
1395
1396 static HRESULT WINAPI ScriptDisp_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1397         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1398 {
1399     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1400     HRESULT hres;
1401
1402     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1403
1404     if (!This->ctx)
1405         return E_UNEXPECTED;
1406
1407     if (id & DISPID_FUNCTION_MASK)
1408     {
1409         id &= ~DISPID_FUNCTION_MASK;
1410         if (id > This->global_funcs_cnt)
1411             return DISP_E_MEMBERNOTFOUND;
1412
1413         switch (wFlags)
1414         {
1415         case DISPATCH_METHOD:
1416         case DISPATCH_METHOD | DISPATCH_PROPERTYGET:
1417             hres = exec_script(This->ctx, TRUE, This->global_funcs[id - 1], NULL, pdp, pvarRes);
1418             break;
1419         default:
1420             FIXME("Unsupported flags %x\n", wFlags);
1421             hres = E_NOTIMPL;
1422         }
1423
1424         return hres;
1425     }
1426
1427     if (id > This->global_vars_cnt)
1428         return DISP_E_MEMBERNOTFOUND;
1429
1430     if (This->global_vars[id - 1]->is_const)
1431     {
1432         FIXME("const not supported\n");
1433         return E_NOTIMPL;
1434     }
1435
1436     return invoke_variant_prop(This->ctx, &This->global_vars[id - 1]->v, wFlags, pdp, pvarRes);
1437 }
1438
1439 static HRESULT WINAPI ScriptDisp_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
1440 {
1441     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1442     FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
1443     return E_NOTIMPL;
1444 }
1445
1446 static HRESULT WINAPI ScriptDisp_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
1447 {
1448     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1449     FIXME("(%p)->(%x)\n", This, id);
1450     return E_NOTIMPL;
1451 }
1452
1453 static HRESULT WINAPI ScriptDisp_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
1454 {
1455     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1456     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
1457     return E_NOTIMPL;
1458 }
1459
1460 static HRESULT WINAPI ScriptDisp_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
1461 {
1462     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1463     FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
1464     return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI ScriptDisp_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
1468 {
1469     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1470     FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
1471     return E_NOTIMPL;
1472 }
1473
1474 static HRESULT WINAPI ScriptDisp_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
1475 {
1476     ScriptDisp *This = ScriptDisp_from_IDispatchEx(iface);
1477     FIXME("(%p)->(%p)\n", This, ppunk);
1478     return E_NOTIMPL;
1479 }
1480
1481 static IDispatchExVtbl ScriptDispVtbl = {
1482     ScriptDisp_QueryInterface,
1483     ScriptDisp_AddRef,
1484     ScriptDisp_Release,
1485     ScriptDisp_GetTypeInfoCount,
1486     ScriptDisp_GetTypeInfo,
1487     ScriptDisp_GetIDsOfNames,
1488     ScriptDisp_Invoke,
1489     ScriptDisp_GetDispID,
1490     ScriptDisp_InvokeEx,
1491     ScriptDisp_DeleteMemberByName,
1492     ScriptDisp_DeleteMemberByDispID,
1493     ScriptDisp_GetMemberProperties,
1494     ScriptDisp_GetMemberName,
1495     ScriptDisp_GetNextDispID,
1496     ScriptDisp_GetNameSpaceParent
1497 };
1498
1499 HRESULT create_script_disp(script_ctx_t *ctx, ScriptDisp **ret)
1500 {
1501     ScriptDisp *script_disp;
1502
1503     script_disp = heap_alloc_zero(sizeof(*script_disp));
1504     if(!script_disp)
1505         return E_OUTOFMEMORY;
1506
1507     script_disp->IDispatchEx_iface.lpVtbl = &ScriptDispVtbl;
1508     script_disp->ref = 1;
1509     script_disp->ctx = ctx;
1510     heap_pool_init(&script_disp->heap);
1511
1512     *ret = script_disp;
1513     return S_OK;
1514 }
1515
1516 void collect_objects(script_ctx_t *ctx)
1517 {
1518     vbdisp_t *iter, *iter2;
1519
1520     LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
1521         run_terminator(iter);
1522
1523     while(!list_empty(&ctx->objects)) {
1524         iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
1525
1526         IDispatchEx_AddRef(&iter->IDispatchEx_iface);
1527         clean_props(iter);
1528         iter->desc = NULL;
1529         list_remove(&iter->entry);
1530         list_init(&iter->entry);
1531         IDispatchEx_Release(&iter->IDispatchEx_iface);
1532     }
1533 }
1534
1535 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
1536 {
1537     IDispatchEx *dispex;
1538     vbdisp_t *vbdisp;
1539     HRESULT hres;
1540
1541     vbdisp = unsafe_impl_from_IDispatch(disp);
1542     if(vbdisp)
1543         return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
1544
1545     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1546     if(FAILED(hres)) {
1547         TRACE("using IDispatch\n");
1548         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
1549     }
1550
1551     hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
1552     IDispatchEx_Release(dispex);
1553     return hres;
1554 }
1555
1556 #define RPC_E_SERVER_UNAVAILABLE 0x800706ba
1557
1558 HRESULT map_hres(HRESULT hres)
1559 {
1560     if(SUCCEEDED(hres) || HRESULT_FACILITY(hres) == FACILITY_VBS)
1561         return hres;
1562
1563     switch(hres) {
1564     case E_NOTIMPL:                  return MAKE_VBSERROR(VBSE_ACTION_NOT_SUPPORTED);
1565     case E_NOINTERFACE:              return MAKE_VBSERROR(VBSE_OLE_NOT_SUPPORTED);
1566     case DISP_E_UNKNOWNINTERFACE:    return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
1567     case DISP_E_MEMBERNOTFOUND:      return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
1568     case DISP_E_PARAMNOTFOUND:       return MAKE_VBSERROR(VBSE_NAMED_PARAM_NOT_FOUND);
1569     case DISP_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
1570     case DISP_E_UNKNOWNNAME:         return MAKE_VBSERROR(VBSE_OLE_NO_PROP_OR_METHOD);
1571     case DISP_E_NONAMEDARGS:         return MAKE_VBSERROR(VBSE_NAMED_ARGS_NOT_SUPPORTED);
1572     case DISP_E_BADVARTYPE:          return MAKE_VBSERROR(VBSE_INVALID_TYPELIB_VARIABLE);
1573     case DISP_E_OVERFLOW:            return MAKE_VBSERROR(VBSE_OVERFLOW);
1574     case DISP_E_BADINDEX:            return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1575     case DISP_E_UNKNOWNLCID:         return MAKE_VBSERROR(VBSE_LOCALE_SETTING_NOT_SUPPORTED);
1576     case DISP_E_ARRAYISLOCKED:       return MAKE_VBSERROR(VBSE_ARRAY_LOCKED);
1577     case DISP_E_BADPARAMCOUNT:       return MAKE_VBSERROR(VBSE_FUNC_ARITY_MISMATCH);
1578     case DISP_E_PARAMNOTOPTIONAL:    return MAKE_VBSERROR(VBSE_PARAMETER_NOT_OPTIONAL);
1579     case DISP_E_NOTACOLLECTION:      return MAKE_VBSERROR(VBSE_NOT_ENUM);
1580     case TYPE_E_DLLFUNCTIONNOTFOUND: return MAKE_VBSERROR(VBSE_INVALID_DLL_FUNCTION_NAME);
1581     case TYPE_E_TYPEMISMATCH:        return MAKE_VBSERROR(VBSE_TYPE_MISMATCH);
1582     case TYPE_E_OUTOFBOUNDS:         return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1583     case TYPE_E_IOERROR:             return MAKE_VBSERROR(VBSE_IO_ERROR);
1584     case TYPE_E_CANTCREATETMPFILE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_TMP_FILE);
1585     case STG_E_FILENOTFOUND:         return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
1586     case STG_E_PATHNOTFOUND:         return MAKE_VBSERROR(VBSE_PATH_NOT_FOUND);
1587     case STG_E_TOOMANYOPENFILES:     return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
1588     case STG_E_ACCESSDENIED:         return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1589     case STG_E_INSUFFICIENTMEMORY:   return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
1590     case STG_E_NOMOREFILES:          return MAKE_VBSERROR(VBSE_TOO_MANY_FILES);
1591     case STG_E_DISKISWRITEPROTECTED: return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1592     case STG_E_WRITEFAULT:           return MAKE_VBSERROR(VBSE_IO_ERROR);
1593     case STG_E_READFAULT:            return MAKE_VBSERROR(VBSE_IO_ERROR);
1594     case STG_E_SHAREVIOLATION:       return MAKE_VBSERROR(VBSE_PATH_FILE_ACCESS);
1595     case STG_E_LOCKVIOLATION:        return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1596     case STG_E_FILEALREADYEXISTS:    return MAKE_VBSERROR(VBSE_FILE_ALREADY_EXISTS);
1597     case STG_E_MEDIUMFULL:           return MAKE_VBSERROR(VBSE_DISK_FULL);
1598     case STG_E_INVALIDNAME:          return MAKE_VBSERROR(VBSE_FILE_NOT_FOUND);
1599     case STG_E_INUSE:                return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1600     case STG_E_NOTCURRENT:           return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1601     case STG_E_CANTSAVE:             return MAKE_VBSERROR(VBSE_IO_ERROR);
1602     case REGDB_E_CLASSNOTREG:        return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1603     case MK_E_UNAVAILABLE:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1604     case MK_E_INVALIDEXTENSION:      return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
1605     case MK_E_CANTOPENFILE:          return MAKE_VBSERROR(VBSE_OLE_FILE_NOT_FOUND);
1606     case CO_E_CLASSSTRING:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1607     case CO_E_APPNOTFOUND:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1608     case CO_E_APPDIDNTREG:           return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1609     case E_ACCESSDENIED:             return MAKE_VBSERROR(VBSE_PERMISSION_DENIED);
1610     case E_OUTOFMEMORY:              return MAKE_VBSERROR(VBSE_OUT_OF_MEMORY);
1611     case E_INVALIDARG:               return MAKE_VBSERROR(VBSE_ILLEGAL_FUNC_CALL);
1612     case RPC_E_SERVER_UNAVAILABLE:   return MAKE_VBSERROR(VBSE_SERVER_NOT_FOUND);
1613     case CO_E_SERVER_EXEC_FAILURE:   return MAKE_VBSERROR(VBSE_CANT_CREATE_OBJECT);
1614     }
1615
1616     return hres;
1617 }
1618
1619 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
1620 {
1621     const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
1622     IDispatchEx *dispex;
1623     vbdisp_t *vbdisp;
1624     EXCEPINFO ei;
1625     HRESULT hres;
1626
1627     memset(&ei, 0, sizeof(ei));
1628     if(retv)
1629         V_VT(retv) = VT_EMPTY;
1630
1631     vbdisp = unsafe_impl_from_IDispatch(disp);
1632     if(vbdisp && vbdisp->desc && vbdisp->desc->ctx == ctx)
1633         return invoke_vbdisp(vbdisp, id, flags, FALSE, dp, retv);
1634
1635     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1636     if(SUCCEEDED(hres)) {
1637         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
1638         IDispatchEx_Release(dispex);
1639     }else {
1640         UINT err = 0;
1641
1642         TRACE("using IDispatch\n");
1643         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
1644     }
1645
1646     if(hres == DISP_E_EXCEPTION) {
1647         clear_ei(&ctx->ei);
1648         ctx->ei = ei;
1649         hres = SCRIPT_E_RECORDED;
1650     }
1651     return hres;
1652 }
1653
1654 HRESULT get_disp_value(script_ctx_t *ctx, IDispatch *disp, VARIANT *v)
1655 {
1656     DISPPARAMS dp = {NULL};
1657     if(!disp)
1658         return MAKE_VBSERROR(VBSE_OBJECT_VARIABLE_NOT_SET);
1659     return disp_call(ctx, disp, DISPID_VALUE, &dp, v);
1660 }
1661
1662 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp)
1663 {
1664     IDispatchEx *dispex;
1665     vbdisp_t *vbdisp;
1666     EXCEPINFO ei = {0};
1667     HRESULT hres;
1668
1669     vbdisp = unsafe_impl_from_IDispatch(disp);
1670     if(vbdisp && vbdisp->desc && vbdisp->desc->ctx == ctx)
1671         return invoke_vbdisp(vbdisp, id, flags, FALSE, dp, NULL);
1672
1673     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1674     if(SUCCEEDED(hres)) {
1675         hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, NULL, &ei, NULL /* FIXME! */);
1676         IDispatchEx_Release(dispex);
1677     }else {
1678         ULONG err = 0;
1679
1680         TRACE("using IDispatch\n");
1681         hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, NULL, &ei, &err);
1682     }
1683
1684     if(hres == DISP_E_EXCEPTION) {
1685         clear_ei(&ctx->ei);
1686         ctx->ei = ei;
1687         hres = SCRIPT_E_RECORDED;
1688     }
1689     return hres;
1690 }