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