dlls/msxml3/dispex.c

   1 /*
   2  * Copyright 2008 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 #define COBJMACROS
  20
  21 #include "config.h"
  22
  23 #include <stdarg.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winnls.h"
  28 #include "ole2.h"
  29 #include "msxml6.h"
  30 #include "wininet.h"
  31 #include "urlmon.h"
  32 #include "winreg.h"
  33 #include "shlwapi.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/list.h"
  37 #include "wine/unicode.h"
  38
  39 #include "msxml_private.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msxml);
  42
  43 #define DISPATCHEX(x)  ((IDispatchEx*)  &(x)->lpIDispatchExVtbl)
  44
  45 typedef struct {
  46     DISPID id;
  47     BSTR name;
  48     enum tid_t tid;
  49 } func_info_t;
  50
  51 struct dispex_data_t {
  52     DWORD func_cnt;
  53     func_info_t *funcs;
  54     func_info_t **name_table;
  55
  56     struct list entry;
  57 };
  58
  59 typedef struct {
  60     VARIANT var;
  61     LPWSTR name;
  62 } dynamic_prop_t;
  63
  64 struct dispex_dynamic_data_t {
  65     DWORD buf_size;
  66     DWORD prop_cnt;
  67     dynamic_prop_t *props;
  68 };
  69
  70 #define DISPID_DYNPROP_0    0x50000000
  71 #define DISPID_DYNPROP_MAX  0x5fffffff
  72
  73 static struct list dispex_data_list = LIST_INIT(dispex_data_list);
  74 static ITypeLib *typelib;
  75 static ITypeInfo *typeinfos[LAST_tid];
  76
  77 static REFIID tid_ids[] = {
  78     &IID_IXMLDOMAttribute,
  79     &IID_IXMLDOMCDATASection,
  80     &IID_IXMLDOMComment,
  81     &IID_IXMLDOMDocument,
  82     &IID_IXMLDOMDocument2,
  83     &IID_IXMLDOMDocumentFragment,
  84     &IID_IXMLDOMDocumentType,
  85     &IID_IXMLDOMElement,
  86     &IID_IXMLDOMEntityReference,
  87     &IID_IXMLDOMImplementation,
  88     &IID_IXMLDOMNamedNodeMap,
  89     &IID_IXMLDOMNode,
  90     &IID_IXMLDOMNodeList,
  91     &IID_IXMLDOMParseError,
  92     &IID_IXMLDOMProcessingInstruction,
  93     &IID_IXMLDOMSchemaCollection,
  94     &IID_IXMLDOMSelection,
  95     &IID_IXMLDOMText,
  96     &IID_IXMLElement,
  97     &IID_IXMLDOMDocument,
  98     &IID_IXMLHTTPRequest,
  99     &IID_IXSLTemplate,
 100     &IID_IVBSAXAttributes,
 101     &IID_IVBSAXContentHandler,
 102     &IID_IVBSAXDeclHandler,
 103     &IID_IVBSAXDTDHandler,
 104     &IID_IVBSAXEntityResolver,
 105     &IID_IVBSAXErrorHandler,
 106     &IID_IVBSAXLexicalHandler,
 107     &IID_IVBSAXLocator,
 108     &IID_IVBSAXXMLFilter,
 109     &IID_IVBSAXXMLReader,
 110     &IID_IMXAttributes,
 111     &IID_IMXReaderControl,
 112     &IID_IMXWriter,
 113 };
 114
 115 HRESULT get_typeinfo(enum tid_t tid, ITypeInfo **typeinfo)
 116 {
 117     HRESULT hres;
 118
 119     if(!typelib) {
 120         ITypeLib *tl;
 121
 122         hres = LoadRegTypeLib(&LIBID_MSXML2, 3, 0, LOCALE_SYSTEM_DEFAULT, &tl);
 123         if(FAILED(hres)) {
 124             ERR("LoadRegTypeLib failed: %08x\n", hres);
 125             return hres;
 126         }
 127
 128         if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
 129             ITypeLib_Release(tl);
 130     }
 131
 132     if(!typeinfos[tid]) {
 133         ITypeInfo *typeinfo;
 134
 135         hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &typeinfo);
 136         if(FAILED(hres)) {
 137             ERR("GetTypeInfoOfGuid failed: %08x\n", hres);
 138             return hres;
 139         }
 140
 141         if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), typeinfo, NULL))
 142             ITypeInfo_Release(typeinfo);
 143     }
 144
 145     *typeinfo = typeinfos[tid];
 146
 147     ITypeInfo_AddRef(typeinfos[tid]);
 148     return S_OK;
 149 }
 150
 151 void release_typelib(void)
 152 {
 153     dispex_data_t *iter;
 154     unsigned i;
 155
 156     while(!list_empty(&dispex_data_list)) {
 157         iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
 158         list_remove(&iter->entry);
 159
 160         for(i=0; i < iter->func_cnt; i++)
 161             SysFreeString(iter->funcs[i].name);
 162
 163         heap_free(iter->funcs);
 164         heap_free(iter->name_table);
 165         heap_free(iter);
 166     }
 167
 168     if(!typelib)
 169         return;
 170
 171     for(i=0; i < sizeof(typeinfos)/sizeof(*typeinfos); i++)
 172         if(typeinfos[i])
 173             ITypeInfo_Release(typeinfos[i]);
 174
 175     ITypeLib_Release(typelib);
 176 }
 177
 178 static void add_func_info(dispex_data_t *data, DWORD *size, tid_t tid, DISPID id, ITypeInfo *dti)
 179 {
 180     HRESULT hres;
 181
 182     if(data->func_cnt && data->funcs[data->func_cnt-1].id == id)
 183         return;
 184
 185     if(data->func_cnt == *size)
 186         data->funcs = heap_realloc(data->funcs, (*size <<= 1)*sizeof(func_info_t));
 187
 188     hres = ITypeInfo_GetDocumentation(dti, id, &data->funcs[data->func_cnt].name, NULL, NULL, NULL);
 189     if(FAILED(hres))
 190         return;
 191
 192     data->funcs[data->func_cnt].id = id;
 193     data->funcs[data->func_cnt].tid = tid;
 194
 195     data->func_cnt++;
 196 }
 197
 198 static int dispid_cmp(const void *p1, const void *p2)
 199 {
 200     return ((const func_info_t*)p1)->id - ((const func_info_t*)p2)->id;
 201 }
 202
 203 static int func_name_cmp(const void *p1, const void *p2)
 204 {
 205     return strcmpiW((*(func_info_t* const*)p1)->name, (*(func_info_t* const*)p2)->name);
 206 }
 207
 208 static dispex_data_t *preprocess_dispex_data(DispatchEx *This)
 209 {
 210     const tid_t *tid = This->data->iface_tids;
 211     FUNCDESC *funcdesc;
 212     dispex_data_t *data;
 213     DWORD size = 16, i;
 214     ITypeInfo *ti, *dti;
 215     HRESULT hres;
 216
 217     TRACE("(%p)\n", This);
 218
 219     hres = get_typeinfo(This->data->disp_tid, &dti);
 220     if(FAILED(hres)) {
 221         ERR("Could not get disp type info: %08x\n", hres);
 222         return NULL;
 223     }
 224
 225     data = heap_alloc(sizeof(dispex_data_t));
 226     data->func_cnt = 0;
 227     data->funcs = heap_alloc(size*sizeof(func_info_t));
 228     list_add_tail(&dispex_data_list, &data->entry);
 229
 230     while(*tid) {
 231         hres = get_typeinfo(*tid, &ti);
 232         if(FAILED(hres))
 233             break;
 234
 235         i=0;
 236         while(1) {
 237             hres = ITypeInfo_GetFuncDesc(ti, i++, &funcdesc);
 238             if(FAILED(hres))
 239                 break;
 240
 241             add_func_info(data, &size, *tid, funcdesc->memid, dti);
 242             ITypeInfo_ReleaseFuncDesc(ti, funcdesc);
 243         }
 244
 245         ITypeInfo_Release(ti);
 246         tid++;
 247     }
 248
 249     if(!data->func_cnt) {
 250         heap_free(data->funcs);
 251         data->funcs = NULL;
 252     }else if(data->func_cnt != size) {
 253         data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
 254     }
 255
 256     qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
 257
 258     if(data->funcs) {
 259         data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
 260         for(i=0; i < data->func_cnt; i++)
 261             data->name_table[i] = data->funcs+i;
 262         qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp);
 263     }else {
 264         data->name_table = NULL;
 265     }
 266
 267     ITypeInfo_Release(dti);
 268     return data;
 269 }
 270
 271 static CRITICAL_SECTION cs_dispex_static_data;
 272 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg =
 273 {
 274     0, 0, &cs_dispex_static_data,
 275     { &cs_dispex_static_data_dbg.ProcessLocksList, &cs_dispex_static_data_dbg.ProcessLocksList },
 276       0, 0, { (DWORD_PTR)(__FILE__ ": dispex_static_data") }
 277 };
 278 static CRITICAL_SECTION cs_dispex_static_data = { &cs_dispex_static_data_dbg, -1, 0, 0, 0, 0 };
 279
 280
 281 static dispex_data_t *get_dispex_data(DispatchEx *This)
 282 {
 283     if(This->data->data)
 284         return This->data->data;
 285
 286     EnterCriticalSection(&cs_dispex_static_data);
 287
 288     if(!This->data->data)
 289         This->data->data = preprocess_dispex_data(This);
 290
 291     LeaveCriticalSection(&cs_dispex_static_data);
 292
 293     return This->data->data;
 294 }
 295
 296 static inline BOOL is_custom_dispid(DISPID id)
 297 {
 298     return MSXML_DISPID_CUSTOM_MIN <= id && id <= MSXML_DISPID_CUSTOM_MAX;
 299 }
 300
 301 static inline BOOL is_dynamic_dispid(DISPID id)
 302 {
 303     return DISPID_DYNPROP_0 <= id && id <= DISPID_DYNPROP_MAX;
 304 }
 305
 306 static inline DispatchEx *impl_from_IDispatchEx(IDispatchEx *iface)
 307 {
 308     return (DispatchEx*)((char*)iface - FIELD_OFFSET(DispatchEx, lpIDispatchExVtbl));
 309 }
 310
 311 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
 312 {
 313     DispatchEx *This = impl_from_IDispatchEx(iface);
 314
 315     return IUnknown_QueryInterface(This->outer, riid, ppv);
 316 }
 317
 318 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
 319 {
 320     DispatchEx *This = impl_from_IDispatchEx(iface);
 321
 322     return IUnknown_AddRef(This->outer);
 323 }
 324
 325 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
 326 {
 327     DispatchEx *This = impl_from_IDispatchEx(iface);
 328
 329     return IUnknown_Release(This->outer);
 330 }
 331
 332 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
 333 {
 334     DispatchEx *This = impl_from_IDispatchEx(iface);
 335
 336     TRACE("(%p)->(%p)\n", This, pctinfo);
 337
 338     *pctinfo = 1;
 339     return S_OK;
 340 }
 341
 342 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
 343                                               LCID lcid, ITypeInfo **ppTInfo)
 344 {
 345     DispatchEx *This = impl_from_IDispatchEx(iface);
 346
 347     TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
 348
 349     return get_typeinfo(This->data->disp_tid, ppTInfo);
 350 }
 351
 352 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
 353                                                 LPOLESTR *rgszNames, UINT cNames,
 354                                                 LCID lcid, DISPID *rgDispId)
 355 {
 356     DispatchEx *This = impl_from_IDispatchEx(iface);
 357     UINT i;
 358     HRESULT hres;
 359
 360     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
 361           lcid, rgDispId);
 362
 363     for(i=0; i < cNames; i++) {
 364         hres = IDispatchEx_GetDispID(DISPATCHEX(This), rgszNames[i], 0, rgDispId+i);
 365         if(FAILED(hres))
 366             return hres;
 367     }
 368
 369     return S_OK;
 370 }
 371
 372 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
 373                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 374                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 375 {
 376     DispatchEx *This = impl_from_IDispatchEx(iface);
 377
 378     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
 379           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 380
 381     return IDispatchEx_InvokeEx(DISPATCHEX(This), dispIdMember, lcid, wFlags,
 382                                 pDispParams, pVarResult, pExcepInfo, NULL);
 383 }
 384
 385 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
 386 {
 387     DispatchEx *This = impl_from_IDispatchEx(iface);
 388     dispex_data_t *data;
 389     int min, max, n, c;
 390
 391     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
 392
 393     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit))
 394         FIXME("Unsupported grfdex %x\n", grfdex);
 395
 396     data = get_dispex_data(This);
 397     if(!data)
 398         return E_FAIL;
 399
 400     min = 0;
 401     max = data->func_cnt-1;
 402
 403     while(min <= max) {
 404         n = (min+max)/2;
 405
 406         c = strcmpiW(data->name_table[n]->name, bstrName);
 407         if(!c) {
 408             if((grfdex & fdexNameCaseSensitive) && strcmpW(data->name_table[n]->name, bstrName))
 409                 break;
 410
 411             *pid = data->name_table[n]->id;
 412             return S_OK;
 413         }
 414
 415         if(c > 0)
 416             max = n-1;
 417         else
 418             min = n+1;
 419     }
 420
 421     if(This->dynamic_data) {
 422         unsigned i;
 423
 424         for(i=0; i < This->dynamic_data->prop_cnt; i++) {
 425             if(!strcmpW(This->dynamic_data->props[i].name, bstrName)) {
 426                 *pid = DISPID_DYNPROP_0 + i;
 427                 return S_OK;
 428             }
 429         }
 430     }
 431
 432     if(This->data->vtbl && This->data->vtbl->get_dispid) {
 433         HRESULT hres;
 434
 435         hres = This->data->vtbl->get_dispid(This->outer, bstrName, grfdex, pid);
 436         if(hres != DISP_E_UNKNOWNNAME)
 437             return hres;
 438     }
 439
 440     if(grfdex & fdexNameEnsure) {
 441         dispex_dynamic_data_t *dynamic_data;
 442
 443         TRACE("creating dynamic prop %s\n", debugstr_w(bstrName));
 444
 445         if(This->dynamic_data) {
 446             dynamic_data = This->dynamic_data;
 447         }else {
 448             dynamic_data = This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t));
 449             if(!dynamic_data)
 450                 return E_OUTOFMEMORY;
 451         }
 452
 453         if(!dynamic_data->buf_size) {
 454             dynamic_data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
 455             if(!dynamic_data->props)
 456                 return E_OUTOFMEMORY;
 457             dynamic_data->buf_size = 4;
 458         }else if(dynamic_data->buf_size == dynamic_data->prop_cnt) {
 459             dynamic_prop_t *new_props;
 460
 461             new_props = heap_realloc(dynamic_data->props, sizeof(dynamic_prop_t)*(dynamic_data->buf_size<<1));
 462             if(!new_props)
 463                 return E_OUTOFMEMORY;
 464
 465             dynamic_data->props = new_props;
 466             dynamic_data->buf_size <<= 1;
 467         }
 468
 469         dynamic_data->props[dynamic_data->prop_cnt].name = heap_strdupW(bstrName);
 470         VariantInit(&dynamic_data->props[dynamic_data->prop_cnt].var);
 471         *pid = DISPID_DYNPROP_0 + dynamic_data->prop_cnt++;
 472
 473         return S_OK;
 474     }
 475
 476     TRACE("not found %s\n", debugstr_w(bstrName));
 477     return DISP_E_UNKNOWNNAME;
 478 }
 479
 480 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
 481         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
 482 {
 483     DispatchEx *This = impl_from_IDispatchEx(iface);
 484     IUnknown *unk;
 485     ITypeInfo *ti;
 486     dispex_data_t *data;
 487     UINT argerr=0;
 488     int min, max, n;
 489     HRESULT hres;
 490
 491     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
 492
 493     if(is_custom_dispid(id) && This->data->vtbl && This->data->vtbl->invoke)
 494         return This->data->vtbl->invoke(This->outer, id, lcid, wFlags, pdp, pvarRes, pei);
 495
 496     if(wFlags == DISPATCH_CONSTRUCT) {
 497         FIXME("DISPATCH_CONSTRUCT not implemented\n");
 498         return E_NOTIMPL;
 499     }
 500
 501     if(is_dynamic_dispid(id)) {
 502         DWORD idx = id - DISPID_DYNPROP_0;
 503         VARIANT *var;
 504
 505         if(!This->dynamic_data || This->dynamic_data->prop_cnt <= idx)
 506             return DISP_E_UNKNOWNNAME;
 507
 508         var = &This->dynamic_data->props[idx].var;
 509
 510         switch(wFlags) {
 511         case INVOKE_PROPERTYGET:
 512             return VariantCopy(pvarRes, var);
 513         case INVOKE_PROPERTYPUT:
 514             VariantClear(var);
 515             return VariantCopy(var, pdp->rgvarg);
 516         default:
 517             FIXME("unhandled wFlags %x\n", wFlags);
 518             return E_NOTIMPL;
 519         }
 520     }
 521
 522     data = get_dispex_data(This);
 523     if(!data)
 524         return E_FAIL;
 525
 526     min = 0;
 527     max = data->func_cnt-1;
 528
 529     while(min <= max) {
 530         n = (min+max)/2;
 531
 532         if(data->funcs[n].id == id)
 533             break;
 534
 535         if(data->funcs[n].id < id)
 536             min = n+1;
 537         else
 538             max = n-1;
 539     }
 540
 541     if(min > max) {
 542         WARN("invalid id %x\n", id);
 543         return DISP_E_UNKNOWNNAME;
 544     }
 545
 546     hres = get_typeinfo(data->funcs[n].tid, &ti);
 547     if(FAILED(hres)) {
 548         ERR("Could not get type info: %08x\n", hres);
 549         return hres;
 550     }
 551
 552     hres = IUnknown_QueryInterface(This->outer, tid_ids[data->funcs[n].tid], (void**)&unk);
 553     if(FAILED(hres)) {
 554         ERR("Could not get iface: %08x\n", hres);
 555         return E_FAIL;
 556     }
 557
 558     hres = ITypeInfo_Invoke(ti, unk, id, wFlags, pdp, pvarRes, pei, &argerr);
 559
 560     ITypeInfo_Release(ti);
 561     IUnknown_Release(unk);
 562     return hres;
 563 }
 564
 565 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
 566 {
 567     DispatchEx *This = impl_from_IDispatchEx(iface);
 568     TRACE("Not implemented in native msxml3 (%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
 573 {
 574     DispatchEx *This = impl_from_IDispatchEx(iface);
 575     TRACE("Not implemented in native msxml3 (%p)->(%x)\n", This, id);
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
 580 {
 581     DispatchEx *This = impl_from_IDispatchEx(iface);
 582     TRACE("Not implemented in native msxml3 (%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
 587 {
 588     DispatchEx *This = impl_from_IDispatchEx(iface);
 589     TRACE("Not implemented in native msxml3 (%p)->(%x %p)\n", This, id, pbstrName);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
 594 {
 595     DispatchEx *This = impl_from_IDispatchEx(iface);
 596     TRACE(" Not implemented in native msxml3 (%p)->(%x %x %p)\n", This, grfdex, id, pid);
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
 601 {
 602     DispatchEx *This = impl_from_IDispatchEx(iface);
 603     TRACE("Not implemented in native msxml3 (%p)->(%p)\n", This, ppunk);
 604     return E_NOTIMPL;
 605 }
 606
 607 static IDispatchExVtbl DispatchExVtbl = {
 608     DispatchEx_QueryInterface,
 609     DispatchEx_AddRef,
 610     DispatchEx_Release,
 611     DispatchEx_GetTypeInfoCount,
 612     DispatchEx_GetTypeInfo,
 613     DispatchEx_GetIDsOfNames,
 614     DispatchEx_Invoke,
 615     DispatchEx_GetDispID,
 616     DispatchEx_InvokeEx,
 617     DispatchEx_DeleteMemberByName,
 618     DispatchEx_DeleteMemberByDispID,
 619     DispatchEx_GetMemberProperties,
 620     DispatchEx_GetMemberName,
 621     DispatchEx_GetNextDispID,
 622     DispatchEx_GetNameSpaceParent
 623 };
 624
 625 BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
 626 {
 627     static const IID IID_UndocumentedScriptIface =
 628         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa0}};
 629
 630     if(IsEqualGUID(&IID_IDispatch, riid)) {
 631         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
 632         *ppv = DISPATCHEX(This);
 633     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
 634         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
 635         *ppv = DISPATCHEX(This);
 636     }else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid)) {
 637         TRACE("(%p)->(IID_UndocumentedScriptIface %p) returning NULL\n", This, ppv);
 638         *ppv = NULL;
 639     }else if (IsEqualGUID(&IID_IObjectIdentity, riid)) {
 640         TRACE("IID_IObjectIdentity not supported returning NULL\n");
 641         *ppv = NULL;
 642     }else {
 643         return FALSE;
 644     }
 645
 646     if(*ppv)
 647         IUnknown_AddRef((IUnknown*)*ppv);
 648     return TRUE;
 649 }
 650
 651 void init_dispex(DispatchEx *dispex, IUnknown *outer, dispex_static_data_t *data)
 652 {
 653     dispex->lpIDispatchExVtbl = &DispatchExVtbl;
 654     dispex->outer = outer;
 655     dispex->data = data;
 656 }