richedit: Added test for word wrapping behaviour.
[wine] / dlls / jscript / dispex.c
1 /*
2  * Copyright 2008 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "jscript.h"
20
21 #include "wine/unicode.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
25
26 /*
27  * This IID is used to get DispatchEx objecto from interface.
28  * We might consider using private insteface instead.
29  */
30 static const IID IID_IDispatchJS =
31         {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
32
33 typedef enum {
34     PROP_VARIANT,
35     PROP_BUILTIN,
36     PROP_PROTREF,
37     PROP_DELETED
38 } prop_type_t;
39
40 struct _dispex_prop_t {
41     WCHAR *name;
42     prop_type_t type;
43     DWORD flags;
44
45     union {
46         VARIANT var;
47         const builtin_prop_t *p;
48         DWORD ref;
49     } u;
50 };
51
52 static inline DISPID prop_to_id(DispatchEx *This, dispex_prop_t *prop)
53 {
54     return prop - This->props;
55 }
56
57 static inline dispex_prop_t *get_prop(DispatchEx *This, DISPID id)
58 {
59     if(id < 0 || id >= This->prop_cnt || This->props[id].type == PROP_DELETED)
60         return NULL;
61
62     return This->props+id;
63 }
64
65 static DWORD get_flags(DispatchEx *This, dispex_prop_t *prop)
66 {
67     if(prop->type == PROP_PROTREF) {
68         dispex_prop_t *parent = get_prop(This->prototype, prop->u.ref);
69         if(!parent) {
70             prop->type = PROP_DELETED;
71             return 0;
72         }
73
74         return get_flags(This->prototype, parent);
75     }
76
77     return prop->flags;
78 }
79
80 static const builtin_prop_t *find_builtin_prop(DispatchEx *This, const WCHAR *name)
81 {
82     int min = 0, max, i, r;
83
84     max = This->builtin_info->props_cnt-1;
85     while(min <= max) {
86         i = (min+max)/2;
87
88         r = strcmpW(name, This->builtin_info->props[i].name);
89         if(!r)
90             return This->builtin_info->props + i;
91
92         if(r < 0)
93             max = i-1;
94         else
95             min = i+1;
96     }
97
98     return NULL;
99 }
100
101 static dispex_prop_t *alloc_prop(DispatchEx *This, const WCHAR *name, prop_type_t type, DWORD flags)
102 {
103     dispex_prop_t *ret;
104
105     if(This->buf_size == This->prop_cnt) {
106         dispex_prop_t *tmp = heap_realloc(This->props, (This->buf_size<<=1)*sizeof(*This->props));
107         if(!tmp)
108             return NULL;
109         This->props = tmp;
110     }
111
112     ret = This->props + This->prop_cnt++;
113     ret->type = type;
114     ret->flags = flags;
115     ret->name = heap_strdupW(name);
116     if(!ret->name)
117         return NULL;
118
119     return ret;
120 }
121
122 static dispex_prop_t *alloc_protref(DispatchEx *This, const WCHAR *name, DWORD ref)
123 {
124     dispex_prop_t *ret;
125
126     ret = alloc_prop(This, name, PROP_PROTREF, 0);
127     if(!ret)
128         return NULL;
129
130     ret->u.ref = ref;
131     return ret;
132 }
133
134 static HRESULT find_prop_name(DispatchEx *This, const WCHAR *name, dispex_prop_t **ret)
135 {
136     const builtin_prop_t *builtin;
137     dispex_prop_t *prop;
138
139     for(prop = This->props; prop < This->props+This->prop_cnt; prop++) {
140         if(prop->name && !strcmpW(prop->name, name)) {
141             *ret = prop;
142             return S_OK;
143         }
144     }
145
146     builtin = find_builtin_prop(This, name);
147     if(builtin) {
148         prop = alloc_prop(This, name, PROP_BUILTIN, builtin->flags);
149         if(!prop)
150             return E_OUTOFMEMORY;
151
152         prop->u.p = builtin;
153         *ret = prop;
154         return S_OK;
155     }
156
157     *ret = NULL;
158     return S_OK;
159 }
160
161 static HRESULT find_prop_name_prot(DispatchEx *This, const WCHAR *name, BOOL alloc, dispex_prop_t **ret)
162 {
163     dispex_prop_t *prop;
164     HRESULT hres;
165
166     hres = find_prop_name(This, name, &prop);
167     if(FAILED(hres))
168         return hres;
169     if(prop) {
170         *ret = prop;
171         return S_OK;
172     }
173
174     if(This->prototype) {
175         hres = find_prop_name_prot(This->prototype, name, FALSE, &prop);
176         if(FAILED(hres))
177             return hres;
178         if(prop) {
179             prop = alloc_protref(This, prop->name, prop - This->prototype->props);
180             if(!prop)
181                 return E_OUTOFMEMORY;
182             *ret = prop;
183             return S_OK;
184         }
185     }
186
187     if(alloc) {
188         TRACE("creating prop %s\n", debugstr_w(name));
189
190         prop = alloc_prop(This, name, PROP_VARIANT, PROPF_ENUM);
191         if(!prop)
192             return E_OUTOFMEMORY;
193         VariantInit(&prop->u.var);
194     }
195
196     *ret = prop;
197     return S_OK;
198 }
199
200 static HRESULT set_this(DISPPARAMS *dp, DISPPARAMS *olddp, IDispatch *jsthis)
201 {
202     VARIANTARG *oldargs;
203     int i;
204
205     static DISPID this_id = DISPID_THIS;
206
207     *dp = *olddp;
208
209     for(i = 0; i < dp->cNamedArgs; i++) {
210         if(dp->rgdispidNamedArgs[i] == DISPID_THIS)
211             return S_OK;
212     }
213
214     oldargs = dp->rgvarg;
215     dp->rgvarg = heap_alloc((dp->cArgs+1) * sizeof(VARIANTARG));
216     if(!dp->rgvarg)
217         return E_OUTOFMEMORY;
218     memcpy(dp->rgvarg+1, oldargs, dp->cArgs*sizeof(VARIANTARG));
219     V_VT(dp->rgvarg) = VT_DISPATCH;
220     V_DISPATCH(dp->rgvarg) = jsthis;
221     dp->cArgs++;
222
223     if(dp->cNamedArgs) {
224         DISPID *old = dp->rgdispidNamedArgs;
225         dp->rgdispidNamedArgs = heap_alloc((dp->cNamedArgs+1)*sizeof(DISPID));
226         if(!dp->rgdispidNamedArgs) {
227             heap_free(dp->rgvarg);
228             return E_OUTOFMEMORY;
229         }
230
231         memcpy(dp->rgdispidNamedArgs+1, old, dp->cNamedArgs*sizeof(DISPID));
232         dp->rgdispidNamedArgs[0] = DISPID_THIS;
233         dp->cNamedArgs++;
234     }else {
235         dp->rgdispidNamedArgs = &this_id;
236         dp->cNamedArgs = 1;
237     }
238
239     return S_OK;
240 }
241
242 static HRESULT invoke_prop_func(DispatchEx *This, DispatchEx *jsthis, dispex_prop_t *prop, LCID lcid, WORD flags,
243         DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
244 {
245     HRESULT hres;
246
247     switch(prop->type) {
248     case PROP_BUILTIN:
249         if(flags == DISPATCH_CONSTRUCT && (prop->flags & DISPATCH_METHOD)) {
250             WARN("%s is not a constructor\n", debugstr_w(prop->name));
251             return E_INVALIDARG;
252         }
253         return prop->u.p->invoke(jsthis, lcid, flags, dp, retv, ei, caller);
254     case PROP_PROTREF:
255         return invoke_prop_func(This->prototype, jsthis, This->prototype->props+prop->u.ref, lcid, flags, dp, retv, ei, caller);
256     case PROP_VARIANT: {
257         DISPPARAMS new_dp;
258
259         if(V_VT(&prop->u.var) != VT_DISPATCH) {
260             FIXME("invoke vt %d\n", V_VT(&prop->u.var));
261             return E_FAIL;
262         }
263
264         TRACE("call %s %p\n", debugstr_w(prop->name), V_DISPATCH(&prop->u.var));
265
266         hres = set_this(&new_dp, dp, (IDispatch*)_IDispatchEx_(jsthis));
267         if(FAILED(hres))
268             return hres;
269
270         hres = disp_call(V_DISPATCH(&prop->u.var), DISPID_VALUE, lcid, flags, &new_dp, retv, ei, caller);
271
272         if(new_dp.rgvarg != dp->rgvarg) {
273             heap_free(new_dp.rgvarg);
274             if(new_dp.cNamedArgs > 1)
275                 heap_free(new_dp.rgdispidNamedArgs);
276         }
277
278         return hres;
279     }
280     default:
281         ERR("type %d\n", prop->type);
282     }
283
284     return E_FAIL;
285 }
286
287 static HRESULT prop_get(DispatchEx *This, dispex_prop_t *prop, LCID lcid, DISPPARAMS *dp,
288         VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
289 {
290     HRESULT hres;
291
292     switch(prop->type) {
293     case PROP_BUILTIN:
294         if(prop->u.p->flags & PROPF_METHOD) {
295             DispatchEx *obj;
296             hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->flags, NULL, &obj);
297             if(FAILED(hres))
298                 break;
299
300             prop->type = PROP_VARIANT;
301             V_VT(&prop->u.var) = VT_DISPATCH;
302             V_DISPATCH(&prop->u.var) = (IDispatch*)_IDispatchEx_(obj);
303
304             hres = VariantCopy(retv, &prop->u.var);
305         }else {
306             hres = prop->u.p->invoke(This, lcid, DISPATCH_PROPERTYGET, dp, retv, ei, caller);
307         }
308         break;
309     case PROP_PROTREF:
310         hres = prop_get(This->prototype, This->prototype->props+prop->u.ref, lcid, dp, retv, ei, caller);
311         break;
312     case PROP_VARIANT:
313         hres = VariantCopy(retv, &prop->u.var);
314         break;
315     default:
316         ERR("type %d\n", prop->type);
317         return E_FAIL;
318     }
319
320     if(FAILED(hres)) {
321         TRACE("fail %08x\n", hres);
322         return hres;
323     }
324
325     TRACE("%s ret %s\n", debugstr_w(prop->name), debugstr_variant(retv));
326     return hres;
327 }
328
329 static HRESULT prop_put(DispatchEx *This, dispex_prop_t *prop, LCID lcid, DISPPARAMS *dp,
330         jsexcept_t *ei, IServiceProvider *caller)
331 {
332     DWORD i;
333     HRESULT hres;
334
335     switch(prop->type) {
336     case PROP_BUILTIN:
337         if(!(prop->flags & PROPF_METHOD))
338             return prop->u.p->invoke(This, lcid, DISPATCH_PROPERTYPUT, dp, NULL, ei, caller);
339     case PROP_PROTREF:
340         prop->type = PROP_VARIANT;
341         prop->flags = PROPF_ENUM;
342         V_VT(&prop->u.var) = VT_EMPTY;
343         break;
344     case PROP_VARIANT:
345         VariantClear(&prop->u.var);
346         break;
347     default:
348         ERR("type %d\n", prop->type);
349         return E_FAIL;
350     }
351
352     for(i=0; i < dp->cNamedArgs; i++) {
353         if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
354             break;
355     }
356
357     if(i == dp->cNamedArgs) {
358         TRACE("no value to set\n");
359         return DISP_E_PARAMNOTOPTIONAL;
360     }
361
362     hres = VariantCopy(&prop->u.var, dp->rgvarg+i);
363     if(FAILED(hres))
364         return hres;
365
366     if(This->builtin_info->on_put)
367         This->builtin_info->on_put(This, prop->name);
368
369     TRACE("%s = %s\n", debugstr_w(prop->name), debugstr_variant(dp->rgvarg+i));
370     return S_OK;
371 }
372
373 static HRESULT fill_protrefs(DispatchEx *This)
374 {
375     dispex_prop_t *iter, *prop;
376     HRESULT hres;
377
378     if(!This->prototype)
379         return S_OK;
380
381     fill_protrefs(This->prototype);
382
383     for(iter = This->prototype->props; iter < This->prototype->props+This->prototype->prop_cnt; iter++) {
384         if(!iter->name)
385             continue;
386         hres = find_prop_name(This, iter->name, &prop);
387         if(FAILED(hres))
388             return hres;
389         if(!prop) {
390             prop = alloc_protref(This, iter->name, iter - This->prototype->props);
391             if(!prop)
392                 return E_OUTOFMEMORY;
393         }
394     }
395
396     return S_OK;
397 }
398
399 #define DISPATCHEX_THIS(iface) DEFINE_THIS(DispatchEx, IDispatchEx, iface)
400
401 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
402 {
403     DispatchEx *This = DISPATCHEX_THIS(iface);
404
405     if(IsEqualGUID(&IID_IUnknown, riid)) {
406         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
407         *ppv = _IDispatchEx_(This);
408     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
409         TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
410         *ppv = _IDispatchEx_(This);
411     }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
412         TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
413         *ppv = _IDispatchEx_(This);
414     }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
415         TRACE("(%p)->(IID_IDispatchJS %p)\n", This, ppv);
416         IUnknown_AddRef(_IDispatchEx_(This));
417         *ppv = This;
418         return S_OK;
419     }else {
420         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
421         *ppv = NULL;
422         return E_NOINTERFACE;
423     }
424
425     IUnknown_AddRef((IUnknown*)*ppv);
426     return S_OK;
427 }
428
429 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
430 {
431     DispatchEx *This = DISPATCHEX_THIS(iface);
432     LONG ref = InterlockedIncrement(&This->ref);
433
434     TRACE("(%p) ref=%d\n", This, ref);
435
436     return ref;
437 }
438
439 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
440 {
441     DispatchEx *This = DISPATCHEX_THIS(iface);
442     LONG ref = InterlockedDecrement(&This->ref);
443
444     TRACE("(%p) ref=%d\n", This, ref);
445
446     if(!ref) {
447         dispex_prop_t *prop;
448
449         for(prop = This->props; prop < This->props+This->prop_cnt; prop++) {
450             if(prop->type == PROP_VARIANT)
451                 VariantClear(&prop->u.var);
452             heap_free(prop->name);
453         }
454         heap_free(This->props);
455         script_release(This->ctx);
456
457         if(This->builtin_info->destructor)
458             This->builtin_info->destructor(This);
459         else
460             heap_free(This);
461     }
462
463     return ref;
464 }
465
466 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
467 {
468     DispatchEx *This = DISPATCHEX_THIS(iface);
469
470     TRACE("(%p)->(%p)\n", This, pctinfo);
471
472     *pctinfo = 1;
473     return S_OK;
474 }
475
476 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo,
477                                               LCID lcid, ITypeInfo **ppTInfo)
478 {
479     DispatchEx *This = DISPATCHEX_THIS(iface);
480     FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
481     return E_NOTIMPL;
482 }
483
484 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
485                                                 LPOLESTR *rgszNames, UINT cNames,
486                                                 LCID lcid, DISPID *rgDispId)
487 {
488     DispatchEx *This = DISPATCHEX_THIS(iface);
489     UINT i;
490     HRESULT hres;
491
492     TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
493           lcid, rgDispId);
494
495     for(i=0; i < cNames; i++) {
496         hres = IDispatchEx_GetDispID(_IDispatchEx_(This), rgszNames[i], 0, rgDispId+i);
497         if(FAILED(hres))
498             return hres;
499     }
500
501     return S_OK;
502 }
503
504 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
505                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
506                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
507 {
508     DispatchEx *This = DISPATCHEX_THIS(iface);
509
510     TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
511           lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
512
513     return IDispatchEx_InvokeEx(_IDispatchEx_(This), dispIdMember, lcid, wFlags,
514             pDispParams, pVarResult, pExcepInfo, NULL);
515 }
516
517 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
518 {
519     DispatchEx *This = DISPATCHEX_THIS(iface);
520
521     TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
522
523     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit)) {
524         FIXME("Unsupported grfdex %x\n", grfdex);
525         return E_NOTIMPL;
526     }
527
528     return jsdisp_get_id(This, bstrName, grfdex, pid);
529 }
530
531 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
532         VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
533 {
534     DispatchEx *This = DISPATCHEX_THIS(iface);
535     dispex_prop_t *prop;
536     jsexcept_t jsexcept;
537     HRESULT hres;
538
539     TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
540
541     if(pvarRes)
542         V_VT(pvarRes) = VT_EMPTY;
543
544     prop = get_prop(This, id);
545     if(!prop || prop->type == PROP_DELETED) {
546         TRACE("invalid id\n");
547         return DISP_E_MEMBERNOTFOUND;
548     }
549
550     memset(&jsexcept, 0, sizeof(jsexcept));
551
552     switch(wFlags) {
553     case DISPATCH_METHOD:
554     case DISPATCH_CONSTRUCT:
555         hres = invoke_prop_func(This, This, prop, lcid, wFlags, pdp, pvarRes, &jsexcept, pspCaller);
556         break;
557     case DISPATCH_PROPERTYGET:
558         hres = prop_get(This, prop, lcid, pdp, pvarRes, &jsexcept, pspCaller);
559         break;
560     case DISPATCH_PROPERTYPUT:
561         hres = prop_put(This, prop, lcid, pdp, &jsexcept, pspCaller);
562         break;
563     default:
564         FIXME("Unimplemented flags %x\n", wFlags);
565         return E_INVALIDARG;
566     }
567
568     if(pei)
569         *pei = jsexcept.ei;
570
571     return hres;
572 }
573
574 static HRESULT delete_prop(dispex_prop_t *prop)
575 {
576     heap_free(prop->name);
577     prop->name = NULL;
578     prop->type = PROP_DELETED;
579
580     return S_OK;
581 }
582
583 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
584 {
585     DispatchEx *This = DISPATCHEX_THIS(iface);
586     dispex_prop_t *prop;
587     HRESULT hres;
588
589     TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
590
591     if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit))
592         FIXME("Unsupported grfdex %x\n", grfdex);
593
594     hres = find_prop_name(This, bstrName, &prop);
595     if(FAILED(hres))
596         return hres;
597     if(!prop) {
598         TRACE("not found\n");
599         return S_OK;
600     }
601
602     return delete_prop(prop);
603 }
604
605 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
606 {
607     DispatchEx *This = DISPATCHEX_THIS(iface);
608     dispex_prop_t *prop;
609
610     TRACE("(%p)->(%x)\n", This, id);
611
612     prop = get_prop(This, id);
613     if(!prop) {
614         WARN("invalid id\n");
615         return DISP_E_MEMBERNOTFOUND;
616     }
617
618     return delete_prop(prop);
619 }
620
621 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
622 {
623     DispatchEx *This = DISPATCHEX_THIS(iface);
624     FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
625     return E_NOTIMPL;
626 }
627
628 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
629 {
630     DispatchEx *This = DISPATCHEX_THIS(iface);
631     dispex_prop_t *prop;
632
633     TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
634
635     prop = get_prop(This, id);
636     if(!prop || !prop->name || prop->type == PROP_DELETED)
637         return DISP_E_MEMBERNOTFOUND;
638
639     *pbstrName = SysAllocString(prop->name);
640     if(!*pbstrName)
641         return E_OUTOFMEMORY;
642
643     return S_OK;
644 }
645
646 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
647 {
648     DispatchEx *This = DISPATCHEX_THIS(iface);
649     dispex_prop_t *iter;
650     HRESULT hres;
651
652     TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
653
654     if(id == DISPID_STARTENUM) {
655         hres = fill_protrefs(This);
656         if(FAILED(hres))
657             return hres;
658     }
659
660     iter = get_prop(This, id+1);
661     if(!iter) {
662         *pid = DISPID_STARTENUM;
663         return S_FALSE;
664     }
665
666     while(iter < This->props + This->prop_cnt) {
667         if(iter->name && (get_flags(This, iter) & PROPF_ENUM)) {
668             *pid = prop_to_id(This, iter);
669             return S_OK;
670         }
671         iter++;
672     }
673
674     *pid = DISPID_STARTENUM;
675     return S_FALSE;
676 }
677
678 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
679 {
680     DispatchEx *This = DISPATCHEX_THIS(iface);
681     FIXME("(%p)->(%p)\n", This, ppunk);
682     return E_NOTIMPL;
683 }
684
685 #undef DISPATCHEX_THIS
686
687 static IDispatchExVtbl DispatchExVtbl = {
688     DispatchEx_QueryInterface,
689     DispatchEx_AddRef,
690     DispatchEx_Release,
691     DispatchEx_GetTypeInfoCount,
692     DispatchEx_GetTypeInfo,
693     DispatchEx_GetIDsOfNames,
694     DispatchEx_Invoke,
695     DispatchEx_GetDispID,
696     DispatchEx_InvokeEx,
697     DispatchEx_DeleteMemberByName,
698     DispatchEx_DeleteMemberByDispID,
699     DispatchEx_GetMemberProperties,
700     DispatchEx_GetMemberName,
701     DispatchEx_GetNextDispID,
702     DispatchEx_GetNameSpaceParent
703 };
704
705 HRESULT init_dispex(DispatchEx *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, DispatchEx *prototype)
706 {
707     TRACE("%p (%p)\n", dispex, prototype);
708
709     dispex->lpIDispatchExVtbl = &DispatchExVtbl;
710     dispex->ref = 1;
711     dispex->builtin_info = builtin_info;
712
713     dispex->props = heap_alloc((dispex->buf_size=4) * sizeof(dispex_prop_t));
714     if(!dispex->props)
715         return E_OUTOFMEMORY;
716
717     dispex->prototype = prototype;
718     if(prototype)
719         IDispatchEx_AddRef(_IDispatchEx_(prototype));
720
721     dispex->prop_cnt = 1;
722     dispex->props[0].name = NULL;
723     dispex->props[0].flags = 0;
724     if(builtin_info->value_prop.invoke) {
725         dispex->props[0].type = PROP_BUILTIN;
726         dispex->props[0].u.p = &builtin_info->value_prop;
727     }else {
728         dispex->props[0].type = PROP_DELETED;
729     }
730
731     script_addref(ctx);
732     dispex->ctx = ctx;
733
734     return S_OK;
735 }
736
737 static const builtin_info_t dispex_info = {
738     JSCLASS_NONE,
739     {NULL, NULL, 0},
740     0, NULL,
741     NULL,
742     NULL
743 };
744
745 HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, DispatchEx *prototype, DispatchEx **dispex)
746 {
747     DispatchEx *ret;
748     HRESULT hres;
749
750     ret = heap_alloc_zero(sizeof(DispatchEx));
751     if(!ret)
752         return E_OUTOFMEMORY;
753
754     hres = init_dispex(ret, ctx, builtin_info ? builtin_info : &dispex_info, prototype);
755     if(FAILED(hres))
756         return hres;
757
758     *dispex = ret;
759     return S_OK;
760 }
761
762 HRESULT init_dispex_from_constr(DispatchEx *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, DispatchEx *constr)
763 {
764     DispatchEx *prot = NULL;
765     dispex_prop_t *prop;
766     HRESULT hres;
767
768     static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
769
770     hres = find_prop_name_prot(constr, prototypeW, FALSE, &prop);
771     if(SUCCEEDED(hres) && prop) {
772         jsexcept_t jsexcept;
773         VARIANT var;
774
775         V_VT(&var) = VT_EMPTY;
776         memset(&jsexcept, 0, sizeof(jsexcept));
777         hres = prop_get(constr, prop, ctx->lcid, NULL, &var, &jsexcept, NULL/*FIXME*/);
778         if(FAILED(hres)) {
779             ERR("Could not get prototype\n");
780             return hres;
781         }
782
783         if(V_VT(&var) == VT_DISPATCH)
784             prot = iface_to_jsdisp((IUnknown*)V_DISPATCH(&var));
785         VariantClear(&var);
786     }
787
788     hres = init_dispex(dispex, ctx, builtin_info, prot);
789
790     if(prot)
791         IDispatchEx_Release(_IDispatchEx_(prot));
792     return hres;
793 }
794
795 DispatchEx *iface_to_jsdisp(IUnknown *iface)
796 {
797     DispatchEx *ret;
798     HRESULT hres;
799
800     hres = IUnknown_QueryInterface(iface, &IID_IDispatchJS, (void**)&ret);
801     if(FAILED(hres))
802         return NULL;
803
804     return ret;
805 }
806
807 HRESULT jsdisp_get_id(DispatchEx *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
808 {
809     dispex_prop_t *prop;
810     HRESULT hres;
811
812     hres = find_prop_name_prot(jsdisp, name, (flags&fdexNameEnsure) != 0, &prop);
813     if(FAILED(hres))
814         return hres;
815
816     if(prop) {
817         *id = prop_to_id(jsdisp, prop);
818         return S_OK;
819     }
820
821     TRACE("not found %s\n", debugstr_w(name));
822     return DISP_E_UNKNOWNNAME;
823 }
824
825 HRESULT jsdisp_call_value(DispatchEx *disp, LCID lcid, WORD flags, DISPPARAMS *dp, VARIANT *retv,
826         jsexcept_t *ei, IServiceProvider *caller)
827 {
828     return disp->builtin_info->value_prop.invoke(disp, lcid, flags, dp, retv, ei, caller);
829 }
830
831 HRESULT jsdisp_call(DispatchEx *disp, DISPID id, LCID lcid, WORD flags, DISPPARAMS *dp, VARIANT *retv,
832         jsexcept_t *ei, IServiceProvider *caller)
833 {
834     dispex_prop_t *prop;
835
836     memset(ei, 0, sizeof(*ei));
837     if(retv)
838         V_VT(retv) = VT_EMPTY;
839
840     prop = get_prop(disp, id);
841     if(!prop)
842         return DISP_E_MEMBERNOTFOUND;
843
844     return invoke_prop_func(disp, disp, prop, lcid, flags, dp, retv, ei, caller);
845 }
846
847 HRESULT disp_call(IDispatch *disp, DISPID id, LCID lcid, WORD flags, DISPPARAMS *dp, VARIANT *retv,
848         jsexcept_t *ei, IServiceProvider *caller)
849 {
850     DispatchEx *jsdisp;
851     IDispatchEx *dispex;
852     HRESULT hres;
853
854     jsdisp = iface_to_jsdisp((IUnknown*)disp);
855     if(jsdisp) {
856         hres = jsdisp_call(jsdisp, id, lcid, flags, dp, retv, ei, caller);
857         IDispatchEx_Release(_IDispatchEx_(jsdisp));
858         return hres;
859     }
860
861     memset(ei, 0, sizeof(*ei));
862
863     if(retv)
864         V_VT(retv) = VT_EMPTY;
865     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
866     if(FAILED(hres)) {
867         UINT err = 0;
868
869         if(flags == DISPATCH_CONSTRUCT) {
870             WARN("IDispatch cannot be constructor\n");
871             return DISP_E_MEMBERNOTFOUND;
872         }
873
874         TRACE("using IDispatch\n");
875         return IDispatch_Invoke(disp, id, &IID_NULL, lcid, flags, dp, retv, &ei->ei, &err);
876     }
877
878     hres = IDispatchEx_InvokeEx(dispex, id, lcid, flags, dp, retv, &ei->ei, caller);
879     IDispatchEx_Release(dispex);
880
881     return hres;
882 }
883
884 HRESULT jsdisp_propput_name(DispatchEx *obj, const WCHAR *name, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
885 {
886     DISPID named_arg = DISPID_PROPERTYPUT;
887     DISPPARAMS dp = {val, &named_arg, 1, 1};
888     dispex_prop_t *prop;
889     HRESULT hres;
890
891     hres = find_prop_name_prot(obj, name, TRUE, &prop);
892     if(FAILED(hres))
893         return hres;
894
895     return prop_put(obj, prop, lcid, &dp, ei, caller);
896 }
897
898 HRESULT jsdisp_propput_idx(DispatchEx *obj, DWORD idx, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
899 {
900     WCHAR buf[12];
901
902     static const WCHAR formatW[] = {'%','d',0};
903
904     sprintfW(buf, formatW, idx);
905     return jsdisp_propput_name(obj, buf, lcid, val, ei, caller);
906 }
907
908 HRESULT disp_propput(IDispatch *disp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
909 {
910     DISPID dispid = DISPID_PROPERTYPUT;
911     DISPPARAMS dp  = {val, &dispid, 1, 1};
912     IDispatchEx *dispex;
913     DispatchEx *jsdisp;
914     HRESULT hres;
915
916     jsdisp = iface_to_jsdisp((IUnknown*)disp);
917     if(jsdisp) {
918         dispex_prop_t *prop;
919
920         prop = get_prop(jsdisp, id);
921         if(prop)
922             hres = prop_put(jsdisp, prop, lcid, &dp, ei, caller);
923         else
924             hres = DISP_E_MEMBERNOTFOUND;
925
926         IDispatchEx_Release(_IDispatchEx_(jsdisp));
927         return hres;
928     }
929
930     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
931     if(FAILED(hres)) {
932         ULONG err = 0;
933
934         TRACE("using IDispatch\n");
935         return IDispatch_Invoke(disp, id, &IID_NULL, DISPATCH_PROPERTYPUT, lcid, &dp, NULL, &ei->ei, &err);
936     }
937
938     hres = IDispatchEx_InvokeEx(dispex, id, lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei, caller);
939
940     IDispatchEx_Release(dispex);
941     return hres;
942 }
943
944 static HRESULT jsdisp_propget_name(DispatchEx *obj, const WCHAR *name, LCID lcid, VARIANT *var,
945         jsexcept_t *ei, IServiceProvider *caller)
946 {
947     DISPPARAMS dp = {NULL, NULL, 0, 0};
948     dispex_prop_t *prop;
949     HRESULT hres;
950
951     hres = find_prop_name_prot(obj, name, FALSE, &prop);
952     if(FAILED(hres))
953         return hres;
954
955     V_VT(var) = VT_EMPTY;
956     if(!prop)
957         return S_OK;
958
959     return prop_get(obj, prop, lcid, &dp, var, ei, caller);
960 }
961
962 HRESULT jsdisp_propget_idx(DispatchEx *obj, DWORD idx, LCID lcid, VARIANT *var, jsexcept_t *ei, IServiceProvider *caller)
963 {
964     WCHAR buf[12];
965
966     static const WCHAR formatW[] = {'%','d',0};
967
968     sprintfW(buf, formatW, idx);
969     return jsdisp_propget_name(obj, buf, lcid, var, ei, caller);
970 }
971
972 HRESULT jsdisp_propget(DispatchEx *jsdisp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei,
973         IServiceProvider *caller)
974 {
975     DISPPARAMS dp  = {NULL,NULL,0,0};
976     dispex_prop_t *prop;
977
978     prop = get_prop(jsdisp, id);
979     if(!prop)
980         return DISP_E_MEMBERNOTFOUND;
981
982     V_VT(val) = VT_EMPTY;
983     return prop_get(jsdisp, prop, lcid, &dp, val, ei, caller);
984 }
985
986 HRESULT disp_propget(IDispatch *disp, DISPID id, LCID lcid, VARIANT *val, jsexcept_t *ei, IServiceProvider *caller)
987 {
988     DISPPARAMS dp  = {NULL,NULL,0,0};
989     IDispatchEx *dispex;
990     DispatchEx *jsdisp;
991     HRESULT hres;
992
993     jsdisp = iface_to_jsdisp((IUnknown*)disp);
994     if(jsdisp) {
995         hres = jsdisp_propget(jsdisp, id, lcid, val, ei, caller);
996         IDispatchEx_Release(_IDispatchEx_(jsdisp));
997         return hres;
998     }
999
1000     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1001     if(FAILED(hres)) {
1002         ULONG err = 0;
1003
1004         TRACE("using IDispatch\n");
1005         return IDispatch_Invoke(disp, id, &IID_NULL, lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, &err);
1006     }
1007
1008     hres = IDispatchEx_InvokeEx(dispex, id, lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, caller);
1009     IDispatchEx_Release(dispex);
1010
1011     return hres;
1012 }