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