2 * Copyright 2008-2009 Jacek Caban for CodeWeavers
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.
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.
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
23 #define NONAMELESSUNION
30 #include "wine/debug.h"
32 #include "mshtml_private.h"
34 WINE_DEFAULT_DEBUG_CHANNEL(mshtml
);
38 static CRITICAL_SECTION cs_dispex_static_data
;
39 static CRITICAL_SECTION_DEBUG cs_dispex_static_data_dbg
=
41 0, 0, &cs_dispex_static_data
,
42 { &cs_dispex_static_data_dbg
.ProcessLocksList
, &cs_dispex_static_data_dbg
.ProcessLocksList
},
43 0, 0, { (DWORD_PTR
)(__FILE__
": dispex_static_data") }
45 static CRITICAL_SECTION cs_dispex_static_data
= { &cs_dispex_static_data_dbg
, -1, 0, 0, 0, 0 };
48 static const WCHAR objectW
[] = {'[','o','b','j','e','c','t',']',0};
63 struct dispex_data_t
{
66 func_info_t
**name_table
;
78 #define DYNPROP_DELETED 0x01
82 IUnknown IUnknown_iface
;
89 func_disp_t
*func_obj
;
93 struct dispex_dynamic_data_t
{
96 dynamic_prop_t
*props
;
97 func_obj_entry_t
*func_disps
;
100 #define DISPID_DYNPROP_0 0x50000000
101 #define DISPID_DYNPROP_MAX 0x5fffffff
103 #define FDEX_VERSION_MASK 0xf0000000
105 static ITypeLib
*typelib
;
106 static ITypeInfo
*typeinfos
[LAST_tid
];
107 static struct list dispex_data_list
= LIST_INIT(dispex_data_list
);
109 static REFIID tid_ids
[] = {
110 #define XIID(iface) &IID_ ## iface,
111 #define XDIID(iface) &DIID_ ## iface,
117 static HRESULT
load_typelib(void)
122 hres
= LoadRegTypeLib(&LIBID_MSHTML
, 4, 0, LOCALE_SYSTEM_DEFAULT
, &tl
);
124 ERR("LoadRegTypeLib failed: %08x\n", hres
);
128 if(InterlockedCompareExchangePointer((void**)&typelib
, tl
, NULL
))
129 ITypeLib_Release(tl
);
133 static HRESULT
get_typeinfo(tid_t tid
, ITypeInfo
**typeinfo
)
138 hres
= load_typelib();
142 if(!typeinfos
[tid
]) {
145 hres
= ITypeLib_GetTypeInfoOfGuid(typelib
, tid_ids
[tid
], &ti
);
147 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_mshtml_guid(tid_ids
[tid
]), hres
);
151 if(InterlockedCompareExchangePointer((void**)(typeinfos
+tid
), ti
, NULL
))
152 ITypeInfo_Release(ti
);
155 *typeinfo
= typeinfos
[tid
];
159 void release_typelib(void)
164 while(!list_empty(&dispex_data_list
)) {
165 iter
= LIST_ENTRY(list_head(&dispex_data_list
), dispex_data_t
, entry
);
166 list_remove(&iter
->entry
);
168 for(i
=0; i
< iter
->func_cnt
; i
++)
169 SysFreeString(iter
->funcs
[i
].name
);
171 heap_free(iter
->funcs
);
172 heap_free(iter
->name_table
);
179 for(i
=0; i
< sizeof(typeinfos
)/sizeof(*typeinfos
); i
++)
181 ITypeInfo_Release(typeinfos
[i
]);
183 ITypeLib_Release(typelib
);
184 DeleteCriticalSection(&cs_dispex_static_data
);
187 HRESULT
get_htmldoc_classinfo(ITypeInfo
**typeinfo
)
192 hres
= load_typelib();
196 hres
= ITypeLib_GetTypeInfoOfGuid(typelib
, &CLSID_HTMLDocument
, typeinfo
);
198 ERR("GetTypeInfoOfGuid failed: %08x\n", hres
);
202 /* Not all argument types are supported yet */
203 #define BUILTIN_ARG_TYPES_SWITCH \
204 CASE_VT(VT_I2, INT16, V_I2); \
205 CASE_VT(VT_I4, INT32, V_I4); \
206 CASE_VT(VT_R4, float, V_R4); \
207 CASE_VT(VT_BSTR, BSTR, V_BSTR); \
208 CASE_VT(VT_BOOL, VARIANT_BOOL, V_BOOL)
210 /* List all types used by IDispatchEx-based properties */
211 #define BUILTIN_TYPES_SWITCH \
212 BUILTIN_ARG_TYPES_SWITCH; \
213 CASE_VT(VT_VARIANT, VARIANT, *); \
214 CASE_VT(VT_PTR, void*, V_BYREF); \
215 CASE_VT(VT_UNKNOWN, IUnknown*, V_UNKNOWN); \
216 CASE_VT(VT_DISPATCH, IDispatch*, V_DISPATCH)
218 static BOOL
is_arg_type_supported(VARTYPE vt
)
221 #define CASE_VT(x,a,b) case x: return TRUE
222 BUILTIN_ARG_TYPES_SWITCH
;
228 static void add_func_info(dispex_data_t
*data
, DWORD
*size
, tid_t tid
, const FUNCDESC
*desc
, ITypeInfo
*dti
)
233 for(info
= data
->funcs
; info
< data
->funcs
+data
->func_cnt
; info
++) {
234 if(info
->id
== desc
->memid
) {
236 return; /* Duplicated in other interface */
241 if(info
== data
->funcs
+data
->func_cnt
) {
242 if(data
->func_cnt
== *size
)
243 data
->funcs
= heap_realloc_zero(data
->funcs
, (*size
<<= 1)*sizeof(func_info_t
));
245 info
= data
->funcs
+data
->func_cnt
;
246 hres
= ITypeInfo_GetDocumentation(dti
, desc
->memid
, &info
->name
, NULL
, NULL
, NULL
);
252 info
->id
= desc
->memid
;
254 info
->func_disp_idx
= -1;
255 info
->prop_vt
= VT_EMPTY
;
258 if(desc
->invkind
& DISPATCH_METHOD
) {
261 info
->func_disp_idx
= data
->func_disp_cnt
++;
262 info
->argc
= desc
->cParams
;
264 assert(info
->argc
< MAX_ARGS
);
265 assert(desc
->funckind
== FUNC_DISPATCH
);
267 info
->arg_types
= heap_alloc(sizeof(*info
->arg_types
) * info
->argc
);
269 return; /* FIXME: real error instead of fallback */
271 for(i
=0; i
< info
->argc
; i
++)
272 info
->arg_types
[i
] = desc
->lprgelemdescParam
[i
].tdesc
.vt
;
274 info
->prop_vt
= desc
->elemdescFunc
.tdesc
.vt
;
275 if(info
->prop_vt
!= VT_VOID
&& !is_arg_type_supported(info
->prop_vt
)) {
276 TRACE("%s: return type %d\n", debugstr_w(info
->name
), info
->prop_vt
);
277 return; /* Fallback to ITypeInfo::Invoke */
280 if(desc
->cParamsOpt
) {
281 TRACE("%s: optional params\n", debugstr_w(info
->name
));
282 return; /* Fallback to ITypeInfo::Invoke */
285 for(i
=0; i
< info
->argc
; i
++) {
286 if(!is_arg_type_supported(info
->arg_types
[i
])) {
287 return; /* Fallback to ITypeInfo for unsupported arg types */
290 if(desc
->lprgelemdescParam
[i
].u
.paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
) {
291 TRACE("%s param %d: default value\n", debugstr_w(info
->name
), i
);
292 return; /* Fallback to ITypeInfo::Invoke */
296 assert(info
->argc
<= MAX_ARGS
);
297 assert(desc
->callconv
== CC_STDCALL
);
299 info
->call_vtbl_off
= desc
->oVft
/sizeof(void*);
300 }else if(desc
->invkind
& (DISPATCH_PROPERTYPUT
|DISPATCH_PROPERTYGET
)) {
301 VARTYPE vt
= VT_EMPTY
;
303 if(desc
->invkind
& DISPATCH_PROPERTYGET
) {
304 vt
= desc
->elemdescFunc
.tdesc
.vt
;
305 info
->get_vtbl_off
= desc
->oVft
/sizeof(void*);
307 if(desc
->invkind
& DISPATCH_PROPERTYPUT
) {
308 assert(desc
->cParams
== 1);
309 vt
= desc
->lprgelemdescParam
->tdesc
.vt
;
310 info
->put_vtbl_off
= desc
->oVft
/sizeof(void*);
313 assert(info
->prop_vt
== VT_EMPTY
|| vt
== info
->prop_vt
);
318 static int dispid_cmp(const void *p1
, const void *p2
)
320 return ((const func_info_t
*)p1
)->id
- ((const func_info_t
*)p2
)->id
;
323 static int func_name_cmp(const void *p1
, const void *p2
)
325 return strcmpiW((*(func_info_t
* const*)p1
)->name
, (*(func_info_t
* const*)p2
)->name
);
328 static dispex_data_t
*preprocess_dispex_data(DispatchEx
*This
)
330 const tid_t
*tid
= This
->data
->iface_tids
;
337 TRACE("(%p)\n", This
);
339 if(This
->data
->disp_tid
) {
340 hres
= get_typeinfo(This
->data
->disp_tid
, &dti
);
342 ERR("Could not get disp type info: %08x\n", hres
);
347 data
= heap_alloc(sizeof(dispex_data_t
));
349 ERR("Out of memory\n");
353 data
->func_disp_cnt
= 0;
354 data
->funcs
= heap_alloc_zero(size
*sizeof(func_info_t
));
357 ERR("Out of memory\n");
360 list_add_tail(&dispex_data_list
, &data
->entry
);
363 hres
= get_typeinfo(*tid
, &ti
);
369 hres
= ITypeInfo_GetFuncDesc(ti
, i
++, &funcdesc
);
373 add_func_info(data
, &size
, *tid
, funcdesc
, dti
);
374 ITypeInfo_ReleaseFuncDesc(ti
, funcdesc
);
380 if(!data
->func_cnt
) {
381 heap_free(data
->funcs
);
382 data
->name_table
= NULL
;
388 data
->funcs
= heap_realloc(data
->funcs
, data
->func_cnt
* sizeof(func_info_t
));
389 qsort(data
->funcs
, data
->func_cnt
, sizeof(func_info_t
), dispid_cmp
);
391 data
->name_table
= heap_alloc(data
->func_cnt
* sizeof(func_info_t
*));
392 for(i
=0; i
< data
->func_cnt
; i
++)
393 data
->name_table
[i
] = data
->funcs
+i
;
394 qsort(data
->name_table
, data
->func_cnt
, sizeof(func_info_t
*), func_name_cmp
);
399 static int id_cmp(const void *p1
, const void *p2
)
401 return *(const DISPID
*)p1
- *(const DISPID
*)p2
;
404 HRESULT
get_dispids(tid_t tid
, DWORD
*ret_size
, DISPID
**ret
)
406 unsigned i
, func_cnt
;
413 hres
= get_typeinfo(tid
, &ti
);
417 hres
= ITypeInfo_GetTypeAttr(ti
, &attr
);
419 ITypeInfo_Release(ti
);
423 func_cnt
= attr
->cFuncs
;
424 ITypeInfo_ReleaseTypeAttr(ti
, attr
);
426 ids
= heap_alloc(func_cnt
*sizeof(DISPID
));
428 ITypeInfo_Release(ti
);
429 return E_OUTOFMEMORY
;
432 for(i
=0; i
< func_cnt
; i
++) {
433 hres
= ITypeInfo_GetFuncDesc(ti
, i
, &funcdesc
);
437 ids
[i
] = funcdesc
->memid
;
438 ITypeInfo_ReleaseFuncDesc(ti
, funcdesc
);
441 ITypeInfo_Release(ti
);
447 qsort(ids
, func_cnt
, sizeof(DISPID
), id_cmp
);
449 *ret_size
= func_cnt
;
454 static dispex_data_t
*get_dispex_data(DispatchEx
*This
)
457 return This
->data
->data
;
459 EnterCriticalSection(&cs_dispex_static_data
);
461 if(!This
->data
->data
)
462 This
->data
->data
= preprocess_dispex_data(This
);
464 LeaveCriticalSection(&cs_dispex_static_data
);
466 return This
->data
->data
;
469 static inline BOOL
is_custom_dispid(DISPID id
)
471 return MSHTML_DISPID_CUSTOM_MIN
<= id
&& id
<= MSHTML_DISPID_CUSTOM_MAX
;
474 static inline BOOL
is_dynamic_dispid(DISPID id
)
476 return DISPID_DYNPROP_0
<= id
&& id
<= DISPID_DYNPROP_MAX
;
479 dispex_prop_type_t
get_dispid_type(DISPID id
)
481 if(is_dynamic_dispid(id
))
482 return DISPEXPROP_DYNAMIC
;
483 if(is_custom_dispid(id
))
484 return DISPEXPROP_CUSTOM
;
485 return DISPEXPROP_BUILTIN
;
488 static HRESULT
variant_copy(VARIANT
*dest
, VARIANT
*src
)
490 if(V_VT(src
) == VT_BSTR
&& !V_BSTR(src
)) {
491 V_VT(dest
) = VT_BSTR
;
496 return VariantCopy(dest
, src
);
499 static inline dispex_dynamic_data_t
*get_dynamic_data(DispatchEx
*This
)
501 if(This
->dynamic_data
)
502 return This
->dynamic_data
;
504 This
->dynamic_data
= heap_alloc_zero(sizeof(dispex_dynamic_data_t
));
505 if(!This
->dynamic_data
)
508 if(This
->data
->vtbl
&& This
->data
->vtbl
->populate_props
)
509 This
->data
->vtbl
->populate_props(This
);
511 return This
->dynamic_data
;
514 static HRESULT
get_dynamic_prop(DispatchEx
*This
, const WCHAR
*name
, DWORD flags
, dynamic_prop_t
**ret
)
516 const BOOL alloc
= flags
& fdexNameEnsure
;
517 dispex_dynamic_data_t
*data
;
518 dynamic_prop_t
*prop
;
520 data
= get_dynamic_data(This
);
522 return E_OUTOFMEMORY
;
524 for(prop
= data
->props
; prop
< data
->props
+data
->prop_cnt
; prop
++) {
525 if(flags
& fdexNameCaseInsensitive
? !strcmpiW(prop
->name
, name
) : !strcmpW(prop
->name
, name
)) {
526 if(prop
->flags
& DYNPROP_DELETED
) {
528 return DISP_E_UNKNOWNNAME
;
529 prop
->flags
&= ~DYNPROP_DELETED
;
537 return DISP_E_UNKNOWNNAME
;
539 TRACE("creating dynamic prop %s\n", debugstr_w(name
));
541 if(!data
->buf_size
) {
542 data
->props
= heap_alloc(sizeof(dynamic_prop_t
)*4);
544 return E_OUTOFMEMORY
;
546 }else if(data
->buf_size
== data
->prop_cnt
) {
547 dynamic_prop_t
*new_props
;
549 new_props
= heap_realloc(data
->props
, sizeof(dynamic_prop_t
)*(data
->buf_size
<<1));
551 return E_OUTOFMEMORY
;
553 data
->props
= new_props
;
554 data
->buf_size
<<= 1;
557 prop
= data
->props
+ data
->prop_cnt
;
559 prop
->name
= heap_strdupW(name
);
561 return E_OUTOFMEMORY
;
563 VariantInit(&prop
->var
);
570 HRESULT
dispex_get_dprop_ref(DispatchEx
*This
, const WCHAR
*name
, BOOL alloc
, VARIANT
**ret
)
572 dynamic_prop_t
*prop
;
575 hres
= get_dynamic_prop(This
, name
, alloc
? fdexNameEnsure
: 0, &prop
);
583 HRESULT
dispex_get_dynid(DispatchEx
*This
, const WCHAR
*name
, DISPID
*id
)
585 dynamic_prop_t
*prop
;
588 hres
= get_dynamic_prop(This
, name
, fdexNameEnsure
, &prop
);
592 *id
= DISPID_DYNPROP_0
+ (prop
- This
->dynamic_data
->props
);
596 static HRESULT
dispex_value(DispatchEx
*This
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
597 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
599 if(This
->data
->vtbl
&& This
->data
->vtbl
->value
)
600 return This
->data
->vtbl
->value(This
, lcid
, flags
, params
, res
, ei
, caller
);
603 case DISPATCH_PROPERTYGET
:
605 V_BSTR(res
) = SysAllocString(objectW
);
607 return E_OUTOFMEMORY
;
610 FIXME("Unimplemented flags %x\n", flags
);
617 static HRESULT
typeinfo_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
620 DISPPARAMS params
= {dp
->rgvarg
+dp
->cNamedArgs
, NULL
, dp
->cArgs
-dp
->cNamedArgs
, 0};
626 hres
= get_typeinfo(func
->tid
, &ti
);
628 ERR("Could not get type info: %08x\n", hres
);
632 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&unk
);
634 ERR("Could not get iface %s: %08x\n", debugstr_mshtml_guid(tid_ids
[func
->tid
]), hres
);
638 hres
= ITypeInfo_Invoke(ti
, unk
, func
->id
, flags
, ¶ms
, res
, ei
, &argerr
);
640 IUnknown_Release(unk
);
644 static inline func_disp_t
*impl_from_IUnknown(IUnknown
*iface
)
646 return CONTAINING_RECORD(iface
, func_disp_t
, IUnknown_iface
);
649 static HRESULT WINAPI
Function_QueryInterface(IUnknown
*iface
, REFIID riid
, void **ppv
)
651 func_disp_t
*This
= impl_from_IUnknown(iface
);
653 TRACE("(%p)->(%s %p)\n", This
, debugstr_mshtml_guid(riid
), ppv
);
655 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
656 *ppv
= &This
->IUnknown_iface
;
657 }else if(dispex_query_interface(&This
->dispex
, riid
, ppv
)) {
658 return *ppv
? S_OK
: E_NOINTERFACE
;
661 return E_NOINTERFACE
;
664 IUnknown_AddRef((IUnknown
*)*ppv
);
668 static ULONG WINAPI
Function_AddRef(IUnknown
*iface
)
670 func_disp_t
*This
= impl_from_IUnknown(iface
);
671 LONG ref
= InterlockedIncrement(&This
->ref
);
673 TRACE("(%p) ref=%d\n", This
, ref
);
678 static ULONG WINAPI
Function_Release(IUnknown
*iface
)
680 func_disp_t
*This
= impl_from_IUnknown(iface
);
681 LONG ref
= InterlockedDecrement(&This
->ref
);
683 TRACE("(%p) ref=%d\n", This
, ref
);
687 release_dispex(&This
->dispex
);
694 static const IUnknownVtbl FunctionUnkVtbl
= {
695 Function_QueryInterface
,
700 static inline func_disp_t
*impl_from_DispatchEx(DispatchEx
*iface
)
702 return CONTAINING_RECORD(iface
, func_disp_t
, dispex
);
705 static HRESULT
function_value(DispatchEx
*dispex
, LCID lcid
, WORD flags
, DISPPARAMS
*params
,
706 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
708 func_disp_t
*This
= impl_from_DispatchEx(dispex
);
712 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
716 case DISPATCH_METHOD
:
719 hres
= typeinfo_invoke(This
->obj
, This
->info
, flags
, params
, res
, ei
);
721 case DISPATCH_PROPERTYGET
: {
726 static const WCHAR func_prefixW
[] =
727 {'\n','f','u','n','c','t','i','o','n',' '};
728 static const WCHAR func_suffixW
[] =
729 {'(',')',' ','{','\n',' ',' ',' ',' ','[','n','a','t','i','v','e',' ','c','o','d','e',']','\n','}','\n'};
731 /* FIXME: This probably should be more generic. Also we should try to get IID_IActiveScriptSite and SID_GetCaller. */
733 return E_ACCESSDENIED
;
735 name_len
= SysStringLen(This
->info
->name
);
736 ptr
= str
= SysAllocStringLen(NULL
, name_len
+ (sizeof(func_prefixW
)+sizeof(func_suffixW
))/sizeof(WCHAR
));
738 return E_OUTOFMEMORY
;
740 memcpy(ptr
, func_prefixW
, sizeof(func_prefixW
));
741 ptr
+= sizeof(func_prefixW
)/sizeof(WCHAR
);
743 memcpy(ptr
, This
->info
->name
, name_len
*sizeof(WCHAR
));
746 memcpy(ptr
, func_suffixW
, sizeof(func_suffixW
));
753 FIXME("Unimplemented flags %x\n", flags
);
760 static const dispex_static_data_vtbl_t function_dispex_vtbl
= {
767 static const tid_t function_iface_tids
[] = {0};
769 static dispex_static_data_t function_dispex
= {
770 &function_dispex_vtbl
,
776 static func_disp_t
*create_func_disp(DispatchEx
*obj
, func_info_t
*info
)
780 ret
= heap_alloc_zero(sizeof(func_disp_t
));
784 ret
->IUnknown_iface
.lpVtbl
= &FunctionUnkVtbl
;
785 init_dispex(&ret
->dispex
, &ret
->IUnknown_iface
, &function_dispex
);
793 static HRESULT
invoke_disp_value(DispatchEx
*This
, IDispatch
*func_disp
, LCID lcid
, WORD flags
, DISPPARAMS
*dp
,
794 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
796 DISPID named_arg
= DISPID_THIS
;
797 DISPPARAMS new_dp
= {NULL
, &named_arg
, 0, 1};
802 FIXME("named args not supported\n");
806 new_dp
.rgvarg
= heap_alloc((dp
->cArgs
+1)*sizeof(VARIANTARG
));
808 return E_OUTOFMEMORY
;
810 new_dp
.cArgs
= dp
->cArgs
+1;
811 memcpy(new_dp
.rgvarg
+1, dp
->rgvarg
, dp
->cArgs
*sizeof(VARIANTARG
));
813 V_VT(new_dp
.rgvarg
) = VT_DISPATCH
;
814 V_DISPATCH(new_dp
.rgvarg
) = (IDispatch
*)&This
->IDispatchEx_iface
;
816 hres
= IDispatch_QueryInterface(func_disp
, &IID_IDispatchEx
, (void**)&dispex
);
818 if(SUCCEEDED(hres
)) {
819 hres
= IDispatchEx_InvokeEx(dispex
, DISPID_VALUE
, lcid
, flags
, &new_dp
, res
, ei
, caller
);
820 IDispatchEx_Release(dispex
);
823 hres
= IDispatch_Invoke(func_disp
, DISPID_VALUE
, &IID_NULL
, lcid
, flags
, &new_dp
, res
, ei
, &err
);
826 TRACE("<<< %s\n", debugstr_variant(res
));
828 WARN("<<< %08x\n", hres
);
830 heap_free(new_dp
.rgvarg
);
834 static HRESULT
get_func_obj_entry(DispatchEx
*This
, func_info_t
*func
, func_obj_entry_t
**ret
)
836 dispex_dynamic_data_t
*dynamic_data
;
837 func_obj_entry_t
*entry
;
839 dynamic_data
= get_dynamic_data(This
);
841 return E_OUTOFMEMORY
;
843 if(!dynamic_data
->func_disps
) {
844 dynamic_data
->func_disps
= heap_alloc_zero(This
->data
->data
->func_disp_cnt
* sizeof(*dynamic_data
->func_disps
));
845 if(!dynamic_data
->func_disps
)
846 return E_OUTOFMEMORY
;
849 entry
= dynamic_data
->func_disps
+ func
->func_disp_idx
;
850 if(!entry
->func_obj
) {
851 entry
->func_obj
= create_func_disp(This
, func
);
853 return E_OUTOFMEMORY
;
855 IDispatchEx_AddRef(&entry
->func_obj
->dispex
.IDispatchEx_iface
);
856 V_VT(&entry
->val
) = VT_DISPATCH
;
857 V_DISPATCH(&entry
->val
) = (IDispatch
*)&entry
->func_obj
->dispex
.IDispatchEx_iface
;
864 static HRESULT
get_builtin_func(dispex_data_t
*data
, DISPID id
, func_info_t
**ret
)
869 max
= data
->func_cnt
-1;
874 if(data
->funcs
[n
].id
== id
) {
875 *ret
= data
->funcs
+n
;
879 if(data
->funcs
[n
].id
< id
)
885 WARN("invalid id %x\n", id
);
886 return DISP_E_UNKNOWNNAME
;
889 static HRESULT
get_builtin_id(DispatchEx
*This
, BSTR name
, DWORD grfdex
, DISPID
*ret
)
894 data
= get_dispex_data(This
);
899 max
= data
->func_cnt
-1;
904 c
= strcmpiW(data
->name_table
[n
]->name
, name
);
906 if((grfdex
& fdexNameCaseSensitive
) && strcmpW(data
->name_table
[n
]->name
, name
))
909 *ret
= data
->name_table
[n
]->id
;
919 if(This
->data
->vtbl
&& This
->data
->vtbl
->get_dispid
) {
922 hres
= This
->data
->vtbl
->get_dispid(This
, name
, grfdex
, ret
);
923 if(hres
!= DISP_E_UNKNOWNNAME
)
927 return DISP_E_UNKNOWNNAME
;
930 static HRESULT
change_type(VARIANT
*dst
, VARIANT
*src
, VARTYPE vt
, IServiceProvider
*caller
)
932 V_VT(dst
) = VT_EMPTY
;
935 IVariantChangeType
*change_type
= NULL
;
938 hres
= IServiceProvider_QueryService(caller
, &SID_VariantConversion
, &IID_IVariantChangeType
, (void**)&change_type
);
939 if(SUCCEEDED(hres
)) {
940 hres
= IVariantChangeType_ChangeType(change_type
, dst
, src
, LOCALE_NEUTRAL
, vt
);
941 IVariantChangeType_Release(change_type
);
948 if(V_VT(src
) == VT_BSTR
) {
950 V_BOOL(dst
) = V_BSTR(src
) && *V_BSTR(src
) ? VARIANT_TRUE
: VARIANT_FALSE
;
956 return VariantChangeType(dst
, src
, 0, vt
);
959 static HRESULT
builtin_propget(DispatchEx
*This
, func_info_t
*func
, DISPPARAMS
*dp
, VARIANT
*res
)
964 if(dp
&& dp
->cArgs
) {
965 FIXME("cArgs %d\n", dp
->cArgs
);
969 assert(func
->get_vtbl_off
);
971 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&iface
);
972 if(SUCCEEDED(hres
)) {
973 switch(func
->prop_vt
) {
974 #define CASE_VT(vt,type,access) \
977 hres = ((HRESULT (WINAPI*)(IUnknown*,type*))((void**)iface->lpVtbl)[func->get_vtbl_off])(iface,&val); \
978 if(SUCCEEDED(hres)) \
982 BUILTIN_TYPES_SWITCH
;
985 FIXME("Unhandled vt %d\n", func
->prop_vt
);
988 IUnknown_Release(iface
);
994 if(func
->prop_vt
!= VT_VARIANT
)
995 V_VT(res
) = func
->prop_vt
== VT_PTR
? VT_DISPATCH
: func
->prop_vt
;
999 static HRESULT
builtin_propput(DispatchEx
*This
, func_info_t
*func
, DISPPARAMS
*dp
, IServiceProvider
*caller
)
1005 if(dp
->cArgs
!= 1 || (dp
->cNamedArgs
== 1 && *dp
->rgdispidNamedArgs
!= DISPID_PROPERTYPUT
)
1006 || dp
->cNamedArgs
> 1) {
1007 FIXME("invalid args\n");
1008 return E_INVALIDARG
;
1011 if(!func
->put_vtbl_off
) {
1012 FIXME("No setter\n");
1017 if(func
->prop_vt
!= VT_VARIANT
&& V_VT(v
) != func
->prop_vt
) {
1018 hres
= change_type(&tmpv
, v
, func
->prop_vt
, caller
);
1024 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&iface
);
1025 if(SUCCEEDED(hres
)) {
1026 switch(func
->prop_vt
) {
1027 #define CASE_VT(vt,type,access) \
1029 hres = ((HRESULT (WINAPI*)(IUnknown*,type))((void**)iface->lpVtbl)[func->put_vtbl_off])(iface,access(v)); \
1031 BUILTIN_TYPES_SWITCH
;
1034 FIXME("Unimplemented vt %d\n", func
->prop_vt
);
1038 IUnknown_Release(iface
);
1046 static HRESULT
invoke_builtin_function(DispatchEx
*This
, func_info_t
*func
, DISPPARAMS
*dp
, VARIANT
*res
, IServiceProvider
*caller
)
1048 VARIANT arg_buf
[MAX_ARGS
], *arg_ptrs
[MAX_ARGS
], *arg
, retv
, ret_ref
, vhres
;
1049 unsigned i
, nconv
= 0;
1053 if(dp
->cNamedArgs
) {
1054 FIXME("Named arguments not supported\n");
1058 if(dp
->cArgs
!= func
->argc
) {
1059 FIXME("Invalid argument count (expected %u, got %u)\n", func
->argc
, dp
->cArgs
);
1060 return E_INVALIDARG
;
1063 hres
= IUnknown_QueryInterface(This
->outer
, tid_ids
[func
->tid
], (void**)&iface
);
1067 for(i
=0; i
< func
->argc
; i
++) {
1068 arg
= dp
->rgvarg
+dp
->cArgs
-i
-1;
1069 if(func
->arg_types
[i
] == V_VT(arg
)) {
1072 hres
= change_type(arg_buf
+nconv
, arg
, func
->arg_types
[i
], caller
);
1075 arg_ptrs
[i
] = arg_buf
+ nconv
++;
1079 if(SUCCEEDED(hres
)) {
1080 if(func
->prop_vt
== VT_VOID
) {
1081 V_VT(&retv
) = VT_EMPTY
;
1083 V_VT(&retv
) = func
->prop_vt
;
1084 arg_ptrs
[func
->argc
] = &ret_ref
;
1085 V_VT(&ret_ref
) = VT_BYREF
|func
->prop_vt
;
1087 switch(func
->prop_vt
) {
1088 #define CASE_VT(vt,type,access) \
1090 V_BYREF(&ret_ref) = &access(&retv); \
1092 BUILTIN_TYPES_SWITCH
;
1099 V_VT(&vhres
) = VT_ERROR
;
1100 hres
= DispCallFunc(iface
, func
->call_vtbl_off
*sizeof(void*), CC_STDCALL
, VT_ERROR
,
1101 func
->argc
+ (func
->prop_vt
== VT_VOID
? 0 : 1), func
->arg_types
, arg_ptrs
, &vhres
);
1105 VariantClear(arg_buf
+nconv
);
1106 IUnknown_Release(iface
);
1109 if(FAILED(V_ERROR(&vhres
)))
1110 return V_ERROR(&vhres
);
1115 VariantClear(&retv
);
1116 return V_ERROR(&vhres
);
1119 static HRESULT
function_invoke(DispatchEx
*This
, func_info_t
*func
, WORD flags
, DISPPARAMS
*dp
, VARIANT
*res
,
1120 EXCEPINFO
*ei
, IServiceProvider
*caller
)
1125 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
1127 return E_INVALIDARG
;
1129 case DISPATCH_METHOD
:
1130 if(This
->dynamic_data
&& This
->dynamic_data
->func_disps
1131 && This
->dynamic_data
->func_disps
[func
->func_disp_idx
].func_obj
) {
1132 func_obj_entry_t
*entry
= This
->dynamic_data
->func_disps
+ func
->func_disp_idx
;
1134 if(V_VT(&entry
->val
) != VT_DISPATCH
) {
1135 FIXME("calling %s not supported\n", debugstr_variant(&entry
->val
));
1139 if((IDispatch
*)&entry
->func_obj
->dispex
.IDispatchEx_iface
!= V_DISPATCH(&entry
->val
)) {
1140 if(!V_DISPATCH(&entry
->val
)) {
1141 FIXME("Calling null\n");
1145 hres
= invoke_disp_value(This
, V_DISPATCH(&entry
->val
), 0, flags
, dp
, res
, ei
, NULL
);
1150 if(func
->call_vtbl_off
)
1151 hres
= invoke_builtin_function(This
, func
, dp
, res
, caller
);
1153 hres
= typeinfo_invoke(This
, func
, flags
, dp
, res
, ei
);
1155 case DISPATCH_PROPERTYGET
: {
1156 func_obj_entry_t
*entry
;
1158 if(func
->id
== DISPID_VALUE
) {
1161 ret
= SysAllocString(objectW
);
1163 return E_OUTOFMEMORY
;
1165 V_VT(res
) = VT_BSTR
;
1170 hres
= get_func_obj_entry(This
, func
, &entry
);
1174 V_VT(res
) = VT_EMPTY
;
1175 return VariantCopy(res
, &entry
->val
);
1177 case DISPATCH_PROPERTYPUT
: {
1178 func_obj_entry_t
*entry
;
1180 if(dp
->cArgs
!= 1 || (dp
->cNamedArgs
== 1 && *dp
->rgdispidNamedArgs
!= DISPID_PROPERTYPUT
)
1181 || dp
->cNamedArgs
> 1) {
1182 FIXME("invalid args\n");
1183 return E_INVALIDARG
;
1187 * NOTE: Although we have IDispatchEx tests showing, that it's not allowed to set
1188 * function property using InvokeEx, it's possible to do that from jscript.
1189 * Native probably uses some undocumented interface in this case, but it should
1190 * be fine for us to allow IDispatchEx handle that.
1192 hres
= get_func_obj_entry(This
, func
, &entry
);
1196 return VariantCopy(&entry
->val
, dp
->rgvarg
);
1199 FIXME("Unimplemented flags %x\n", flags
);
1206 static HRESULT
invoke_builtin_prop(DispatchEx
*This
, DISPID id
, LCID lcid
, WORD flags
, DISPPARAMS
*dp
,
1207 VARIANT
*res
, EXCEPINFO
*ei
, IServiceProvider
*caller
)
1209 dispex_data_t
*data
;
1213 data
= get_dispex_data(This
);
1217 hres
= get_builtin_func(data
, id
, &func
);
1218 if(id
== DISPID_VALUE
&& hres
== DISP_E_UNKNOWNNAME
)
1219 return dispex_value(This
, lcid
, flags
, dp
, res
, ei
, caller
);
1223 if(func
->func_disp_idx
!= -1)
1224 return function_invoke(This
, func
, flags
, dp
, res
, ei
, caller
);
1227 case DISPATCH_PROPERTYPUT
:
1229 V_VT(res
) = VT_EMPTY
;
1230 hres
= builtin_propput(This
, func
, dp
, caller
);
1232 case DISPATCH_PROPERTYGET
:
1233 hres
= builtin_propget(This
, func
, dp
, res
);
1236 if(!func
->get_vtbl_off
) {
1237 hres
= typeinfo_invoke(This
, func
, flags
, dp
, res
, ei
);
1241 hres
= builtin_propget(This
, func
, NULL
, &v
);
1245 if(flags
!= (DISPATCH_PROPERTYGET
|DISPATCH_METHOD
) || dp
->cArgs
) {
1246 if(V_VT(&v
) != VT_DISPATCH
) {
1247 FIXME("Not a function %s flags %08x\n", debugstr_variant(&v
), flags
);
1252 hres
= invoke_disp_value(This
, V_DISPATCH(&v
), lcid
, flags
, dp
, res
, ei
, caller
);
1253 IDispatch_Release(V_DISPATCH(&v
));
1265 HRESULT
remove_attribute(DispatchEx
*This
, DISPID id
, VARIANT_BOOL
*success
)
1267 switch(get_dispid_type(id
)) {
1268 case DISPEXPROP_CUSTOM
:
1269 FIXME("DISPEXPROP_CUSTOM not supported\n");
1272 case DISPEXPROP_DYNAMIC
: {
1273 DWORD idx
= id
- DISPID_DYNPROP_0
;
1274 dynamic_prop_t
*prop
;
1276 prop
= This
->dynamic_data
->props
+idx
;
1277 VariantClear(&prop
->var
);
1278 prop
->flags
|= DYNPROP_DELETED
;
1279 *success
= VARIANT_TRUE
;
1282 case DISPEXPROP_BUILTIN
: {
1284 DISPPARAMS dp
= {&var
,NULL
,1,0};
1285 dispex_data_t
*data
;
1289 data
= get_dispex_data(This
);
1293 hres
= get_builtin_func(data
, id
, &func
);
1297 /* For builtin functions, we set their value to the original function. */
1298 if(func
->func_disp_idx
!= -1) {
1299 func_obj_entry_t
*entry
;
1301 if(!This
->dynamic_data
|| !This
->dynamic_data
->func_disps
1302 || !This
->dynamic_data
->func_disps
[func
->func_disp_idx
].func_obj
) {
1303 *success
= VARIANT_FALSE
;
1307 entry
= This
->dynamic_data
->func_disps
+ func
->func_disp_idx
;
1308 if(V_VT(&entry
->val
) == VT_DISPATCH
1309 && V_DISPATCH(&entry
->val
) == (IDispatch
*)&entry
->func_obj
->dispex
.IDispatchEx_iface
) {
1310 *success
= VARIANT_FALSE
;
1314 VariantClear(&entry
->val
);
1315 V_VT(&entry
->val
) = VT_DISPATCH
;
1316 V_DISPATCH(&entry
->val
) = (IDispatch
*)&entry
->func_obj
->dispex
.IDispatchEx_iface
;
1317 IDispatch_AddRef(V_DISPATCH(&entry
->val
));
1318 *success
= VARIANT_TRUE
;
1322 V_VT(&var
) = VT_EMPTY
;
1323 hres
= builtin_propput(This
, func
, &dp
, NULL
);
1327 *success
= VARIANT_TRUE
;
1336 static inline DispatchEx
*impl_from_IDispatchEx(IDispatchEx
*iface
)
1338 return CONTAINING_RECORD(iface
, DispatchEx
, IDispatchEx_iface
);
1341 static HRESULT WINAPI
DispatchEx_QueryInterface(IDispatchEx
*iface
, REFIID riid
, void **ppv
)
1343 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1345 return IUnknown_QueryInterface(This
->outer
, riid
, ppv
);
1348 static ULONG WINAPI
DispatchEx_AddRef(IDispatchEx
*iface
)
1350 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1352 return IUnknown_AddRef(This
->outer
);
1355 static ULONG WINAPI
DispatchEx_Release(IDispatchEx
*iface
)
1357 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1359 return IUnknown_Release(This
->outer
);
1362 static HRESULT WINAPI
DispatchEx_GetTypeInfoCount(IDispatchEx
*iface
, UINT
*pctinfo
)
1364 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1366 TRACE("(%p)->(%p)\n", This
, pctinfo
);
1372 static HRESULT WINAPI
DispatchEx_GetTypeInfo(IDispatchEx
*iface
, UINT iTInfo
,
1373 LCID lcid
, ITypeInfo
**ppTInfo
)
1375 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1378 TRACE("(%p)->(%u %u %p)\n", This
, iTInfo
, lcid
, ppTInfo
);
1380 hres
= get_typeinfo(This
->data
->disp_tid
, ppTInfo
);
1384 ITypeInfo_AddRef(*ppTInfo
);
1388 static HRESULT WINAPI
DispatchEx_GetIDsOfNames(IDispatchEx
*iface
, REFIID riid
,
1389 LPOLESTR
*rgszNames
, UINT cNames
,
1390 LCID lcid
, DISPID
*rgDispId
)
1392 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1396 TRACE("(%p)->(%s %p %u %u %p)\n", This
, debugstr_guid(riid
), rgszNames
, cNames
,
1399 for(i
=0; i
< cNames
; i
++) {
1400 hres
= IDispatchEx_GetDispID(&This
->IDispatchEx_iface
, rgszNames
[i
], 0, rgDispId
+i
);
1408 static HRESULT WINAPI
DispatchEx_Invoke(IDispatchEx
*iface
, DISPID dispIdMember
,
1409 REFIID riid
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pDispParams
,
1410 VARIANT
*pVarResult
, EXCEPINFO
*pExcepInfo
, UINT
*puArgErr
)
1412 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1414 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This
, dispIdMember
, debugstr_guid(riid
),
1415 lcid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
1417 return IDispatchEx_InvokeEx(&This
->IDispatchEx_iface
, dispIdMember
, lcid
, wFlags
, pDispParams
,
1418 pVarResult
, pExcepInfo
, NULL
);
1421 static HRESULT WINAPI
DispatchEx_GetDispID(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
, DISPID
*pid
)
1423 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1424 dynamic_prop_t
*dprop
;
1427 TRACE("(%p)->(%s %x %p)\n", This
, debugstr_w(bstrName
), grfdex
, pid
);
1429 if(grfdex
& ~(fdexNameCaseSensitive
|fdexNameCaseInsensitive
|fdexNameEnsure
|fdexNameImplicit
|FDEX_VERSION_MASK
))
1430 FIXME("Unsupported grfdex %x\n", grfdex
);
1432 hres
= get_builtin_id(This
, bstrName
, grfdex
, pid
);
1433 if(hres
!= DISP_E_UNKNOWNNAME
)
1436 hres
= get_dynamic_prop(This
, bstrName
, grfdex
, &dprop
);
1440 *pid
= DISPID_DYNPROP_0
+ (dprop
- This
->dynamic_data
->props
);
1444 static HRESULT WINAPI
DispatchEx_InvokeEx(IDispatchEx
*iface
, DISPID id
, LCID lcid
, WORD wFlags
, DISPPARAMS
*pdp
,
1445 VARIANT
*pvarRes
, EXCEPINFO
*pei
, IServiceProvider
*pspCaller
)
1447 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1450 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
1452 if(wFlags
== (DISPATCH_PROPERTYPUT
|DISPATCH_PROPERTYPUTREF
))
1453 wFlags
= DISPATCH_PROPERTYPUT
;
1455 switch(get_dispid_type(id
)) {
1456 case DISPEXPROP_CUSTOM
:
1457 if(!This
->data
->vtbl
|| !This
->data
->vtbl
->invoke
)
1458 return DISP_E_UNKNOWNNAME
;
1459 return This
->data
->vtbl
->invoke(This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
1461 case DISPEXPROP_DYNAMIC
: {
1462 DWORD idx
= id
- DISPID_DYNPROP_0
;
1463 dynamic_prop_t
*prop
;
1465 if(!get_dynamic_data(This
) || This
->dynamic_data
->prop_cnt
<= idx
)
1466 return DISP_E_UNKNOWNNAME
;
1468 prop
= This
->dynamic_data
->props
+idx
;
1471 case DISPATCH_METHOD
|DISPATCH_PROPERTYGET
:
1473 return E_INVALIDARG
;
1475 case DISPATCH_METHOD
:
1476 if(V_VT(&prop
->var
) != VT_DISPATCH
) {
1477 FIXME("invoke %s\n", debugstr_variant(&prop
->var
));
1481 return invoke_disp_value(This
, V_DISPATCH(&prop
->var
), lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
1482 case DISPATCH_PROPERTYGET
:
1483 if(prop
->flags
& DYNPROP_DELETED
)
1484 return DISP_E_UNKNOWNNAME
;
1485 V_VT(pvarRes
) = VT_EMPTY
;
1486 return variant_copy(pvarRes
, &prop
->var
);
1487 case DISPATCH_PROPERTYPUT
:
1488 if(pdp
->cArgs
!= 1 || (pdp
->cNamedArgs
== 1 && *pdp
->rgdispidNamedArgs
!= DISPID_PROPERTYPUT
)
1489 || pdp
->cNamedArgs
> 1) {
1490 FIXME("invalid args\n");
1491 return E_INVALIDARG
;
1494 TRACE("put %s\n", debugstr_variant(pdp
->rgvarg
));
1495 VariantClear(&prop
->var
);
1496 hres
= variant_copy(&prop
->var
, pdp
->rgvarg
);
1500 prop
->flags
&= ~DYNPROP_DELETED
;
1503 FIXME("unhandled wFlags %x\n", wFlags
);
1507 case DISPEXPROP_BUILTIN
:
1508 if(wFlags
== DISPATCH_CONSTRUCT
) {
1509 if(id
== DISPID_VALUE
) {
1510 if(This
->data
->vtbl
&& This
->data
->vtbl
->value
) {
1511 return This
->data
->vtbl
->value(This
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
1513 FIXME("DISPATCH_CONSTRUCT flag but missing value function\n");
1516 FIXME("DISPATCH_CONSTRUCT flag without DISPID_VALUE\n");
1520 return invoke_builtin_prop(This
, id
, lcid
, wFlags
, pdp
, pvarRes
, pei
, pspCaller
);
1527 static HRESULT WINAPI
DispatchEx_DeleteMemberByName(IDispatchEx
*iface
, BSTR bstrName
, DWORD grfdex
)
1529 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1531 TRACE("(%p)->(%s %x)\n", This
, debugstr_w(bstrName
), grfdex
);
1533 /* Not implemented by IE */
1537 static HRESULT WINAPI
DispatchEx_DeleteMemberByDispID(IDispatchEx
*iface
, DISPID id
)
1539 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1541 TRACE("(%p)->(%x)\n", This
, id
);
1543 /* Not implemented by IE */
1547 static HRESULT WINAPI
DispatchEx_GetMemberProperties(IDispatchEx
*iface
, DISPID id
, DWORD grfdexFetch
, DWORD
*pgrfdex
)
1549 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1550 FIXME("(%p)->(%x %x %p)\n", This
, id
, grfdexFetch
, pgrfdex
);
1554 static HRESULT WINAPI
DispatchEx_GetMemberName(IDispatchEx
*iface
, DISPID id
, BSTR
*pbstrName
)
1556 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1557 dispex_data_t
*data
;
1561 TRACE("(%p)->(%x %p)\n", This
, id
, pbstrName
);
1563 if(is_dynamic_dispid(id
)) {
1564 DWORD idx
= id
- DISPID_DYNPROP_0
;
1566 if(!get_dynamic_data(This
) || This
->dynamic_data
->prop_cnt
<= idx
)
1567 return DISP_E_UNKNOWNNAME
;
1569 *pbstrName
= SysAllocString(This
->dynamic_data
->props
[idx
].name
);
1571 return E_OUTOFMEMORY
;
1576 data
= get_dispex_data(This
);
1580 hres
= get_builtin_func(data
, id
, &func
);
1584 *pbstrName
= SysAllocString(func
->name
);
1586 return E_OUTOFMEMORY
;
1590 static HRESULT WINAPI
DispatchEx_GetNextDispID(IDispatchEx
*iface
, DWORD grfdex
, DISPID id
, DISPID
*pid
)
1592 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1593 dispex_data_t
*data
;
1597 TRACE("(%p)->(%x %x %p)\n", This
, grfdex
, id
, pid
);
1599 if(is_dynamic_dispid(id
)) {
1600 DWORD idx
= id
- DISPID_DYNPROP_0
;
1602 if(!get_dynamic_data(This
) || This
->dynamic_data
->prop_cnt
<= idx
)
1603 return DISP_E_UNKNOWNNAME
;
1605 while(++idx
< This
->dynamic_data
->prop_cnt
&& This
->dynamic_data
->props
[idx
].flags
& DYNPROP_DELETED
);
1607 if(idx
== This
->dynamic_data
->prop_cnt
) {
1608 *pid
= DISPID_STARTENUM
;
1612 *pid
= DISPID_DYNPROP_0
+idx
;
1616 data
= get_dispex_data(This
);
1620 if(id
== DISPID_STARTENUM
) {
1623 hres
= get_builtin_func(data
, id
, &func
);
1629 while(func
< data
->funcs
+data
->func_cnt
) {
1630 /* FIXME: Skip hidden properties */
1631 if(func
->func_disp_idx
== -1) {
1638 if(get_dynamic_data(This
) && This
->dynamic_data
->prop_cnt
) {
1639 *pid
= DISPID_DYNPROP_0
;
1643 *pid
= DISPID_STARTENUM
;
1647 static HRESULT WINAPI
DispatchEx_GetNameSpaceParent(IDispatchEx
*iface
, IUnknown
**ppunk
)
1649 DispatchEx
*This
= impl_from_IDispatchEx(iface
);
1650 FIXME("(%p)->(%p)\n", This
, ppunk
);
1654 static IDispatchExVtbl DispatchExVtbl
= {
1655 DispatchEx_QueryInterface
,
1658 DispatchEx_GetTypeInfoCount
,
1659 DispatchEx_GetTypeInfo
,
1660 DispatchEx_GetIDsOfNames
,
1662 DispatchEx_GetDispID
,
1663 DispatchEx_InvokeEx
,
1664 DispatchEx_DeleteMemberByName
,
1665 DispatchEx_DeleteMemberByDispID
,
1666 DispatchEx_GetMemberProperties
,
1667 DispatchEx_GetMemberName
,
1668 DispatchEx_GetNextDispID
,
1669 DispatchEx_GetNameSpaceParent
1672 BOOL
dispex_query_interface(DispatchEx
*This
, REFIID riid
, void **ppv
)
1674 if(IsEqualGUID(&IID_IDispatch
, riid
))
1675 *ppv
= &This
->IDispatchEx_iface
;
1676 else if(IsEqualGUID(&IID_IDispatchEx
, riid
))
1677 *ppv
= &This
->IDispatchEx_iface
;
1678 else if(IsEqualGUID(&IID_IDispatchJS
, riid
))
1680 else if(IsEqualGUID(&IID_UndocumentedScriptIface
, riid
))
1686 IUnknown_AddRef((IUnknown
*)*ppv
);
1690 void dispex_traverse(DispatchEx
*This
, nsCycleCollectionTraversalCallback
*cb
)
1692 dynamic_prop_t
*prop
;
1694 if(!This
->dynamic_data
)
1697 for(prop
= This
->dynamic_data
->props
; prop
< This
->dynamic_data
->props
+ This
->dynamic_data
->prop_cnt
; prop
++) {
1698 if(V_VT(&prop
->var
) == VT_DISPATCH
)
1699 note_cc_edge((nsISupports
*)V_DISPATCH(&prop
->var
), "dispex_data", cb
);
1702 /* FIXME: Traverse func_disps */
1705 void dispex_unlink(DispatchEx
*This
)
1707 dynamic_prop_t
*prop
;
1709 if(!This
->dynamic_data
)
1712 for(prop
= This
->dynamic_data
->props
; prop
< This
->dynamic_data
->props
+ This
->dynamic_data
->prop_cnt
; prop
++) {
1713 if(V_VT(&prop
->var
) == VT_DISPATCH
) {
1714 V_VT(&prop
->var
) = VT_EMPTY
;
1715 IDispatch_Release(V_DISPATCH(&prop
->var
));
1717 VariantClear(&prop
->var
);
1722 void release_dispex(DispatchEx
*This
)
1724 dynamic_prop_t
*prop
;
1726 if(!This
->dynamic_data
)
1729 for(prop
= This
->dynamic_data
->props
; prop
< This
->dynamic_data
->props
+ This
->dynamic_data
->prop_cnt
; prop
++) {
1730 VariantClear(&prop
->var
);
1731 heap_free(prop
->name
);
1734 heap_free(This
->dynamic_data
->props
);
1736 if(This
->dynamic_data
->func_disps
) {
1737 func_obj_entry_t
*iter
;
1739 for(iter
= This
->dynamic_data
->func_disps
; iter
< This
->dynamic_data
->func_disps
+This
->data
->data
->func_disp_cnt
; iter
++) {
1740 if(iter
->func_obj
) {
1741 iter
->func_obj
->obj
= NULL
;
1742 IDispatchEx_Release(&iter
->func_obj
->dispex
.IDispatchEx_iface
);
1744 VariantClear(&iter
->val
);
1747 heap_free(This
->dynamic_data
->func_disps
);
1750 heap_free(This
->dynamic_data
);
1753 void init_dispex(DispatchEx
*dispex
, IUnknown
*outer
, dispex_static_data_t
*data
)
1755 dispex
->IDispatchEx_iface
.lpVtbl
= &DispatchExVtbl
;
1756 dispex
->outer
= outer
;
1757 dispex
->data
= data
;
1758 dispex
->dynamic_data
= NULL
;