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