?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hidclass.sys: Support parsing of explicit usage page.
[wine.git] / dlls / mshtml / dispex.c
blob39630590228cd140ac99b534ad00f2ed13d4df87
1 /*
2 * Copyright 2008-2009 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 <stdarg.h>
20 #include <assert.h>
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "ole2.h"
29 #include "mscoree.h"
30
31 #include "wine/debug.h"
32
33 #include "mshtml_private.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
36
37 #define MAX_ARGS 16
38
39 static CRITICAL_SECTION cs_dispex_static_data;
40 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg =
41 {
42 0, 0, &cs_dispex_static_data,
43 { &cs_dispex_static_data_dbg.ProcessLocksList, &cs_dispex_static_data_dbg.ProcessLocksList },
44 0, 0, { (DWORD_PTR)(__FILE__ ": dispex_static_data") }
45 };
46 static CRITICAL_SECTION cs_dispex_static_data = { &cs_dispex_static_data_dbg, -1, 0, 0, 0, 0 };
47
48 typedef struct {
49 IID iid;
50 VARIANT default_value;
51 } func_arg_info_t;
52
53 typedef struct {
54 DISPID id;
55 BSTR name;
56 tid_t tid;
57 dispex_hook_invoke_t hook;
58 SHORT call_vtbl_off;
59 SHORT put_vtbl_off;
60 SHORT get_vtbl_off;
61 SHORT func_disp_idx;
62 USHORT argc;
63 USHORT default_value_cnt;
64 VARTYPE prop_vt;
65 VARTYPE *arg_types;
66 func_arg_info_t *arg_info;
67 } func_info_t;
68
69 struct dispex_data_t {
70 dispex_static_data_t *desc;
71 compat_mode_t compat_mode;
72
73 DWORD func_cnt;
74 DWORD func_size;
75 func_info_t *funcs;
76 func_info_t **name_table;
77 DWORD func_disp_cnt;
78
79 struct list entry;
80 };
81
82 typedef struct {
83 VARIANT var;
84 LPWSTR name;
85 DWORD flags;
86 } dynamic_prop_t;
87
88 #define DYNPROP_DELETED 0x01
89
90 typedef struct {
91 DispatchEx dispex;
92 IUnknown IUnknown_iface;
93 LONG ref;
94 DispatchEx *obj;
95 func_info_t *info;
96 } func_disp_t;
97
98 typedef struct {
99 func_disp_t *func_obj;
100 VARIANT val;
101 } func_obj_entry_t;
102
103 struct dispex_dynamic_data_t {
104 DWORD buf_size;
105 DWORD prop_cnt;
106 dynamic_prop_t *props;
107 func_obj_entry_t *func_disps;
108 };
109
110 #define DISPID_DYNPROP_0 0x50000000
111 #define DISPID_DYNPROP_MAX 0x5fffffff
112
113 #define FDEX_VERSION_MASK 0xf0000000
114
115 static ITypeLib *typelib;
116 static ITypeInfo *typeinfos[LAST_tid];
117 static struct list dispex_data_list = LIST_INIT(dispex_data_list);
118
119 static REFIID tid_ids[] = {
120 #define XIID(iface) &IID_ ## iface,
121 #define XDIID(iface) &DIID_ ## iface,
122 TID_LIST
123 #undef XIID
124 #undef XDIID
125 };
126
127 static HRESULT load_typelib(void)
128 {
129 HRESULT hres;
130 ITypeLib *tl;
131
132 hres = LoadRegTypeLib(&LIBID_MSHTML, 4, 0, LOCALE_SYSTEM_DEFAULT, &tl);
133 if(FAILED(hres)) {
134 ERR("LoadRegTypeLib failed: %08x\n", hres);
135 return hres;
136 }
137
138 if(InterlockedCompareExchangePointer((void**)&typelib, tl, NULL))
139 ITypeLib_Release(tl);
140 return hres;
141 }
142
143 static HRESULT get_typeinfo(tid_t tid, ITypeInfo **typeinfo)
144 {
145 HRESULT hres;
146
147 if (!typelib)
148 hres = load_typelib();
149 if (!typelib)
150 return hres;
151
152 if(!typeinfos[tid]) {
153 ITypeInfo *ti;
154
155 hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
156 if(FAILED(hres)) {
157 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_mshtml_guid(tid_ids[tid]), hres);
158 return hres;
159 }
160
161 if(InterlockedCompareExchangePointer((void**)(typeinfos+tid), ti, NULL))
162 ITypeInfo_Release(ti);
163 }
164
165 *typeinfo = typeinfos[tid];
166 return S_OK;
167 }
168
169 void release_typelib(void)
170 {
171 dispex_data_t *iter;
172 unsigned i, j;
173
174 while(!list_empty(&dispex_data_list)) {
175 iter = LIST_ENTRY(list_head(&dispex_data_list), dispex_data_t, entry);
176 list_remove(&iter->entry);
177
178 for(i = 0; i < iter->func_cnt; i++) {
179 if(iter->funcs[i].default_value_cnt && iter->funcs[i].arg_info) {
180 for(j = 0; j < iter->funcs[i].argc; j++)
181 VariantClear(&iter->funcs[i].arg_info[j].default_value);
182 }
183 heap_free(iter->funcs[i].arg_types);
184 heap_free(iter->funcs[i].arg_info);
185 SysFreeString(iter->funcs[i].name);
186 }
187
188 heap_free(iter->funcs);
189 heap_free(iter->name_table);
190 heap_free(iter);
191 }
192
193 if(!typelib)
194 return;
195
196 for(i=0; i < ARRAY_SIZE(typeinfos); i++)
197 if(typeinfos[i])
198 ITypeInfo_Release(typeinfos[i]);
199
200 ITypeLib_Release(typelib);
201 DeleteCriticalSection(&cs_dispex_static_data);
202 }
203
204 HRESULT get_class_typeinfo(const CLSID *clsid, ITypeInfo **typeinfo)
205 {
206 HRESULT hres;
207
208 if (!typelib)
209 hres = load_typelib();
210 if (!typelib)
211 return hres;
212
213 hres = ITypeLib_GetTypeInfoOfGuid(typelib, clsid, typeinfo);
214 if(FAILED(hres))
215 ERR("GetTypeInfoOfGuid failed: %08x\n", hres);
216 return hres;
217 }
218
219 /* Not all argument types are supported yet */
220 #define BUILTIN_ARG_TYPES_SWITCH \
221 CASE_VT(VT_I2, INT16, V_I2); \
222 CASE_VT(VT_UI2, UINT16, V_UI2); \
223 CASE_VT(VT_I4, INT32, V_I4); \
224 CASE_VT(VT_UI4, UINT32, V_UI4); \
225 CASE_VT(VT_R4, float, V_R4); \
226 CASE_VT(VT_BSTR, BSTR, V_BSTR); \
227 CASE_VT(VT_DISPATCH, IDispatch*, V_DISPATCH); \
228 CASE_VT(VT_BOOL, VARIANT_BOOL, V_BOOL)
229
230 /* List all types used by IDispatchEx-based properties */
231 #define BUILTIN_TYPES_SWITCH \
232 BUILTIN_ARG_TYPES_SWITCH; \
233 CASE_VT(VT_VARIANT, VARIANT, *); \
234 CASE_VT(VT_PTR, void*, V_BYREF); \
235 CASE_VT(VT_UNKNOWN, IUnknown*, V_UNKNOWN); \
236 CASE_VT(VT_UI8, ULONGLONG, V_UI8)
237
238 static BOOL is_arg_type_supported(VARTYPE vt)
239 {
240 switch(vt) {
241 #define CASE_VT(x,a,b) case x: return TRUE
242 BUILTIN_ARG_TYPES_SWITCH;
243 #undef CASE_VT
244 }
245 return FALSE;
246 }
247
248 static void add_func_info(dispex_data_t *data, tid_t tid, const FUNCDESC *desc, ITypeInfo *dti,
249 dispex_hook_invoke_t hook)
250 {
251 func_info_t *info;
252 BSTR name;
253 HRESULT hres;
254
255 hres = ITypeInfo_GetDocumentation(dti, desc->memid, &name, NULL, NULL, NULL);
256 if(FAILED(hres)) {
257 WARN("GetDocumentation failed: %08x\n", hres);
258 return;
259 }
260
261 for(info = data->funcs; info < data->funcs+data->func_cnt; info++) {
262 if(info->id == desc->memid || !wcscmp(info->name, name)) {
263 if(info->tid != tid) {
264 SysFreeString(name);
265 return; /* Duplicated in other interface */
266 }
267 break;
268 }
269 }
270
271 TRACE("adding %s...\n", debugstr_w(name));
272
273 if(info == data->funcs+data->func_cnt) {
274 if(data->func_cnt == data->func_size)
275 data->funcs = heap_realloc_zero(data->funcs, (data->func_size <<= 1)*sizeof(func_info_t));
276 info = data->funcs+data->func_cnt;
277
278 data->func_cnt++;
279
280 info->id = desc->memid;
281 info->name = name;
282 info->tid = tid;
283 info->func_disp_idx = -1;
284 info->prop_vt = VT_EMPTY;
285 info->hook = hook;
286 }else {
287 SysFreeString(name);
288 }
289
290 if(desc->invkind & DISPATCH_METHOD) {
291 unsigned i;
292
293 info->func_disp_idx = data->func_disp_cnt++;
294 info->argc = desc->cParams;
295
296 assert(info->argc < MAX_ARGS);
297 assert(desc->funckind == FUNC_DISPATCH);
298
299 info->arg_info = heap_alloc_zero(sizeof(*info->arg_info) * info->argc);
300 if(!info->arg_info)
301 return;
302
303 info->prop_vt = desc->elemdescFunc.tdesc.vt;
304 if(info->prop_vt != VT_VOID && info->prop_vt != VT_PTR && !is_arg_type_supported(info->prop_vt)) {
305 TRACE("%s: return type %d\n", debugstr_w(info->name), info->prop_vt);
306 return; /* Fallback to ITypeInfo::Invoke */
307 }
308
309 info->arg_types = heap_alloc(sizeof(*info->arg_types) * (info->argc + (info->prop_vt == VT_VOID ? 0 : 1)));
310 if(!info->arg_types)
311 return;
312
313 for(i=0; i < info->argc; i++)
314 info->arg_types[i] = desc->lprgelemdescParam[i].tdesc.vt;
315
316 if(info->prop_vt == VT_PTR)
317 info->arg_types[info->argc] = VT_BYREF | VT_DISPATCH;
318 else if(info->prop_vt != VT_VOID)
319 info->arg_types[info->argc] = VT_BYREF | info->prop_vt;
320
321 if(desc->cParamsOpt) {
322 TRACE("%s: optional params\n", debugstr_w(info->name));
323 return; /* Fallback to ITypeInfo::Invoke */
324 }
325
326 for(i=0; i < info->argc; i++) {
327 TYPEDESC *tdesc = &desc->lprgelemdescParam[i].tdesc;
328 if(tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED) {
329 ITypeInfo *ref_type_info;
330 TYPEATTR *attr;
331
332 hres = ITypeInfo_GetRefTypeInfo(dti, tdesc->u.lptdesc->u.hreftype, &ref_type_info);
333 if(FAILED(hres)) {
334 ERR("Could not get referenced type info: %08x\n", hres);
335 return;
336 }
337
338 hres = ITypeInfo_GetTypeAttr(ref_type_info, &attr);
339 if(SUCCEEDED(hres)) {
340 assert(attr->typekind == TKIND_DISPATCH);
341 info->arg_info[i].iid = attr->guid;
342 ITypeInfo_ReleaseTypeAttr(ref_type_info, attr);
343 }else {
344 ERR("GetTypeAttr failed: %08x\n", hres);
345 }
346 ITypeInfo_Release(ref_type_info);
347 if(FAILED(hres))
348 return;
349 info->arg_types[i] = VT_DISPATCH;
350 }else if(!is_arg_type_supported(info->arg_types[i])) {
351 TRACE("%s: unsupported arg type %s\n", debugstr_w(info->name), debugstr_vt(info->arg_types[i]));
352 return; /* Fallback to ITypeInfo for unsupported arg types */
353 }
354
355 if(desc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
356 hres = VariantCopy(&info->arg_info[i].default_value,
357 &desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
358 if(FAILED(hres)) {
359 ERR("Could not copy default value: %08x\n", hres);
360 return;
361 }
362 TRACE("%s param %d: default value %s\n", debugstr_w(info->name),
363 i, debugstr_variant(&info->arg_info[i].default_value));
364 info->default_value_cnt++;
365 }
366 }
367
368 assert(info->argc <= MAX_ARGS);
369 assert(desc->callconv == CC_STDCALL);
370
371 info->call_vtbl_off = desc->oVft/sizeof(void*);
372 }else if(desc->invkind & (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYGET)) {
373 VARTYPE vt = VT_EMPTY;
374
375 if(desc->invkind & DISPATCH_PROPERTYGET) {
376 vt = desc->elemdescFunc.tdesc.vt;
377 info->get_vtbl_off = desc->oVft/sizeof(void*);
378 }
379 if(desc->invkind & DISPATCH_PROPERTYPUT) {
380 assert(desc->cParams == 1);
381 vt = desc->lprgelemdescParam->tdesc.vt;
382 info->put_vtbl_off = desc->oVft/sizeof(void*);
383 }
384
385 assert(info->prop_vt == VT_EMPTY || vt == info->prop_vt);
386 info->prop_vt = vt;
387 }
388 }
389
390 static HRESULT process_interface(dispex_data_t *data, tid_t tid, ITypeInfo *disp_typeinfo, const dispex_hook_t *hooks)
391 {
392 unsigned i = 7; /* skip IDispatch functions */
393 ITypeInfo *typeinfo;
394 FUNCDESC *funcdesc;
395 HRESULT hres;
396
397 hres = get_typeinfo(tid, &typeinfo);
398 if(FAILED(hres))
399 return hres;
400
401 while(1) {
402 const dispex_hook_t *hook = NULL;
403
404 hres = ITypeInfo_GetFuncDesc(typeinfo, i++, &funcdesc);
405 if(FAILED(hres))
406 break;
407
408 if(hooks) {
409 for(hook = hooks; hook->dispid != DISPID_UNKNOWN; hook++) {
410 if(hook->dispid == funcdesc->memid)
411 break;
412 }
413 if(hook->dispid == DISPID_UNKNOWN)
414 hook = NULL;
415 }
416
417 if(!hook || hook->invoke) {
418 add_func_info(data, tid, funcdesc, disp_typeinfo ? disp_typeinfo : typeinfo,
419 hook ? hook->invoke : NULL);
420 }
421
422 ITypeInfo_ReleaseFuncDesc(typeinfo, funcdesc);
423 }
424
425 return S_OK;
426 }
427
428 void dispex_info_add_interface(dispex_data_t *info, tid_t tid, const dispex_hook_t *hooks)
429 {
430 HRESULT hres;
431
432 hres = process_interface(info, tid, NULL, hooks);
433 if(FAILED(hres))
434 ERR("process_interface failed: %08x\n", hres);
435 }
436
437 static int __cdecl dispid_cmp(const void *p1, const void *p2)
438 {
439 return ((const func_info_t*)p1)->id - ((const func_info_t*)p2)->id;
440 }
441
442 static int __cdecl func_name_cmp(const void *p1, const void *p2)
443 {
444 return wcsicmp((*(func_info_t* const*)p1)->name, (*(func_info_t* const*)p2)->name);
445 }
446
447 static dispex_data_t *preprocess_dispex_data(dispex_static_data_t *desc, compat_mode_t compat_mode)
448 {
449 const tid_t *tid;
450 dispex_data_t *data;
451 DWORD i;
452 ITypeInfo *dti;
453 HRESULT hres;
454
455 if(desc->disp_tid) {
456 hres = get_typeinfo(desc->disp_tid, &dti);
457 if(FAILED(hres)) {
458 ERR("Could not get disp type info: %08x\n", hres);
459 return NULL;
460 }
461 }
462
463 data = heap_alloc(sizeof(dispex_data_t));
464 if (!data) {
465 ERR("Out of memory\n");
466 return NULL;
467 }
468 data->desc = desc;
469 data->compat_mode = compat_mode;
470 data->func_cnt = 0;
471 data->func_disp_cnt = 0;
472 data->func_size = 16;
473 data->funcs = heap_alloc_zero(data->func_size*sizeof(func_info_t));
474 if (!data->funcs) {
475 heap_free (data);
476 ERR("Out of memory\n");
477 return NULL;
478 }
479 list_add_tail(&dispex_data_list, &data->entry);
480
481 if(desc->init_info)
482 desc->init_info(data, compat_mode);
483
484 for(tid = desc->iface_tids; *tid; tid++) {
485 hres = process_interface(data, *tid, dti, NULL);
486 if(FAILED(hres))
487 break;
488 }
489
490 if(!data->func_cnt) {
491 heap_free(data->funcs);
492 data->name_table = NULL;
493 data->funcs = NULL;
494 data->func_size = 0;
495 return data;
496 }
497
498
499 data->funcs = heap_realloc(data->funcs, data->func_cnt * sizeof(func_info_t));
500 qsort(data->funcs, data->func_cnt, sizeof(func_info_t), dispid_cmp);
501
502 data->name_table = heap_alloc(data->func_cnt * sizeof(func_info_t*));
503 for(i=0; i < data->func_cnt; i++)
504 data->name_table[i] = data->funcs+i;
505 qsort(data->name_table, data->func_cnt, sizeof(func_info_t*), func_name_cmp);
506 return data;
507 }
508
509 static int __cdecl id_cmp(const void *p1, const void *p2)
510 {
511 return *(const DISPID*)p1 - *(const DISPID*)p2;
512 }
513
514 HRESULT get_dispids(tid_t tid, DWORD *ret_size, DISPID **ret)
515 {
516 unsigned i, func_cnt;
517 FUNCDESC *funcdesc;
518 ITypeInfo *ti;
519 TYPEATTR *attr;
520 DISPID *ids;
521 HRESULT hres;
522
523 hres = get_typeinfo(tid, &ti);
524 if(FAILED(hres))
525 return hres;
526
527 hres = ITypeInfo_GetTypeAttr(ti, &attr);
528 if(FAILED(hres)) {
529 ITypeInfo_Release(ti);
530 return hres;
531 }
532
533 func_cnt = attr->cFuncs;
534 ITypeInfo_ReleaseTypeAttr(ti, attr);
535
536 ids = heap_alloc(func_cnt*sizeof(DISPID));
537 if(!ids) {
538 ITypeInfo_Release(ti);
539 return E_OUTOFMEMORY;
540 }
541
542 for(i=0; i < func_cnt; i++) {
543 hres = ITypeInfo_GetFuncDesc(ti, i, &funcdesc);
544 if(FAILED(hres))
545 break;
546
547 ids[i] = funcdesc->memid;
548 ITypeInfo_ReleaseFuncDesc(ti, funcdesc);
549 }
550
551 ITypeInfo_Release(ti);
552 if(FAILED(hres)) {
553 heap_free(ids);
554 return hres;
555 }
556
557 qsort(ids, func_cnt, sizeof(DISPID), id_cmp);
558
559 *ret_size = func_cnt;
560 *ret = ids;
561 return S_OK;
562 }
563
564 static inline BOOL is_custom_dispid(DISPID id)
565 {
566 return MSHTML_DISPID_CUSTOM_MIN <= id && id <= MSHTML_DISPID_CUSTOM_MAX;
567 }
568
569 static inline BOOL is_dynamic_dispid(DISPID id)
570 {
571 return DISPID_DYNPROP_0 <= id && id <= DISPID_DYNPROP_MAX;
572 }
573
574 dispex_prop_type_t get_dispid_type(DISPID id)
575 {
576 if(is_dynamic_dispid(id))
577 return DISPEXPROP_DYNAMIC;
578 if(is_custom_dispid(id))
579 return DISPEXPROP_CUSTOM;
580 return DISPEXPROP_BUILTIN;
581 }
582
583 static HRESULT variant_copy(VARIANT *dest, VARIANT *src)
584 {
585 if(V_VT(src) == VT_BSTR && !V_BSTR(src)) {
586 V_VT(dest) = VT_BSTR;
587 V_BSTR(dest) = NULL;
588 return S_OK;
589 }
590
591 return VariantCopy(dest, src);
592 }
593
594 static inline dispex_dynamic_data_t *get_dynamic_data(DispatchEx *This)
595 {
596 if(This->dynamic_data)
597 return This->dynamic_data;
598
599 This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t));
600 if(!This->dynamic_data)
601 return NULL;
602
603 if(This->info->desc->vtbl && This->info->desc->vtbl->populate_props)
604 This->info->desc->vtbl->populate_props(This);
605
606 return This->dynamic_data;
607 }
608
609 static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, DWORD flags, dynamic_prop_t **ret)
610 {
611 const BOOL alloc = flags & fdexNameEnsure;
612 dispex_dynamic_data_t *data;
613 dynamic_prop_t *prop;
614
615 data = get_dynamic_data(This);
616 if(!data)
617 return E_OUTOFMEMORY;
618
619 for(prop = data->props; prop < data->props+data->prop_cnt; prop++) {
620 if(flags & fdexNameCaseInsensitive ? !wcsicmp(prop->name, name) : !wcscmp(prop->name, name)) {
621 if(prop->flags & DYNPROP_DELETED) {
622 if(!alloc)
623 return DISP_E_UNKNOWNNAME;
624 prop->flags &= ~DYNPROP_DELETED;
625 }
626 *ret = prop;
627 return S_OK;
628 }
629 }
630
631 if(!alloc)
632 return DISP_E_UNKNOWNNAME;
633
634 TRACE("creating dynamic prop %s\n", debugstr_w(name));
635
636 if(!data->buf_size) {
637 data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
638 if(!data->props)
639 return E_OUTOFMEMORY;
640 data->buf_size = 4;
641 }else if(data->buf_size == data->prop_cnt) {
642 dynamic_prop_t *new_props;
643
644 new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1));
645 if(!new_props)
646 return E_OUTOFMEMORY;
647
648 data->props = new_props;
649 data->buf_size <<= 1;
650 }
651
652 prop = data->props + data->prop_cnt;
653
654 prop->name = heap_strdupW(name);
655 if(!prop->name)
656 return E_OUTOFMEMORY;
657
658 VariantInit(&prop->var);
659 prop->flags = 0;
660 data->prop_cnt++;
661 *ret = prop;
662 return S_OK;
663 }
664
665 HRESULT dispex_get_dprop_ref(DispatchEx *This, const WCHAR *name, BOOL alloc, VARIANT **ret)
666 {
667 dynamic_prop_t *prop;
668 HRESULT hres;
669
670 hres = get_dynamic_prop(This, name, alloc ? fdexNameEnsure : 0, &prop);
671 if(FAILED(hres))
672 return hres;
673
674 *ret = &prop->var;
675 return S_OK;
676 }
677
678 HRESULT dispex_get_dynid(DispatchEx *This, const WCHAR *name, DISPID *id)
679 {
680 dynamic_prop_t *prop;
681 HRESULT hres;
682
683 hres = get_dynamic_prop(This, name, fdexNameEnsure, &prop);
684 if(FAILED(hres))
685 return hres;
686
687 *id = DISPID_DYNPROP_0 + (prop - This->dynamic_data->props);
688 return S_OK;
689 }
690
691 static HRESULT dispex_value(DispatchEx *This, LCID lcid, WORD flags, DISPPARAMS *params,
692 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
693 {
694 if(This->info->desc->vtbl && This->info->desc->vtbl->value)
695 return This->info->desc->vtbl->value(This, lcid, flags, params, res, ei, caller);
696
697 switch(flags) {
698 case DISPATCH_PROPERTYGET:
699 V_VT(res) = VT_BSTR;
700 V_BSTR(res) = SysAllocString(L"[object]");
701 if(!V_BSTR(res))
702 return E_OUTOFMEMORY;
703 break;
704 default:
705 FIXME("Unimplemented flags %x\n", flags);
706 return E_NOTIMPL;
707 }
708
709 return S_OK;
710 }
711
712 static HRESULT typeinfo_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res,
713 EXCEPINFO *ei)
714 {
715 DISPPARAMS params = {dp->rgvarg+dp->cNamedArgs, NULL, dp->cArgs-dp->cNamedArgs, 0};
716 ITypeInfo *ti;
717 IUnknown *unk;
718 UINT argerr=0;
719 HRESULT hres;
720
721 hres = get_typeinfo(func->tid, &ti);
722 if(FAILED(hres)) {
723 ERR("Could not get type info: %08x\n", hres);
724 return hres;
725 }
726
727 hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&unk);
728 if(FAILED(hres)) {
729 ERR("Could not get iface %s: %08x\n", debugstr_mshtml_guid(tid_ids[func->tid]), hres);
730 return E_FAIL;
731 }
732
733 hres = ITypeInfo_Invoke(ti, unk, func->id, flags, &params, res, ei, &argerr);
734
735 IUnknown_Release(unk);
736 return hres;
737 }
738
739 static inline func_disp_t *impl_from_IUnknown(IUnknown *iface)
740 {
741 return CONTAINING_RECORD(iface, func_disp_t, IUnknown_iface);
742 }
743
744 static HRESULT WINAPI Function_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
745 {
746 func_disp_t *This = impl_from_IUnknown(iface);
747
748 TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
749
750 if(IsEqualGUID(&IID_IUnknown, riid)) {
751 *ppv = &This->IUnknown_iface;
752 }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
753 return *ppv ? S_OK : E_NOINTERFACE;
754 }else {
755 *ppv = NULL;
756 return E_NOINTERFACE;
757 }
758
759 IUnknown_AddRef((IUnknown*)*ppv);
760 return S_OK;
761 }
762
763 static ULONG WINAPI Function_AddRef(IUnknown *iface)
764 {
765 func_disp_t *This = impl_from_IUnknown(iface);
766 LONG ref = InterlockedIncrement(&This->ref);
767
768 TRACE("(%p) ref=%d\n", This, ref);
769
770 return ref;
771 }
772
773 static ULONG WINAPI Function_Release(IUnknown *iface)
774 {
775 func_disp_t *This = impl_from_IUnknown(iface);
776 LONG ref = InterlockedDecrement(&This->ref);
777
778 TRACE("(%p) ref=%d\n", This, ref);
779
780 if(!ref) {
781 assert(!This->obj);
782 release_dispex(&This->dispex);
783 heap_free(This);
784 }
785
786 return ref;
787 }
788
789 static const IUnknownVtbl FunctionUnkVtbl = {
790 Function_QueryInterface,
791 Function_AddRef,
792 Function_Release
793 };
794
795 static inline func_disp_t *impl_from_DispatchEx(DispatchEx *iface)
796 {
797 return CONTAINING_RECORD(iface, func_disp_t, dispex);
798 }
799
800 static HRESULT function_value(DispatchEx *dispex, LCID lcid, WORD flags, DISPPARAMS *params,
801 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
802 {
803 func_disp_t *This = impl_from_DispatchEx(dispex);
804 HRESULT hres;
805
806 switch(flags) {
807 case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
808 if(!res)
809 return E_INVALIDARG;
810 /* fall through */
811 case DISPATCH_METHOD:
812 if(!This->obj)
813 return E_UNEXPECTED;
814 hres = typeinfo_invoke(This->obj, This->info, flags, params, res, ei);
815 break;
816 case DISPATCH_PROPERTYGET: {
817 unsigned name_len;
818 WCHAR *ptr;
819 BSTR str;
820
821 static const WCHAR func_prefixW[] =
822 {'\n','f','u','n','c','t','i','o','n',' '};
823 static const WCHAR func_suffixW[] =
824 {'(',')',' ','{','\n',' ',' ',' ',' ','[','n','a','t','i','v','e',' ','c','o','d','e',']','\n','}','\n'};
825
826 /* FIXME: This probably should be more generic. Also we should try to get IID_IActiveScriptSite and SID_GetCaller. */
827 if(!caller)
828 return E_ACCESSDENIED;
829
830 name_len = SysStringLen(This->info->name);
831 ptr = str = SysAllocStringLen(NULL, name_len + ARRAY_SIZE(func_prefixW) + ARRAY_SIZE(func_suffixW));
832 if(!str)
833 return E_OUTOFMEMORY;
834
835 memcpy(ptr, func_prefixW, sizeof(func_prefixW));
836 ptr += ARRAY_SIZE(func_prefixW);
837
838 memcpy(ptr, This->info->name, name_len*sizeof(WCHAR));
839 ptr += name_len;
840
841 memcpy(ptr, func_suffixW, sizeof(func_suffixW));
842
843 V_VT(res) = VT_BSTR;
844 V_BSTR(res) = str;
845 return S_OK;
846 }
847 default:
848 FIXME("Unimplemented flags %x\n", flags);
849 hres = E_NOTIMPL;
850 }
851
852 return hres;
853 }
854
855 static const dispex_static_data_vtbl_t function_dispex_vtbl = {
856 function_value,
857 NULL,
858 NULL,
859 NULL
860 };
861
862 static const tid_t function_iface_tids[] = {0};
863
864 static dispex_static_data_t function_dispex = {
865 &function_dispex_vtbl,
866 NULL_tid,
867 function_iface_tids
868 };
869
870 static func_disp_t *create_func_disp(DispatchEx *obj, func_info_t *info)
871 {
872 func_disp_t *ret;
873
874 ret = heap_alloc_zero(sizeof(func_disp_t));
875 if(!ret)
876 return NULL;
877
878 ret->IUnknown_iface.lpVtbl = &FunctionUnkVtbl;
879 init_dispatch(&ret->dispex, &ret->IUnknown_iface, &function_dispex, dispex_compat_mode(obj));
880 ret->ref = 1;
881 ret->obj = obj;
882 ret->info = info;
883
884 return ret;
885 }
886
887 static HRESULT invoke_disp_value(DispatchEx *This, IDispatch *func_disp, LCID lcid, WORD flags, DISPPARAMS *dp,
888 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
889 {
890 DISPID named_arg = DISPID_THIS;
891 DISPPARAMS new_dp = {NULL, &named_arg, 0, 1};
892 IDispatchEx *dispex;
893 HRESULT hres;
894
895 if(dp->cNamedArgs) {
896 FIXME("named args not supported\n");
897 return E_NOTIMPL;
898 }
899
900 new_dp.rgvarg = heap_alloc((dp->cArgs+1)*sizeof(VARIANTARG));
901 if(!new_dp.rgvarg)
902 return E_OUTOFMEMORY;
903
904 new_dp.cArgs = dp->cArgs+1;
905 memcpy(new_dp.rgvarg+1, dp->rgvarg, dp->cArgs*sizeof(VARIANTARG));
906
907 V_VT(new_dp.rgvarg) = VT_DISPATCH;
908 V_DISPATCH(new_dp.rgvarg) = (IDispatch*)&This->IDispatchEx_iface;
909
910 hres = IDispatch_QueryInterface(func_disp, &IID_IDispatchEx, (void**)&dispex);
911 TRACE(">>>\n");
912 if(SUCCEEDED(hres)) {
913 hres = IDispatchEx_InvokeEx(dispex, DISPID_VALUE, lcid, flags, &new_dp, res, ei, caller);
914 IDispatchEx_Release(dispex);
915 }else {
916 ULONG err = 0;
917 hres = IDispatch_Invoke(func_disp, DISPID_VALUE, &IID_NULL, lcid, flags, &new_dp, res, ei, &err);
918 }
919 if(SUCCEEDED(hres))
920 TRACE("<<< %s\n", debugstr_variant(res));
921 else
922 WARN("<<< %08x\n", hres);
923
924 heap_free(new_dp.rgvarg);
925 return hres;
926 }
927
928 static HRESULT get_func_obj_entry(DispatchEx *This, func_info_t *func, func_obj_entry_t **ret)
929 {
930 dispex_dynamic_data_t *dynamic_data;
931 func_obj_entry_t *entry;
932
933 dynamic_data = get_dynamic_data(This);
934 if(!dynamic_data)
935 return E_OUTOFMEMORY;
936
937 if(!dynamic_data->func_disps) {
938 dynamic_data->func_disps = heap_alloc_zero(This->info->func_disp_cnt * sizeof(*dynamic_data->func_disps));
939 if(!dynamic_data->func_disps)
940 return E_OUTOFMEMORY;
941 }
942
943 entry = dynamic_data->func_disps + func->func_disp_idx;
944 if(!entry->func_obj) {
945 entry->func_obj = create_func_disp(This, func);
946 if(!entry->func_obj)
947 return E_OUTOFMEMORY;
948
949 IDispatchEx_AddRef(&entry->func_obj->dispex.IDispatchEx_iface);
950 V_VT(&entry->val) = VT_DISPATCH;
951 V_DISPATCH(&entry->val) = (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface;
952 }
953
954 *ret = entry;
955 return S_OK;
956 }
957
958 static HRESULT get_builtin_func(dispex_data_t *data, DISPID id, func_info_t **ret)
959 {
960 int min, max, n;
961
962 min = 0;
963 max = data->func_cnt-1;
964
965 while(min <= max) {
966 n = (min+max)/2;
967
968 if(data->funcs[n].id == id) {
969 *ret = data->funcs+n;
970 return S_OK;
971 }
972
973 if(data->funcs[n].id < id)
974 min = n+1;
975 else
976 max = n-1;
977 }
978
979 WARN("invalid id %x\n", id);
980 return DISP_E_UNKNOWNNAME;
981 }
982
983 static HRESULT get_builtin_id(DispatchEx *This, BSTR name, DWORD grfdex, DISPID *ret)
984 {
985 int min, max, n, c;
986
987 min = 0;
988 max = This->info->func_cnt-1;
989
990 while(min <= max) {
991 n = (min+max)/2;
992
993 c = wcsicmp(This->info->name_table[n]->name, name);
994 if(!c) {
995 if((grfdex & fdexNameCaseSensitive) && wcscmp(This->info->name_table[n]->name, name))
996 break;
997
998 *ret = This->info->name_table[n]->id;
999 return S_OK;
1000 }
1001
1002 if(c > 0)
1003 max = n-1;
1004 else
1005 min = n+1;
1006 }
1007
1008 if(This->info->desc->vtbl && This->info->desc->vtbl->get_dispid) {
1009 HRESULT hres;
1010
1011 hres = This->info->desc->vtbl->get_dispid(This, name, grfdex, ret);
1012 if(hres != DISP_E_UNKNOWNNAME)
1013 return hres;
1014 }
1015
1016 return DISP_E_UNKNOWNNAME;
1017 }
1018
1019 static HRESULT change_type(VARIANT *dst, VARIANT *src, VARTYPE vt, IServiceProvider *caller)
1020 {
1021 V_VT(dst) = VT_EMPTY;
1022
1023 if(caller) {
1024 IVariantChangeType *change_type = NULL;
1025 HRESULT hres;
1026
1027 hres = IServiceProvider_QueryService(caller, &SID_VariantConversion, &IID_IVariantChangeType, (void**)&change_type);
1028 if(SUCCEEDED(hres)) {
1029 hres = IVariantChangeType_ChangeType(change_type, dst, src, LOCALE_NEUTRAL, vt);
1030 IVariantChangeType_Release(change_type);
1031 return hres;
1032 }
1033 }
1034
1035 switch(vt) {
1036 case VT_BOOL:
1037 if(V_VT(src) == VT_BSTR) {
1038 V_VT(dst) = VT_BOOL;
1039 V_BOOL(dst) = variant_bool(V_BSTR(src) && *V_BSTR(src));
1040 return S_OK;
1041 }
1042 break;
1043 }
1044
1045 return VariantChangeType(dst, src, 0, vt);
1046 }
1047
1048 static HRESULT builtin_propget(DispatchEx *This, func_info_t *func, DISPPARAMS *dp, VARIANT *res)
1049 {
1050 IUnknown *iface;
1051 HRESULT hres;
1052
1053 if(dp && dp->cArgs) {
1054 FIXME("cArgs %d\n", dp->cArgs);
1055 return E_NOTIMPL;
1056 }
1057
1058 assert(func->get_vtbl_off);
1059
1060 hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&iface);
1061 if(SUCCEEDED(hres)) {
1062 switch(func->prop_vt) {
1063 #define CASE_VT(vt,type,access) \
1064 case vt: { \
1065 type val; \
1066 hres = ((HRESULT (WINAPI*)(IUnknown*,type*))((void**)iface->lpVtbl)[func->get_vtbl_off])(iface,&val); \
1067 if(SUCCEEDED(hres)) \
1068 access(res) = val; \
1069 } \
1070 break
1071 BUILTIN_TYPES_SWITCH;
1072 #undef CASE_VT
1073 default:
1074 FIXME("Unhandled vt %d\n", func->prop_vt);
1075 hres = E_NOTIMPL;
1076 }
1077 IUnknown_Release(iface);
1078 }
1079
1080 if(FAILED(hres))
1081 return hres;
1082
1083 if(func->prop_vt != VT_VARIANT)
1084 V_VT(res) = func->prop_vt == VT_PTR ? VT_DISPATCH : func->prop_vt;
1085 return S_OK;
1086 }
1087
1088 static HRESULT builtin_propput(DispatchEx *This, func_info_t *func, DISPPARAMS *dp, IServiceProvider *caller)
1089 {
1090 VARIANT *v, tmpv;
1091 IUnknown *iface;
1092 HRESULT hres;
1093
1094 if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
1095 || dp->cNamedArgs > 1) {
1096 FIXME("invalid args\n");
1097 return E_INVALIDARG;
1098 }
1099
1100 if(!func->put_vtbl_off) {
1101 if(dispex_compat_mode(This) >= COMPAT_MODE_IE9) {
1102 WARN("No setter\n");
1103 return S_OK;
1104 }
1105 FIXME("No setter\n");
1106 return E_FAIL;
1107 }
1108
1109 v = dp->rgvarg;
1110 if(func->prop_vt != VT_VARIANT && V_VT(v) != func->prop_vt) {
1111 hres = change_type(&tmpv, v, func->prop_vt, caller);
1112 if(FAILED(hres))
1113 return hres;
1114 v = &tmpv;
1115 }
1116
1117 hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&iface);
1118 if(SUCCEEDED(hres)) {
1119 switch(func->prop_vt) {
1120 #define CASE_VT(vt,type,access) \
1121 case vt: \
1122 hres = ((HRESULT (WINAPI*)(IUnknown*,type))((void**)iface->lpVtbl)[func->put_vtbl_off])(iface,access(v)); \
1123 break
1124 BUILTIN_TYPES_SWITCH;
1125 #undef CASE_VT
1126 default:
1127 FIXME("Unimplemented vt %d\n", func->prop_vt);
1128 hres = E_NOTIMPL;
1129 }
1130
1131 IUnknown_Release(iface);
1132 }
1133
1134 if(v == &tmpv)
1135 VariantClear(v);
1136 return hres;
1137 }
1138
1139 static HRESULT invoke_builtin_function(DispatchEx *This, func_info_t *func, DISPPARAMS *dp, VARIANT *res, IServiceProvider *caller)
1140 {
1141 VARIANT arg_buf[MAX_ARGS], *arg_ptrs[MAX_ARGS], *arg, retv, ret_ref, vhres;
1142 unsigned i, nconv = 0;
1143 IUnknown *iface;
1144 HRESULT hres;
1145
1146 if(dp->cNamedArgs) {
1147 FIXME("Named arguments not supported\n");
1148 return E_NOTIMPL;
1149 }
1150
1151 if(dp->cArgs > func->argc || dp->cArgs + func->default_value_cnt < func->argc) {
1152 FIXME("Invalid argument count (expected %u, got %u)\n", func->argc, dp->cArgs);
1153 return E_INVALIDARG;
1154 }
1155
1156 hres = IUnknown_QueryInterface(This->outer, tid_ids[func->tid], (void**)&iface);
1157 if(FAILED(hres))
1158 return hres;
1159
1160 for(i=0; i < func->argc; i++) {
1161 BOOL own_value = FALSE;
1162 if(i >= dp->cArgs) {
1163 /* use default value */
1164 arg_ptrs[i] = &func->arg_info[i].default_value;
1165 continue;
1166 }
1167 arg = dp->rgvarg+dp->cArgs-i-1;
1168 if(func->arg_types[i] == V_VT(arg)) {
1169 arg_ptrs[i] = arg;
1170 }else {
1171 hres = change_type(arg_buf+nconv, arg, func->arg_types[i], caller);
1172 if(FAILED(hres))
1173 break;
1174 arg_ptrs[i] = arg_buf + nconv++;
1175 own_value = TRUE;
1176 }
1177
1178 if(func->arg_types[i] == VT_DISPATCH && !IsEqualGUID(&func->arg_info[i].iid, &IID_NULL)
1179 && V_DISPATCH(arg_ptrs[i])) {
1180 IDispatch *iface;
1181 if(!own_value) {
1182 arg_buf[nconv] = *arg_ptrs[i];
1183 arg_ptrs[i] = arg_buf + nconv++;
1184 }
1185 hres = IDispatch_QueryInterface(V_DISPATCH(arg_ptrs[i]), &func->arg_info[i].iid, (void**)&iface);
1186 if(FAILED(hres)) {
1187 WARN("Could not get %s iface: %08x\n", debugstr_guid(&func->arg_info[i].iid), hres);
1188 break;
1189 }
1190 if(own_value)
1191 IDispatch_Release(V_DISPATCH(arg_ptrs[i]));
1192 V_DISPATCH(arg_ptrs[i]) = iface;
1193 }
1194 }
1195
1196 if(SUCCEEDED(hres)) {
1197 if(func->prop_vt == VT_VOID) {
1198 V_VT(&retv) = VT_EMPTY;
1199 }else {
1200 V_VT(&retv) = func->prop_vt;
1201 arg_ptrs[func->argc] = &ret_ref;
1202 V_VT(&ret_ref) = VT_BYREF|func->prop_vt;
1203
1204 switch(func->prop_vt) {
1205 #define CASE_VT(vt,type,access) \
1206 case vt: \
1207 V_BYREF(&ret_ref) = &access(&retv); \
1208 break
1209 BUILTIN_ARG_TYPES_SWITCH;
1210 #undef CASE_VT
1211 case VT_PTR:
1212 V_VT(&retv) = VT_DISPATCH;
1213 V_VT(&ret_ref) = VT_BYREF | VT_DISPATCH;
1214 V_BYREF(&ret_ref) = &V_DISPATCH(&retv);
1215 break;
1216 default:
1217 assert(0);
1218 }
1219 }
1220
1221 V_VT(&vhres) = VT_ERROR;
1222 hres = DispCallFunc(iface, func->call_vtbl_off*sizeof(void*), CC_STDCALL, VT_ERROR,
1223 func->argc + (func->prop_vt == VT_VOID ? 0 : 1), func->arg_types, arg_ptrs, &vhres);
1224 }
1225
1226 while(nconv--)
1227 VariantClear(arg_buf+nconv);
1228 IUnknown_Release(iface);
1229 if(FAILED(hres))
1230 return hres;
1231 if(FAILED(V_ERROR(&vhres)))
1232 return V_ERROR(&vhres);
1233
1234 if(res)
1235 *res = retv;
1236 else
1237 VariantClear(&retv);
1238 return V_ERROR(&vhres);
1239 }
1240
1241 static HRESULT function_invoke(DispatchEx *This, func_info_t *func, WORD flags, DISPPARAMS *dp, VARIANT *res,
1242 EXCEPINFO *ei, IServiceProvider *caller)
1243 {
1244 HRESULT hres;
1245
1246 switch(flags) {
1247 case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
1248 if(!res)
1249 return E_INVALIDARG;
1250 /* fall through */
1251 case DISPATCH_METHOD:
1252 if(This->dynamic_data && This->dynamic_data->func_disps
1253 && This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
1254 func_obj_entry_t *entry = This->dynamic_data->func_disps + func->func_disp_idx;
1255
1256 if(V_VT(&entry->val) != VT_DISPATCH) {
1257 FIXME("calling %s not supported\n", debugstr_variant(&entry->val));
1258 return E_NOTIMPL;
1259 }
1260
1261 if((IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface != V_DISPATCH(&entry->val)) {
1262 if(!V_DISPATCH(&entry->val)) {
1263 FIXME("Calling null\n");
1264 return E_FAIL;
1265 }
1266
1267 hres = invoke_disp_value(This, V_DISPATCH(&entry->val), 0, flags, dp, res, ei, NULL);
1268 break;
1269 }
1270 }
1271
1272 if(func->call_vtbl_off)
1273 hres = invoke_builtin_function(This, func, dp, res, caller);
1274 else
1275 hres = typeinfo_invoke(This, func, flags, dp, res, ei);
1276 break;
1277 case DISPATCH_PROPERTYGET: {
1278 func_obj_entry_t *entry;
1279
1280 if(func->id == DISPID_VALUE) {
1281 BSTR ret;
1282
1283 ret = SysAllocString(L"[object]");
1284 if(!ret)
1285 return E_OUTOFMEMORY;
1286
1287 V_VT(res) = VT_BSTR;
1288 V_BSTR(res) = ret;
1289 return S_OK;
1290 }
1291
1292 hres = get_func_obj_entry(This, func, &entry);
1293 if(FAILED(hres))
1294 return hres;
1295
1296 V_VT(res) = VT_EMPTY;
1297 return VariantCopy(res, &entry->val);
1298 }
1299 case DISPATCH_PROPERTYPUT: {
1300 func_obj_entry_t *entry;
1301
1302 if(dp->cArgs != 1 || (dp->cNamedArgs == 1 && *dp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
1303 || dp->cNamedArgs > 1) {
1304 FIXME("invalid args\n");
1305 return E_INVALIDARG;
1306 }
1307
1308 /*
1309 * NOTE: Although we have IDispatchEx tests showing, that it's not allowed to set
1310 * function property using InvokeEx, it's possible to do that from jscript.
1311 * Native probably uses some undocumented interface in this case, but it should
1312 * be fine for us to allow IDispatchEx handle that.
1313 */
1314 hres = get_func_obj_entry(This, func, &entry);
1315 if(FAILED(hres))
1316 return hres;
1317
1318 return VariantCopy(&entry->val, dp->rgvarg);
1319 }
1320 default:
1321 FIXME("Unimplemented flags %x\n", flags);
1322 hres = E_NOTIMPL;
1323 }
1324
1325 return hres;
1326 }
1327
1328 static HRESULT invoke_builtin_prop(DispatchEx *This, DISPID id, LCID lcid, WORD flags, DISPPARAMS *dp,
1329 VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1330 {
1331 func_info_t *func;
1332 HRESULT hres;
1333
1334 hres = get_builtin_func(This->info, id, &func);
1335 if(id == DISPID_VALUE && hres == DISP_E_UNKNOWNNAME)
1336 return dispex_value(This, lcid, flags, dp, res, ei, caller);
1337 if(FAILED(hres))
1338 return hres;
1339
1340 if(func->hook) {
1341 hres = func->hook(This, lcid, flags, dp, res, ei, caller);
1342 if(hres != S_FALSE)
1343 return hres;
1344 }
1345
1346 if(func->func_disp_idx != -1)
1347 return function_invoke(This, func, flags, dp, res, ei, caller);
1348
1349 switch(flags) {
1350 case DISPATCH_PROPERTYPUT:
1351 if(res)
1352 V_VT(res) = VT_EMPTY;
1353 hres = builtin_propput(This, func, dp, caller);
1354 break;
1355 case DISPATCH_PROPERTYGET:
1356 hres = builtin_propget(This, func, dp, res);
1357 break;
1358 default:
1359 if(!func->get_vtbl_off) {
1360 hres = typeinfo_invoke(This, func, flags, dp, res, ei);
1361 }else {
1362 VARIANT v;
1363
1364 hres = builtin_propget(This, func, NULL, &v);
1365 if(FAILED(hres))
1366 return hres;
1367
1368 if(flags != (DISPATCH_PROPERTYGET|DISPATCH_METHOD) || dp->cArgs) {
1369 if(V_VT(&v) != VT_DISPATCH) {
1370 FIXME("Not a function %s flags %08x\n", debugstr_variant(&v), flags);
1371 VariantClear(&v);
1372 return E_FAIL;
1373 }
1374
1375 hres = invoke_disp_value(This, V_DISPATCH(&v), lcid, flags, dp, res, ei, caller);
1376 IDispatch_Release(V_DISPATCH(&v));
1377 }else if(res) {
1378 *res = v;
1379 }else {
1380 VariantClear(&v);
1381 }
1382 }
1383 }
1384
1385 return hres;
1386 }
1387
1388 HRESULT remove_attribute(DispatchEx *This, DISPID id, VARIANT_BOOL *success)
1389 {
1390 switch(get_dispid_type(id)) {
1391 case DISPEXPROP_CUSTOM:
1392 FIXME("DISPEXPROP_CUSTOM not supported\n");
1393 return E_NOTIMPL;
1394
1395 case DISPEXPROP_DYNAMIC: {
1396 DWORD idx = id - DISPID_DYNPROP_0;
1397 dynamic_prop_t *prop;
1398
1399 prop = This->dynamic_data->props+idx;
1400 VariantClear(&prop->var);
1401 prop->flags |= DYNPROP_DELETED;
1402 *success = VARIANT_TRUE;
1403 return S_OK;
1404 }
1405 case DISPEXPROP_BUILTIN: {
1406 VARIANT var;
1407 DISPPARAMS dp = {&var,NULL,1,0};
1408 func_info_t *func;
1409 HRESULT hres;
1410
1411 hres = get_builtin_func(This->info, id, &func);
1412 if(FAILED(hres))
1413 return hres;
1414
1415 /* For builtin functions, we set their value to the original function. */
1416 if(func->func_disp_idx != -1) {
1417 func_obj_entry_t *entry;
1418
1419 if(!This->dynamic_data || !This->dynamic_data->func_disps
1420 || !This->dynamic_data->func_disps[func->func_disp_idx].func_obj) {
1421 *success = VARIANT_FALSE;
1422 return S_OK;
1423 }
1424
1425 entry = This->dynamic_data->func_disps + func->func_disp_idx;
1426 if(V_VT(&entry->val) == VT_DISPATCH
1427 && V_DISPATCH(&entry->val) == (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface) {
1428 *success = VARIANT_FALSE;
1429 return S_OK;
1430 }
1431
1432 VariantClear(&entry->val);
1433 V_VT(&entry->val) = VT_DISPATCH;
1434 V_DISPATCH(&entry->val) = (IDispatch*)&entry->func_obj->dispex.IDispatchEx_iface;
1435 IDispatch_AddRef(V_DISPATCH(&entry->val));
1436 *success = VARIANT_TRUE;
1437 return S_OK;
1438 }
1439
1440 V_VT(&var) = VT_EMPTY;
1441 hres = builtin_propput(This, func, &dp, NULL);
1442 if(FAILED(hres))
1443 return hres;
1444
1445 *success = VARIANT_TRUE;
1446 return S_OK;
1447 }
1448 default:
1449 assert(0);
1450 return E_FAIL;
1451 }
1452 }
1453
1454 compat_mode_t dispex_compat_mode(DispatchEx *dispex)
1455 {
1456 return dispex->info != dispex->info->desc->delayed_init_info
1457 ? dispex->info->compat_mode
1458 : dispex->info->desc->vtbl->get_compat_mode(dispex);
1459 }
1460
1461 static dispex_data_t *ensure_dispex_info(dispex_static_data_t *desc, compat_mode_t compat_mode)
1462 {
1463 if(!desc->info_cache[compat_mode]) {
1464 EnterCriticalSection(&cs_dispex_static_data);
1465 if(!desc->info_cache[compat_mode])
1466 desc->info_cache[compat_mode] = preprocess_dispex_data(desc, compat_mode);
1467 LeaveCriticalSection(&cs_dispex_static_data);
1468 }
1469 return desc->info_cache[compat_mode];
1470 }
1471
1472 static BOOL ensure_real_info(DispatchEx *dispex)
1473 {
1474 if(dispex->info != dispex->info->desc->delayed_init_info)
1475 return TRUE;
1476
1477 dispex->info = ensure_dispex_info(dispex->info->desc, dispex_compat_mode(dispex));
1478 return dispex->info != NULL;
1479 }
1480
1481 static inline DispatchEx *impl_from_IDispatchEx(IDispatchEx *iface)
1482 {
1483 return CONTAINING_RECORD(iface, DispatchEx, IDispatchEx_iface);
1484 }
1485
1486 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
1487 {
1488 DispatchEx *This = impl_from_IDispatchEx(iface);
1489
1490 return IUnknown_QueryInterface(This->outer, riid, ppv);
1491 }
1492
1493 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
1494 {
1495 DispatchEx *This = impl_from_IDispatchEx(iface);
1496
1497 return IUnknown_AddRef(This->outer);
1498 }
1499
1500 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
1501 {
1502 DispatchEx *This = impl_from_IDispatchEx(iface);
1503
1504 return IUnknown_Release(This->outer);
1505 }
1506
1507 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
1508 {
1509 DispatchEx *This = impl_from_IDispatchEx(iface);
1510
1511 TRACE("(%p)->(%p)\n", This, pctinfo);
1512
1513 *pctinfo = 1;
1514 return S_OK;
1515 }
1516
1517 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
1518 LCID lcid, ITypeInfo **ppTInfo)
1519 {
1520 DispatchEx *This = impl_from_IDispatchEx(iface);
1521 HRESULT hres;
1522
1523 TRACE("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1524
1525 hres = get_typeinfo(This->info->desc->disp_tid, ppTInfo);
1526 if(FAILED(hres))
1527 return hres;
1528
1529 ITypeInfo_AddRef(*ppTInfo);
1530 return S_OK;
1531 }
1532
1533 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
1534 LPOLESTR *rgszNames, UINT cNames,
1535 LCID lcid, DISPID *rgDispId)
1536 {
1537 DispatchEx *This = impl_from_IDispatchEx(iface);
1538 UINT i;
1539 HRESULT hres;
1540
1541 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
1542 lcid, rgDispId);
1543
1544 for(i=0; i < cNames; i++) {
1545 hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
1546 if(FAILED(hres))
1547 return hres;
1548 }
1549
1550 return S_OK;
1551 }
1552
1553 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
1554 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1555 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1556 {
1557 DispatchEx *This = impl_from_IDispatchEx(iface);
1558
1559 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1560 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1561
1562 return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags, pDispParams,
1563 pVarResult, pExcepInfo, NULL);
1564 }
1565
1566 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
1567 {
1568 DispatchEx *This = impl_from_IDispatchEx(iface);
1569 dynamic_prop_t *dprop;
1570 HRESULT hres;
1571
1572 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
1573
1574 if(grfdex & ~(fdexNameCaseSensitive|fdexNameCaseInsensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK))
1575 FIXME("Unsupported grfdex %x\n", grfdex);
1576
1577 if(!ensure_real_info(This))
1578 return E_OUTOFMEMORY;
1579
1580 hres = get_builtin_id(This, bstrName, grfdex, pid);
1581 if(hres != DISP_E_UNKNOWNNAME)
1582 return hres;
1583
1584 hres = get_dynamic_prop(This, bstrName, grfdex, &dprop);
1585 if(FAILED(hres))
1586 return hres;
1587
1588 *pid = DISPID_DYNPROP_0 + (dprop - This->dynamic_data->props);
1589 return S_OK;
1590 }
1591
1592 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
1593 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
1594 {
1595 DispatchEx *This = impl_from_IDispatchEx(iface);
1596 HRESULT hres;
1597
1598 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1599
1600 if(!ensure_real_info(This))
1601 return E_OUTOFMEMORY;
1602
1603 if(wFlags == (DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF))
1604 wFlags = DISPATCH_PROPERTYPUT;
1605
1606 switch(get_dispid_type(id)) {
1607 case DISPEXPROP_CUSTOM:
1608 if(!This->info->desc->vtbl || !This->info->desc->vtbl->invoke)
1609 return DISP_E_UNKNOWNNAME;
1610 return This->info->desc->vtbl->invoke(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1611
1612 case DISPEXPROP_DYNAMIC: {
1613 DWORD idx = id - DISPID_DYNPROP_0;
1614 dynamic_prop_t *prop;
1615
1616 if(!get_dynamic_data(This) || This->dynamic_data->prop_cnt <= idx)
1617 return DISP_E_UNKNOWNNAME;
1618
1619 prop = This->dynamic_data->props+idx;
1620
1621 switch(wFlags) {
1622 case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
1623 if(!pvarRes)
1624 return E_INVALIDARG;
1625 /* fall through */
1626 case DISPATCH_METHOD:
1627 if(V_VT(&prop->var) != VT_DISPATCH) {
1628 FIXME("invoke %s\n", debugstr_variant(&prop->var));
1629 return E_NOTIMPL;
1630 }
1631
1632 return invoke_disp_value(This, V_DISPATCH(&prop->var), lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1633 case DISPATCH_PROPERTYGET:
1634 if(prop->flags & DYNPROP_DELETED)
1635 return DISP_E_UNKNOWNNAME;
1636 V_VT(pvarRes) = VT_EMPTY;
1637 return variant_copy(pvarRes, &prop->var);
1638 case DISPATCH_PROPERTYPUT:
1639 if(pdp->cArgs != 1 || (pdp->cNamedArgs == 1 && *pdp->rgdispidNamedArgs != DISPID_PROPERTYPUT)
1640 || pdp->cNamedArgs > 1) {
1641 FIXME("invalid args\n");
1642 return E_INVALIDARG;
1643 }
1644
1645 TRACE("put %s\n", debugstr_variant(pdp->rgvarg));
1646 VariantClear(&prop->var);
1647 hres = variant_copy(&prop->var, pdp->rgvarg);
1648 if(FAILED(hres))
1649 return hres;
1650
1651 prop->flags &= ~DYNPROP_DELETED;
1652 return S_OK;
1653 default:
1654 FIXME("unhandled wFlags %x\n", wFlags);
1655 return E_NOTIMPL;
1656 }
1657 }
1658 case DISPEXPROP_BUILTIN:
1659 if(wFlags == DISPATCH_CONSTRUCT) {
1660 if(id == DISPID_VALUE) {
1661 if(This->info->desc->vtbl && This->info->desc->vtbl->value) {
1662 return This->info->desc->vtbl->value(This, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1663 }
1664 FIXME("DISPATCH_CONSTRUCT flag but missing value function\n");
1665 return E_FAIL;
1666 }
1667 FIXME("DISPATCH_CONSTRUCT flag without DISPID_VALUE\n");
1668 return E_FAIL;
1669 }
1670
1671 return invoke_builtin_prop(This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
1672 default:
1673 assert(0);
1674 return E_FAIL;
1675 }
1676 }
1677
1678 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR name, DWORD grfdex)
1679 {
1680 DispatchEx *This = impl_from_IDispatchEx(iface);
1681 DISPID id;
1682 HRESULT hres;
1683
1684 TRACE("(%p)->(%s %x)\n", This, debugstr_w(name), grfdex);
1685
1686 if(dispex_compat_mode(This) < COMPAT_MODE_IE8) {
1687 /* Not implemented by IE */
1688 return E_NOTIMPL;
1689 }
1690
1691 hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, name, grfdex & ~fdexNameEnsure, &id);
1692 if(FAILED(hres)) {
1693 TRACE("property %s not found\n", debugstr_w(name));
1694 return dispex_compat_mode(This) < COMPAT_MODE_IE9 ? hres : S_OK;
1695 }
1696
1697 return IDispatchEx_DeleteMemberByDispID(&This->IDispatchEx_iface, id);
1698 }
1699
1700 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
1701 {
1702 DispatchEx *This = impl_from_IDispatchEx(iface);
1703
1704 TRACE("(%p)->(%x)\n", This, id);
1705
1706 if(dispex_compat_mode(This) < COMPAT_MODE_IE8) {
1707 /* Not implemented by IE */
1708 return E_NOTIMPL;
1709 }
1710
1711 if(is_dynamic_dispid(id)) {
1712 DWORD idx = id - DISPID_DYNPROP_0;
1713 dynamic_prop_t *prop;
1714
1715 if(!get_dynamic_data(This) || idx > This->dynamic_data->prop_cnt)
1716 return S_OK;
1717
1718 prop = This->dynamic_data->props + idx;
1719 VariantClear(&prop->var);
1720 prop->flags |= DYNPROP_DELETED;
1721 return S_OK;
1722 }
1723
1724 return S_OK;
1725 }
1726
1727 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
1728 {
1729 DispatchEx *This = impl_from_IDispatchEx(iface);
1730 FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
1731 return E_NOTIMPL;
1732 }
1733
1734 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
1735 {
1736 DispatchEx *This = impl_from_IDispatchEx(iface);
1737 func_info_t *func;
1738 HRESULT hres;
1739
1740 TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
1741
1742 if(!ensure_real_info(This))
1743 return E_OUTOFMEMORY;
1744
1745 if(is_dynamic_dispid(id)) {
1746 DWORD idx = id - DISPID_DYNPROP_0;
1747
1748 if(!get_dynamic_data(This) || This->dynamic_data->prop_cnt <= idx)
1749 return DISP_E_UNKNOWNNAME;
1750
1751 *pbstrName = SysAllocString(This->dynamic_data->props[idx].name);
1752 if(!*pbstrName)
1753 return E_OUTOFMEMORY;
1754
1755 return S_OK;
1756 }
1757
1758 hres = get_builtin_func(This->info, id, &func);
1759 if(FAILED(hres))
1760 return hres;
1761
1762 *pbstrName = SysAllocString(func->name);
1763 if(!*pbstrName)
1764 return E_OUTOFMEMORY;
1765 return S_OK;
1766 }
1767
1768 static HRESULT next_dynamic_id(DispatchEx *dispex, DWORD idx, DISPID *ret_id)
1769 {
1770 while(idx < dispex->dynamic_data->prop_cnt && dispex->dynamic_data->props[idx].flags & DYNPROP_DELETED)
1771 idx++;
1772
1773 if(idx == dispex->dynamic_data->prop_cnt) {
1774 *ret_id = DISPID_STARTENUM;
1775 return S_FALSE;
1776 }
1777
1778 *ret_id = DISPID_DYNPROP_0+idx;
1779 return S_OK;
1780 }
1781
1782 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
1783 {
1784 DispatchEx *This = impl_from_IDispatchEx(iface);
1785 func_info_t *func;
1786 HRESULT hres;
1787
1788 TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
1789
1790 if(!ensure_real_info(This))
1791 return E_OUTOFMEMORY;
1792
1793 if(is_dynamic_dispid(id)) {
1794 DWORD idx = id - DISPID_DYNPROP_0;
1795
1796 if(!get_dynamic_data(This) || This->dynamic_data->prop_cnt <= idx)
1797 return DISP_E_UNKNOWNNAME;
1798
1799 return next_dynamic_id(This, idx+1, pid);
1800 }
1801
1802 if(id == DISPID_STARTENUM) {
1803 func = This->info->funcs;
1804 }else {
1805 hres = get_builtin_func(This->info, id, &func);
1806 if(FAILED(hres))
1807 return hres;
1808 func++;
1809 }
1810
1811 while(func < This->info->funcs + This->info->func_cnt) {
1812 /* FIXME: Skip hidden properties */
1813 if(func->func_disp_idx == -1) {
1814 *pid = func->id;
1815 return S_OK;
1816 }
1817 func++;
1818 }
1819
1820 if(get_dynamic_data(This) && This->dynamic_data->prop_cnt)
1821 return next_dynamic_id(This, 0, pid);
1822
1823 *pid = DISPID_STARTENUM;
1824 return S_FALSE;
1825 }
1826
1827 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
1828 {
1829 DispatchEx *This = impl_from_IDispatchEx(iface);
1830 FIXME("(%p)->(%p)\n", This, ppunk);
1831 return E_NOTIMPL;
1832 }
1833
1834 static IDispatchExVtbl DispatchExVtbl = {
1835 DispatchEx_QueryInterface,
1836 DispatchEx_AddRef,
1837 DispatchEx_Release,
1838 DispatchEx_GetTypeInfoCount,
1839 DispatchEx_GetTypeInfo,
1840 DispatchEx_GetIDsOfNames,
1841 DispatchEx_Invoke,
1842 DispatchEx_GetDispID,
1843 DispatchEx_InvokeEx,
1844 DispatchEx_DeleteMemberByName,
1845 DispatchEx_DeleteMemberByDispID,
1846 DispatchEx_GetMemberProperties,
1847 DispatchEx_GetMemberName,
1848 DispatchEx_GetNextDispID,
1849 DispatchEx_GetNameSpaceParent
1850 };
1851
1852 BOOL dispex_query_interface(DispatchEx *This, REFIID riid, void **ppv)
1853 {
1854 if(IsEqualGUID(&IID_IDispatch, riid))
1855 *ppv = &This->IDispatchEx_iface;
1856 else if(IsEqualGUID(&IID_IDispatchEx, riid))
1857 *ppv = &This->IDispatchEx_iface;
1858 else if(IsEqualGUID(&IID_IDispatchJS, riid))
1859 *ppv = NULL;
1860 else if(IsEqualGUID(&IID_UndocumentedScriptIface, riid))
1861 *ppv = NULL;
1862 else if(IsEqualGUID(&IID_IMarshal, riid))
1863 *ppv = NULL;
1864 else if(IsEqualGUID(&IID_IManagedObject, riid))
1865 *ppv = NULL;
1866 else
1867 return FALSE;
1868
1869 if(*ppv)
1870 IUnknown_AddRef((IUnknown*)*ppv);
1871 return TRUE;
1872 }
1873
1874 void dispex_traverse(DispatchEx *This, nsCycleCollectionTraversalCallback *cb)
1875 {
1876 dynamic_prop_t *prop;
1877
1878 if(!This->dynamic_data)
1879 return;
1880
1881 for(prop = This->dynamic_data->props; prop < This->dynamic_data->props + This->dynamic_data->prop_cnt; prop++) {
1882 if(V_VT(&prop->var) == VT_DISPATCH)
1883 note_cc_edge((nsISupports*)V_DISPATCH(&prop->var), "dispex_data", cb);
1884 }
1885
1886 /* FIXME: Traverse func_disps */
1887 }
1888
1889 void dispex_unlink(DispatchEx *This)
1890 {
1891 dynamic_prop_t *prop;
1892
1893 if(!This->dynamic_data)
1894 return;
1895
1896 for(prop = This->dynamic_data->props; prop < This->dynamic_data->props + This->dynamic_data->prop_cnt; prop++) {
1897 if(V_VT(&prop->var) == VT_DISPATCH) {
1898 V_VT(&prop->var) = VT_EMPTY;
1899 IDispatch_Release(V_DISPATCH(&prop->var));
1900 }else {
1901 VariantClear(&prop->var);
1902 }
1903 }
1904 }
1905
1906 const void *dispex_get_vtbl(DispatchEx *dispex)
1907 {
1908 return dispex->info->desc->vtbl;
1909 }
1910
1911 void release_dispex(DispatchEx *This)
1912 {
1913 dynamic_prop_t *prop;
1914
1915 if(!This->dynamic_data)
1916 return;
1917
1918 for(prop = This->dynamic_data->props; prop < This->dynamic_data->props + This->dynamic_data->prop_cnt; prop++) {
1919 VariantClear(&prop->var);
1920 heap_free(prop->name);
1921 }
1922
1923 heap_free(This->dynamic_data->props);
1924
1925 if(This->dynamic_data->func_disps) {
1926 func_obj_entry_t *iter;
1927
1928 for(iter = This->dynamic_data->func_disps; iter < This->dynamic_data->func_disps + This->info->func_disp_cnt; iter++) {
1929 if(iter->func_obj) {
1930 iter->func_obj->obj = NULL;
1931 IDispatchEx_Release(&iter->func_obj->dispex.IDispatchEx_iface);
1932 }
1933 VariantClear(&iter->val);
1934 }
1935
1936 heap_free(This->dynamic_data->func_disps);
1937 }
1938
1939 heap_free(This->dynamic_data);
1940 }
1941
1942 void init_dispatch(DispatchEx *dispex, IUnknown *outer, dispex_static_data_t *data, compat_mode_t compat_mode)
1943 {
1944 assert(compat_mode < COMPAT_MODE_CNT);
1945
1946 dispex->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
1947 dispex->outer = outer;
1948 dispex->dynamic_data = NULL;
1949
1950 if(data->vtbl && data->vtbl->get_compat_mode) {
1951 /* delayed init */
1952 if(!data->delayed_init_info) {
1953 EnterCriticalSection(&cs_dispex_static_data);
1954 if(!data->delayed_init_info) {
1955 dispex_data_t *info = heap_alloc_zero(sizeof(*data->delayed_init_info));
1956 if(info) {
1957 info->desc = data;
1958 data->delayed_init_info = info;
1959 }
1960 }
1961 LeaveCriticalSection(&cs_dispex_static_data);
1962 }
1963 dispex->info = data->delayed_init_info;
1964 }else {
1965 dispex->info = ensure_dispex_info(data, compat_mode);
1966 }
1967 }
Windows API implementation