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 <assert.h>
20
21 #include "jscript.h"
22
23 #include "wine/unicode.h"
24 #include "wine/debug.h"
25
26 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
27
28 /*
29 * This IID is used to get jsdisp_t objecto from interface.
30 * We might consider using private interface instead.
31 */
32 static const IID IID_IDispatchJS =
33 {0x719c3050,0xf9d3,0x11cf,{0xa4,0x93,0x00,0x40,0x05,0x23,0xa8,0xa6}};
34
35 #define FDEX_VERSION_MASK 0xf0000000
36 #define GOLDEN_RATIO 0x9E3779B9U
37
38 typedef enum {
39 PROP_VARIANT,
40 PROP_BUILTIN,
41 PROP_PROTREF,
42 PROP_DELETED
43 } prop_type_t;
44
45 struct _dispex_prop_t {
46 WCHAR *name;
47 unsigned hash;
48 prop_type_t type;
49 DWORD flags;
50
51 union {
52 VARIANT var;
53 const builtin_prop_t *p;
54 DWORD ref;
55 } u;
56
57 int bucket_head;
58 int bucket_next;
59 };
60
61 static inline DISPID prop_to_id(jsdisp_t *This, dispex_prop_t *prop)
62 {
63 return prop - This->props;
64 }
65
66 static inline dispex_prop_t *get_prop(jsdisp_t *This, DISPID id)
67 {
68 if(id < 0 || id >= This->prop_cnt || This->props[id].type == PROP_DELETED)
69 return NULL;
70
71 return This->props+id;
72 }
73
74 static DWORD get_flags(jsdisp_t *This, dispex_prop_t *prop)
75 {
76 if(prop->type == PROP_PROTREF) {
77 dispex_prop_t *parent = get_prop(This->prototype, prop->u.ref);
78 if(!parent) {
79 prop->type = PROP_DELETED;
80 return 0;
81 }
82
83 return get_flags(This->prototype, parent);
84 }
85
86 return prop->flags;
87 }
88
89 static const builtin_prop_t *find_builtin_prop(jsdisp_t *This, const WCHAR *name)
90 {
91 int min = 0, max, i, r;
92
93 max = This->builtin_info->props_cnt-1;
94 while(min <= max) {
95 i = (min+max)/2;
96
97 r = strcmpW(name, This->builtin_info->props[i].name);
98 if(!r)
99 return This->builtin_info->props + i;
100
101 if(r < 0)
102 max = i-1;
103 else
104 min = i+1;
105 }
106
107 return NULL;
108 }
109
110 static inline unsigned string_hash(const WCHAR *name)
111 {
112 unsigned h = 0;
113 for(; *name; name++)
114 h = (h>>(sizeof(unsigned)*8-4)) ^ (h<<4) ^ tolowerW(*name);
115 return h;
116 }
117
118 static inline unsigned get_props_idx(jsdisp_t *This, unsigned hash)
119 {
120 return (hash*GOLDEN_RATIO) & (This->buf_size-1);
121 }
122
123 static inline HRESULT resize_props(jsdisp_t *This)
124 {
125 dispex_prop_t *props;
126 int i, bucket;
127
128 if(This->buf_size != This->prop_cnt)
129 return S_FALSE;
130
131 props = heap_realloc(This->props, sizeof(dispex_prop_t)*This->buf_size*2);
132 if(!props)
133 return E_OUTOFMEMORY;
134 This->buf_size *= 2;
135 This->props = props;
136
137 for(i=0; i<This->buf_size; i++) {
138 This->props[i].bucket_head = 0;
139 This->props[i].bucket_next = 0;
140 }
141
142 for(i=1; i<This->prop_cnt; i++) {
143 props = This->props+i;
144
145 bucket = get_props_idx(This, props->hash);
146 props->bucket_next = This->props[bucket].bucket_head;
147 This->props[bucket].bucket_head = i;
148 }
149
150 return S_OK;
151 }
152
153 static inline dispex_prop_t* alloc_prop(jsdisp_t *This, const WCHAR *name, prop_type_t type, DWORD flags)
154 {
155 dispex_prop_t *prop;
156 unsigned bucket;
157
158 if(FAILED(resize_props(This)))
159 return NULL;
160
161 prop = &This->props[This->prop_cnt];
162 prop->name = heap_strdupW(name);
163 if(!prop->name)
164 return NULL;
165 prop->type = type;
166 prop->flags = flags;
167 prop->hash = string_hash(name);
168
169 bucket = get_props_idx(This, prop->hash);
170 prop->bucket_next = This->props[bucket].bucket_head;
171 This->props[bucket].bucket_head = This->prop_cnt++;
172 return prop;
173 }
174
175 static dispex_prop_t *alloc_protref(jsdisp_t *This, const WCHAR *name, DWORD ref)
176 {
177 dispex_prop_t *ret;
178
179 ret = alloc_prop(This, name, PROP_PROTREF, 0);
180 if(!ret)
181 return NULL;
182
183 ret->u.ref = ref;
184 return ret;
185 }
186
187 static HRESULT find_prop_name(jsdisp_t *This, unsigned hash, const WCHAR *name, dispex_prop_t **ret)
188 {
189 const builtin_prop_t *builtin;
190 unsigned bucket, pos, prev = 0;
191 dispex_prop_t *prop;
192
193 bucket = get_props_idx(This, hash);
194 pos = This->props[bucket].bucket_head;
195 while(pos != 0) {
196 if(!strcmpW(name, This->props[pos].name)) {
197 if(prev != 0) {
198 This->props[prev].bucket_next = This->props[pos].bucket_next;
199 This->props[pos].bucket_next = This->props[bucket].bucket_head;
200 This->props[bucket].bucket_head = pos;
201 }
202
203 *ret = &This->props[pos];
204 return S_OK;
205 }
206
207 prev = pos;
208 pos = This->props[pos].bucket_next;
209 }
210
211 builtin = find_builtin_prop(This, name);
212 if(builtin) {
213 prop = alloc_prop(This, name, PROP_BUILTIN, builtin->flags);
214 if(!prop)
215 return E_OUTOFMEMORY;
216
217 prop->u.p = builtin;
218 *ret = prop;
219 return S_OK;
220 }
221
222 *ret = NULL;
223 return S_OK;
224 }
225
226 static HRESULT find_prop_name_prot(jsdisp_t *This, unsigned hash, const WCHAR *name, dispex_prop_t **ret)
227 {
228 dispex_prop_t *prop, *del=NULL;
229 HRESULT hres;
230
231 hres = find_prop_name(This, hash, name, &prop);
232 if(FAILED(hres))
233 return hres;
234 if(prop && prop->type==PROP_DELETED) {
235 del = prop;
236 } else if(prop) {
237 *ret = prop;
238 return S_OK;
239 }
240
241 if(This->prototype) {
242 hres = find_prop_name_prot(This->prototype, hash, name, &prop);
243 if(FAILED(hres))
244 return hres;
245 if(prop) {
246 if(del) {
247 del->type = PROP_PROTREF;
248 del->flags = 0;
249 del->u.ref = prop - This->prototype->props;
250 prop = del;
251 }else {
252 prop = alloc_protref(This, prop->name, prop - This->prototype->props);
253 if(!prop)
254 return E_OUTOFMEMORY;
255 }
256
257 *ret = prop;
258 return S_OK;
259 }
260 }
261
262 *ret = del;
263 return S_OK;
264 }
265
266 static HRESULT ensure_prop_name(jsdisp_t *This, const WCHAR *name, BOOL search_prot, DWORD create_flags, dispex_prop_t **ret)
267 {
268 dispex_prop_t *prop;
269 HRESULT hres;
270
271 if(search_prot)
272 hres = find_prop_name_prot(This, string_hash(name), name, &prop);
273 else
274 hres = find_prop_name(This, string_hash(name), name, &prop);
275 if(SUCCEEDED(hres) && (!prop || prop->type==PROP_DELETED)) {
276 TRACE("creating prop %s\n", debugstr_w(name));
277
278 if(prop) {
279 prop->type = PROP_VARIANT;
280 prop->flags = create_flags;
281 }else {
282 prop = alloc_prop(This, name, PROP_VARIANT, create_flags);
283 if(!prop)
284 return E_OUTOFMEMORY;
285 }
286
287 VariantInit(&prop->u.var);
288 }
289
290 *ret = prop;
291 return hres;
292 }
293
294 static HRESULT set_this(DISPPARAMS *dp, DISPPARAMS *olddp, IDispatch *jsthis)
295 {
296 VARIANTARG *oldargs;
297 int i;
298
299 static DISPID this_id = DISPID_THIS;
300
301 *dp = *olddp;
302
303 for(i = 0; i < dp->cNamedArgs; i++) {
304 if(dp->rgdispidNamedArgs[i] == DISPID_THIS)
305 return S_OK;
306 }
307
308 oldargs = dp->rgvarg;
309 dp->rgvarg = heap_alloc((dp->cArgs+1) * sizeof(VARIANTARG));
310 if(!dp->rgvarg)
311 return E_OUTOFMEMORY;
312 memcpy(dp->rgvarg+1, oldargs, dp->cArgs*sizeof(VARIANTARG));
313 V_VT(dp->rgvarg) = VT_DISPATCH;
314 V_DISPATCH(dp->rgvarg) = jsthis;
315 dp->cArgs++;
316
317 if(dp->cNamedArgs) {
318 DISPID *old = dp->rgdispidNamedArgs;
319 dp->rgdispidNamedArgs = heap_alloc((dp->cNamedArgs+1)*sizeof(DISPID));
320 if(!dp->rgdispidNamedArgs) {
321 heap_free(dp->rgvarg);
322 return E_OUTOFMEMORY;
323 }
324
325 memcpy(dp->rgdispidNamedArgs+1, old, dp->cNamedArgs*sizeof(DISPID));
326 dp->rgdispidNamedArgs[0] = DISPID_THIS;
327 dp->cNamedArgs++;
328 }else {
329 dp->rgdispidNamedArgs = &this_id;
330 dp->cNamedArgs = 1;
331 }
332
333 return S_OK;
334 }
335
336 static HRESULT convert_params(const DISPPARAMS *dp, VARIANT *buf, DISPPARAMS *ret)
337 {
338 BOOL need_conversion = FALSE;
339 const VARIANT *s;
340 VARIANT *d;
341 unsigned i;
342
343 *ret = *dp;
344
345 for(i = 0; i < ret->cArgs && !need_conversion; i++) {
346 switch(V_VT(get_arg(dp, i))) {
347 case VT_I2:
348 case VT_INT:
349 need_conversion = TRUE;
350 break;
351 }
352 }
353
354 if(!need_conversion)
355 return S_OK;
356
357 if(ret->cArgs > 6) {
358 ret->rgvarg = heap_alloc(ret->cArgs * sizeof(VARIANT));
359 if(!ret->rgvarg)
360 return E_OUTOFMEMORY;
361 }else {
362 ret->rgvarg = buf;
363 }
364
365 for(i = 0; i < ret->cArgs; i++) {
366 s = get_arg(dp, i);
367 d = get_arg(ret, i);
368 switch(V_VT(s)) {
369 case VT_I2:
370 V_VT(d) = VT_I4;
371 V_I4(d) = V_I2(s);
372 break;
373 case VT_INT:
374 V_VT(d) = VT_I4;
375 V_I4(d) = V_INT(s);
376 break;
377 default:
378 *d = *s;
379 }
380 }
381
382 return S_OK;
383 }
384
385 static HRESULT invoke_prop_func(jsdisp_t *This, jsdisp_t *jsthis, dispex_prop_t *prop, WORD flags,
386 DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
387 {
388 HRESULT hres;
389
390 switch(prop->type) {
391 case PROP_BUILTIN: {
392 DISPPARAMS params;
393 VARIANT buf[6];
394 vdisp_t vthis;
395
396 if(flags == DISPATCH_CONSTRUCT && (prop->flags & PROPF_METHOD)) {
397 WARN("%s is not a constructor\n", debugstr_w(prop->name));
398 return E_INVALIDARG;
399 }
400
401 hres = convert_params(dp, buf, ¶ms);
402 if(FAILED(hres))
403 return hres;
404
405 set_jsdisp(&vthis, jsthis);
406 hres = prop->u.p->invoke(This->ctx, &vthis, flags, ¶ms, retv, ei);
407 vdisp_release(&vthis);
408 if(params.rgvarg != buf && params.rgvarg != dp->rgvarg)
409 heap_free(params.rgvarg);
410 return hres;
411 }
412 case PROP_PROTREF:
413 return invoke_prop_func(This->prototype, jsthis, This->prototype->props+prop->u.ref, flags, dp, retv, ei, caller);
414 case PROP_VARIANT: {
415 DISPPARAMS new_dp;
416
417 if(V_VT(&prop->u.var) != VT_DISPATCH) {
418 FIXME("invoke vt %d\n", V_VT(&prop->u.var));
419 return E_FAIL;
420 }
421
422 TRACE("call %s %p\n", debugstr_w(prop->name), V_DISPATCH(&prop->u.var));
423
424 hres = set_this(&new_dp, dp, to_disp(jsthis));
425 if(FAILED(hres))
426 return hres;
427
428 hres = disp_call(This->ctx, V_DISPATCH(&prop->u.var), DISPID_VALUE, flags, &new_dp, retv, ei);
429
430 if(new_dp.rgvarg != dp->rgvarg) {
431 heap_free(new_dp.rgvarg);
432 if(new_dp.cNamedArgs > 1)
433 heap_free(new_dp.rgdispidNamedArgs);
434 }
435
436 return hres;
437 }
438 default:
439 ERR("type %d\n", prop->type);
440 }
441
442 return E_FAIL;
443 }
444
445 static HRESULT prop_get(jsdisp_t *This, dispex_prop_t *prop, DISPPARAMS *dp,
446 VARIANT *retv, jsexcept_t *ei, IServiceProvider *caller)
447 {
448 HRESULT hres;
449
450 switch(prop->type) {
451 case PROP_BUILTIN:
452 if(prop->u.p->flags & PROPF_METHOD) {
453 jsdisp_t *obj;
454 hres = create_builtin_function(This->ctx, prop->u.p->invoke, prop->u.p->name, NULL,
455 prop->u.p->flags, NULL, &obj);
456 if(FAILED(hres))
457 break;
458
459 prop->type = PROP_VARIANT;
460 var_set_jsdisp(&prop->u.var, obj);
461 hres = VariantCopy(retv, &prop->u.var);
462 }else {
463 vdisp_t vthis;
464
465 set_jsdisp(&vthis, This);
466 hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYGET, dp, retv, ei);
467 vdisp_release(&vthis);
468 }
469 break;
470 case PROP_PROTREF:
471 hres = prop_get(This->prototype, This->prototype->props+prop->u.ref, dp, retv, ei, caller);
472 break;
473 case PROP_VARIANT:
474 hres = VariantCopy(retv, &prop->u.var);
475 break;
476 default:
477 ERR("type %d\n", prop->type);
478 return E_FAIL;
479 }
480
481 if(FAILED(hres)) {
482 TRACE("fail %08x\n", hres);
483 return hres;
484 }
485
486 TRACE("%s ret %s\n", debugstr_w(prop->name), debugstr_variant(retv));
487 return hres;
488 }
489
490 static HRESULT prop_put(jsdisp_t *This, dispex_prop_t *prop, VARIANT *val,
491 jsexcept_t *ei, IServiceProvider *caller)
492 {
493 HRESULT hres;
494
495 if(prop->flags & PROPF_CONST)
496 return S_OK;
497
498 switch(prop->type) {
499 case PROP_BUILTIN:
500 if(!(prop->flags & PROPF_METHOD)) {
501 DISPPARAMS dp = {val, NULL, 1, 0};
502 vdisp_t vthis;
503
504 set_jsdisp(&vthis, This);
505 hres = prop->u.p->invoke(This->ctx, &vthis, DISPATCH_PROPERTYPUT, &dp, NULL, ei);
506 vdisp_release(&vthis);
507 return hres;
508 }
509 case PROP_PROTREF:
510 prop->type = PROP_VARIANT;
511 prop->flags = PROPF_ENUM;
512 V_VT(&prop->u.var) = VT_EMPTY;
513 break;
514 case PROP_VARIANT:
515 VariantClear(&prop->u.var);
516 break;
517 default:
518 ERR("type %d\n", prop->type);
519 return E_FAIL;
520 }
521
522 hres = VariantCopy(&prop->u.var, val);
523 if(FAILED(hres))
524 return hres;
525
526 if(This->builtin_info->on_put)
527 This->builtin_info->on_put(This, prop->name);
528
529 TRACE("%s = %s\n", debugstr_w(prop->name), debugstr_variant(val));
530 return S_OK;
531 }
532
533 static HRESULT fill_protrefs(jsdisp_t *This)
534 {
535 dispex_prop_t *iter, *prop;
536 HRESULT hres;
537
538 if(!This->prototype)
539 return S_OK;
540
541 fill_protrefs(This->prototype);
542
543 for(iter = This->prototype->props; iter < This->prototype->props+This->prototype->prop_cnt; iter++) {
544 if(!iter->name)
545 continue;
546 hres = find_prop_name(This, iter->hash, iter->name, &prop);
547 if(FAILED(hres))
548 return hres;
549 if(!prop || prop->type==PROP_DELETED) {
550 if(prop) {
551 prop->type = PROP_PROTREF;
552 prop->flags = 0;
553 prop->u.ref = iter - This->prototype->props;
554 }else {
555 prop = alloc_protref(This, iter->name, iter - This->prototype->props);
556 if(!prop)
557 return E_OUTOFMEMORY;
558 }
559 }
560 }
561
562 return S_OK;
563 }
564
565 static inline jsdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
566 {
567 return CONTAINING_RECORD(iface, jsdisp_t, IDispatchEx_iface);
568 }
569
570 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
571 {
572 jsdisp_t *This = impl_from_IDispatchEx(iface);
573
574 if(IsEqualGUID(&IID_IUnknown, riid)) {
575 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
576 *ppv = &This->IDispatchEx_iface;
577 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
578 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
579 *ppv = &This->IDispatchEx_iface;
580 }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
581 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
582 *ppv = &This->IDispatchEx_iface;
583 }else if(IsEqualGUID(&IID_IDispatchJS, riid)) {
584 TRACE("(%p)->(IID_IDispatchJS %p)\n", This, ppv);
585 jsdisp_addref(This);
586 *ppv = This;
587 return S_OK;
588 }else {
589 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
590 *ppv = NULL;
591 return E_NOINTERFACE;
592 }
593
594 IUnknown_AddRef((IUnknown*)*ppv);
595 return S_OK;
596 }
597
598 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
599 {
600 jsdisp_t *This = impl_from_IDispatchEx(iface);
601 LONG ref = InterlockedIncrement(&This->ref);
602
603 TRACE("(%p) ref=%d\n", This, ref);
604
605 return ref;
606 }
607
608 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
609 {
610 jsdisp_t *This = impl_from_IDispatchEx(iface);
611 LONG ref = InterlockedDecrement(&This->ref);
612
613 TRACE("(%p) ref=%d\n", This, ref);
614
615 if(!ref) {
616 dispex_prop_t *prop;
617
618 for(prop = This->props; prop < This->props+This->prop_cnt; prop++) {
619 if(prop->type == PROP_VARIANT)
620 VariantClear(&prop->u.var);
621 heap_free(prop->name);
622 }
623 heap_free(This->props);
624 script_release(This->ctx);
625 if(This->prototype)
626 jsdisp_release(This->prototype);
627
628 if(This->builtin_info->destructor)
629 This->builtin_info->destructor(This);
630 else
631 heap_free(This);
632 }
633
634 return ref;
635 }
636
637 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
638 {
639 jsdisp_t *This = impl_from_IDispatchEx(iface);
640
641 TRACE("(%p)->(%p)\n", This, pctinfo);
642
643 *pctinfo = 1;
644 return S_OK;
645 }
646
647 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
648 ITypeInfo **ppTInfo)
649 {
650 jsdisp_t *This = impl_from_IDispatchEx(iface);
651 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
652 return E_NOTIMPL;
653 }
654
655 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
656 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
657 DISPID *rgDispId)
658 {
659 jsdisp_t *This = impl_from_IDispatchEx(iface);
660 UINT i;
661 HRESULT hres;
662
663 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
664 lcid, rgDispId);
665
666 for(i=0; i < cNames; i++) {
667 hres = IDispatchEx_GetDispID(&This->IDispatchEx_iface, rgszNames[i], 0, rgDispId+i);
668 if(FAILED(hres))
669 return hres;
670 }
671
672 return S_OK;
673 }
674
675 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
676 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
677 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
678 {
679 jsdisp_t *This = impl_from_IDispatchEx(iface);
680
681 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
682 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
683
684 return IDispatchEx_InvokeEx(&This->IDispatchEx_iface, dispIdMember, lcid, wFlags,
685 pDispParams, pVarResult, pExcepInfo, NULL);
686 }
687
688 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
689 {
690 jsdisp_t *This = impl_from_IDispatchEx(iface);
691
692 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
693
694 if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK)) {
695 FIXME("Unsupported grfdex %x\n", grfdex);
696 return E_NOTIMPL;
697 }
698
699 return jsdisp_get_id(This, bstrName, grfdex, pid);
700 }
701
702 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
703 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
704 {
705 jsdisp_t *This = impl_from_IDispatchEx(iface);
706 dispex_prop_t *prop;
707 jsexcept_t jsexcept;
708 HRESULT hres;
709
710 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
711
712 if(pvarRes)
713 V_VT(pvarRes) = VT_EMPTY;
714
715 prop = get_prop(This, id);
716 if(!prop || prop->type == PROP_DELETED) {
717 TRACE("invalid id\n");
718 return DISP_E_MEMBERNOTFOUND;
719 }
720
721 memset(&jsexcept, 0, sizeof(jsexcept));
722
723 switch(wFlags) {
724 case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
725 wFlags = DISPATCH_METHOD;
726 /* fall through */
727 case DISPATCH_METHOD:
728 case DISPATCH_CONSTRUCT:
729 hres = invoke_prop_func(This, This, prop, wFlags, pdp, pvarRes, &jsexcept, pspCaller);
730 break;
731 case DISPATCH_PROPERTYGET:
732 hres = prop_get(This, prop, pdp, pvarRes, &jsexcept, pspCaller);
733 break;
734 case DISPATCH_PROPERTYPUT: {
735 DWORD i;
736
737 for(i=0; i < pdp->cNamedArgs; i++) {
738 if(pdp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
739 break;
740 }
741
742 if(i == pdp->cNamedArgs) {
743 TRACE("no value to set\n");
744 return DISP_E_PARAMNOTOPTIONAL;
745 }
746
747 hres = prop_put(This, prop, pdp->rgvarg+i, &jsexcept, pspCaller);
748 break;
749 }
750 default:
751 FIXME("Unimplemented flags %x\n", wFlags);
752 return E_INVALIDARG;
753 }
754
755 if(pei)
756 *pei = jsexcept.ei;
757
758 return hres;
759 }
760
761 static HRESULT delete_prop(dispex_prop_t *prop)
762 {
763 if(prop->type == PROP_VARIANT) {
764 VariantClear(&prop->u.var);
765 prop->type = PROP_DELETED;
766 }
767 return S_OK;
768 }
769
770 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
771 {
772 jsdisp_t *This = impl_from_IDispatchEx(iface);
773 dispex_prop_t *prop;
774 HRESULT hres;
775
776 TRACE("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
777
778 if(grfdex & ~(fdexNameCaseSensitive|fdexNameEnsure|fdexNameImplicit|FDEX_VERSION_MASK))
779 FIXME("Unsupported grfdex %x\n", grfdex);
780
781 hres = find_prop_name(This, string_hash(bstrName), bstrName, &prop);
782 if(FAILED(hres))
783 return hres;
784 if(!prop) {
785 TRACE("not found\n");
786 return S_OK;
787 }
788
789 return delete_prop(prop);
790 }
791
792 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
793 {
794 jsdisp_t *This = impl_from_IDispatchEx(iface);
795 dispex_prop_t *prop;
796
797 TRACE("(%p)->(%x)\n", This, id);
798
799 prop = get_prop(This, id);
800 if(!prop) {
801 WARN("invalid id\n");
802 return DISP_E_MEMBERNOTFOUND;
803 }
804
805 return delete_prop(prop);
806 }
807
808 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
809 {
810 jsdisp_t *This = impl_from_IDispatchEx(iface);
811 FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
812 return E_NOTIMPL;
813 }
814
815 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
816 {
817 jsdisp_t *This = impl_from_IDispatchEx(iface);
818 dispex_prop_t *prop;
819
820 TRACE("(%p)->(%x %p)\n", This, id, pbstrName);
821
822 prop = get_prop(This, id);
823 if(!prop || !prop->name || prop->type == PROP_DELETED)
824 return DISP_E_MEMBERNOTFOUND;
825
826 *pbstrName = SysAllocString(prop->name);
827 if(!*pbstrName)
828 return E_OUTOFMEMORY;
829
830 return S_OK;
831 }
832
833 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
834 {
835 jsdisp_t *This = impl_from_IDispatchEx(iface);
836 dispex_prop_t *iter;
837 HRESULT hres;
838
839 TRACE("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
840
841 if(id == DISPID_STARTENUM) {
842 hres = fill_protrefs(This);
843 if(FAILED(hres))
844 return hres;
845 }
846
847 if(id+1>=0 && id+1<This->prop_cnt) {
848 iter = &This->props[id+1];
849 }else {
850 *pid = DISPID_STARTENUM;
851 return S_FALSE;
852 }
853
854 while(iter < This->props + This->prop_cnt) {
855 if(iter->name && (get_flags(This, iter) & PROPF_ENUM) && iter->type!=PROP_DELETED) {
856 *pid = prop_to_id(This, iter);
857 return S_OK;
858 }
859 iter++;
860 }
861
862 *pid = DISPID_STARTENUM;
863 return S_FALSE;
864 }
865
866 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
867 {
868 jsdisp_t *This = impl_from_IDispatchEx(iface);
869 FIXME("(%p)->(%p)\n", This, ppunk);
870 return E_NOTIMPL;
871 }
872
873 static IDispatchExVtbl DispatchExVtbl = {
874 DispatchEx_QueryInterface,
875 DispatchEx_AddRef,
876 DispatchEx_Release,
877 DispatchEx_GetTypeInfoCount,
878 DispatchEx_GetTypeInfo,
879 DispatchEx_GetIDsOfNames,
880 DispatchEx_Invoke,
881 DispatchEx_GetDispID,
882 DispatchEx_InvokeEx,
883 DispatchEx_DeleteMemberByName,
884 DispatchEx_DeleteMemberByDispID,
885 DispatchEx_GetMemberProperties,
886 DispatchEx_GetMemberName,
887 DispatchEx_GetNextDispID,
888 DispatchEx_GetNameSpaceParent
889 };
890
891 jsdisp_t *as_jsdisp(IDispatch *disp)
892 {
893 assert(disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl);
894 return impl_from_IDispatchEx((IDispatchEx*)disp);
895 }
896
897 jsdisp_t *to_jsdisp(IDispatch *disp)
898 {
899 return disp->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl ? impl_from_IDispatchEx((IDispatchEx*)disp) : NULL;
900 }
901
902 HRESULT init_dispex(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype)
903 {
904 TRACE("%p (%p)\n", dispex, prototype);
905
906 dispex->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
907 dispex->ref = 1;
908 dispex->builtin_info = builtin_info;
909
910 dispex->props = heap_alloc_zero(sizeof(dispex_prop_t)*(dispex->buf_size=4));
911 if(!dispex->props)
912 return E_OUTOFMEMORY;
913
914 dispex->prototype = prototype;
915 if(prototype)
916 jsdisp_addref(prototype);
917
918 dispex->prop_cnt = 1;
919 if(builtin_info->value_prop.invoke) {
920 dispex->props[0].type = PROP_BUILTIN;
921 dispex->props[0].u.p = &builtin_info->value_prop;
922 }else {
923 dispex->props[0].type = PROP_DELETED;
924 }
925
926 script_addref(ctx);
927 dispex->ctx = ctx;
928
929 return S_OK;
930 }
931
932 static const builtin_info_t dispex_info = {
933 JSCLASS_NONE,
934 {NULL, NULL, 0},
935 0, NULL,
936 NULL,
937 NULL
938 };
939
940 HRESULT create_dispex(script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *prototype, jsdisp_t **dispex)
941 {
942 jsdisp_t *ret;
943 HRESULT hres;
944
945 ret = heap_alloc_zero(sizeof(jsdisp_t));
946 if(!ret)
947 return E_OUTOFMEMORY;
948
949 hres = init_dispex(ret, ctx, builtin_info ? builtin_info : &dispex_info, prototype);
950 if(FAILED(hres))
951 return hres;
952
953 *dispex = ret;
954 return S_OK;
955 }
956
957 HRESULT init_dispex_from_constr(jsdisp_t *dispex, script_ctx_t *ctx, const builtin_info_t *builtin_info, jsdisp_t *constr)
958 {
959 jsdisp_t *prot = NULL;
960 dispex_prop_t *prop;
961 HRESULT hres;
962
963 static const WCHAR constructorW[] = {'c','o','n','s','t','r','u','c','t','o','r',0};
964 static const WCHAR prototypeW[] = {'p','r','o','t','o','t','y','p','e',0};
965
966 hres = find_prop_name_prot(constr, string_hash(prototypeW), prototypeW, &prop);
967 if(SUCCEEDED(hres) && prop && prop->type!=PROP_DELETED) {
968 jsexcept_t jsexcept;
969 VARIANT var;
970
971 V_VT(&var) = VT_EMPTY;
972 memset(&jsexcept, 0, sizeof(jsexcept));
973 hres = prop_get(constr, prop, NULL, &var, &jsexcept, NULL/*FIXME*/);
974 if(FAILED(hres)) {
975 ERR("Could not get prototype\n");
976 return hres;
977 }
978
979 if(V_VT(&var) == VT_DISPATCH)
980 prot = iface_to_jsdisp((IUnknown*)V_DISPATCH(&var));
981 VariantClear(&var);
982 }
983
984 hres = init_dispex(dispex, ctx, builtin_info, prot);
985
986 if(prot)
987 jsdisp_release(prot);
988 if(FAILED(hres))
989 return hres;
990
991 hres = ensure_prop_name(dispex, constructorW, FALSE, 0, &prop);
992 if(SUCCEEDED(hres)) {
993 jsexcept_t jsexcept;
994 VARIANT var;
995
996 var_set_jsdisp(&var, constr);
997 memset(&jsexcept, 0, sizeof(jsexcept));
998 hres = prop_put(dispex, prop, &var, &jsexcept, NULL/*FIXME*/);
999 }
1000 if(FAILED(hres))
1001 jsdisp_release(dispex);
1002
1003 return hres;
1004 }
1005
1006 jsdisp_t *iface_to_jsdisp(IUnknown *iface)
1007 {
1008 jsdisp_t *ret;
1009 HRESULT hres;
1010
1011 hres = IUnknown_QueryInterface(iface, &IID_IDispatchJS, (void**)&ret);
1012 if(FAILED(hres))
1013 return NULL;
1014
1015 return ret;
1016 }
1017
1018 static void ensure_retval_type(VARIANT *v)
1019 {
1020 switch(V_VT(v)) {
1021 case VT_I2:
1022 V_VT(v) = VT_I4;
1023 V_I4(v) = V_I2(v);
1024 break;
1025 case VT_INT:
1026 V_VT(v) = VT_I4;
1027 V_I4(v) = V_INT(v);
1028 }
1029 }
1030
1031 HRESULT jsdisp_get_id(jsdisp_t *jsdisp, const WCHAR *name, DWORD flags, DISPID *id)
1032 {
1033 dispex_prop_t *prop;
1034 HRESULT hres;
1035
1036 if(flags & fdexNameEnsure)
1037 hres = ensure_prop_name(jsdisp, name, TRUE, PROPF_ENUM, &prop);
1038 else
1039 hres = find_prop_name_prot(jsdisp, string_hash(name), name, &prop);
1040 if(FAILED(hres))
1041 return hres;
1042
1043 if(prop && prop->type!=PROP_DELETED) {
1044 *id = prop_to_id(jsdisp, prop);
1045 return S_OK;
1046 }
1047
1048 TRACE("not found %s\n", debugstr_w(name));
1049 return DISP_E_UNKNOWNNAME;
1050 }
1051
1052 HRESULT jsdisp_call_value(jsdisp_t *jsthis, WORD flags, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei)
1053 {
1054 vdisp_t vdisp;
1055 HRESULT hres;
1056
1057 set_jsdisp(&vdisp, jsthis);
1058 hres = jsthis->builtin_info->value_prop.invoke(jsthis->ctx, &vdisp, flags, dp, retv, ei);
1059 vdisp_release(&vdisp);
1060 return hres;
1061 }
1062
1063 HRESULT jsdisp_call(jsdisp_t *disp, DISPID id, WORD flags, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei)
1064 {
1065 dispex_prop_t *prop;
1066
1067 memset(ei, 0, sizeof(*ei));
1068 if(retv)
1069 V_VT(retv) = VT_EMPTY;
1070
1071 prop = get_prop(disp, id);
1072 if(!prop)
1073 return DISP_E_MEMBERNOTFOUND;
1074
1075 return invoke_prop_func(disp, disp, prop, flags, dp, retv, ei, NULL);
1076 }
1077
1078 HRESULT jsdisp_call_name(jsdisp_t *disp, const WCHAR *name, WORD flags, DISPPARAMS *dp, VARIANT *retv,
1079 jsexcept_t *ei)
1080 {
1081 dispex_prop_t *prop;
1082 HRESULT hres;
1083
1084 hres = find_prop_name_prot(disp, string_hash(name), name, &prop);
1085 if(FAILED(hres))
1086 return hres;
1087
1088 memset(ei, 0, sizeof(*ei));
1089 if(retv)
1090 V_VT(retv) = VT_EMPTY;
1091
1092 return invoke_prop_func(disp, disp, prop, flags, dp, retv, ei, NULL);
1093 }
1094
1095 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, WORD flags, DISPPARAMS *dp, VARIANT *retv, jsexcept_t *ei)
1096 {
1097 jsdisp_t *jsdisp;
1098 IDispatchEx *dispex;
1099 HRESULT hres;
1100
1101 jsdisp = iface_to_jsdisp((IUnknown*)disp);
1102 if(jsdisp) {
1103 if(flags & DISPATCH_PROPERTYPUT) {
1104 FIXME("disp_call(propput) on builtin object\n");
1105 return E_FAIL;
1106 }
1107
1108 hres = jsdisp_call(jsdisp, id, flags, dp, retv, ei);
1109 jsdisp_release(jsdisp);
1110 return hres;
1111 }
1112
1113 memset(ei, 0, sizeof(*ei));
1114 if(retv && arg_cnt(dp))
1115 flags |= DISPATCH_PROPERTYGET;
1116
1117 if(retv)
1118 V_VT(retv) = VT_EMPTY;
1119 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1120 if(SUCCEEDED(hres)) {
1121 hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei->ei, &ctx->jscaller->IServiceProvider_iface);
1122 IDispatchEx_Release(dispex);
1123 }else {
1124 UINT err = 0;
1125
1126 if(flags == DISPATCH_CONSTRUCT) {
1127 WARN("IDispatch cannot be constructor\n");
1128 return DISP_E_MEMBERNOTFOUND;
1129 }
1130
1131 TRACE("using IDispatch\n");
1132 hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei->ei, &err);
1133 }
1134
1135 if(FAILED(hres))
1136 return hres;
1137
1138 if(retv)
1139 ensure_retval_type(retv);
1140 return S_OK;
1141 }
1142
1143 HRESULT jsdisp_propput_name(jsdisp_t *obj, const WCHAR *name, VARIANT *val, jsexcept_t *ei)
1144 {
1145 dispex_prop_t *prop;
1146 HRESULT hres;
1147
1148 hres = ensure_prop_name(obj, name, FALSE, PROPF_ENUM, &prop);
1149 if(FAILED(hres))
1150 return hres;
1151
1152 return prop_put(obj, prop, val, ei, NULL);
1153 }
1154
1155 HRESULT jsdisp_propput_const(jsdisp_t *obj, const WCHAR *name, VARIANT *val)
1156 {
1157 dispex_prop_t *prop;
1158 HRESULT hres;
1159
1160 hres = ensure_prop_name(obj, name, FALSE, PROPF_ENUM|PROPF_CONST, &prop);
1161 if(FAILED(hres))
1162 return hres;
1163
1164 return VariantCopy(&prop->u.var, val);
1165 }
1166
1167 HRESULT jsdisp_propput_idx(jsdisp_t *obj, DWORD idx, VARIANT *val, jsexcept_t *ei)
1168 {
1169 WCHAR buf[12];
1170
1171 static const WCHAR formatW[] = {'%','d',0};
1172
1173 sprintfW(buf, formatW, idx);
1174 return jsdisp_propput_name(obj, buf, val, ei);
1175 }
1176
1177 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val, jsexcept_t *ei)
1178 {
1179 jsdisp_t *jsdisp;
1180 HRESULT hres;
1181
1182 jsdisp = iface_to_jsdisp((IUnknown*)disp);
1183 if(jsdisp) {
1184 dispex_prop_t *prop;
1185
1186 prop = get_prop(jsdisp, id);
1187 if(prop)
1188 hres = prop_put(jsdisp, prop, val, ei, NULL);
1189 else
1190 hres = DISP_E_MEMBERNOTFOUND;
1191
1192 jsdisp_release(jsdisp);
1193 }else {
1194 DISPID dispid = DISPID_PROPERTYPUT;
1195 DISPPARAMS dp = {val, &dispid, 1, 1};
1196 IDispatchEx *dispex;
1197
1198 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1199 if(SUCCEEDED(hres)) {
1200 hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei,
1201 &ctx->jscaller->IServiceProvider_iface);
1202 IDispatchEx_Release(dispex);
1203 }else {
1204 ULONG err = 0;
1205
1206 TRACE("using IDispatch\n");
1207 hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, &dp, NULL, &ei->ei, &err);
1208 }
1209 }
1210
1211 return hres;
1212 }
1213
1214 HRESULT jsdisp_propget_name(jsdisp_t *obj, const WCHAR *name, VARIANT *var, jsexcept_t *ei)
1215 {
1216 DISPPARAMS dp = {NULL, NULL, 0, 0};
1217 dispex_prop_t *prop;
1218 HRESULT hres;
1219
1220 hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1221 if(FAILED(hres))
1222 return hres;
1223
1224 V_VT(var) = VT_EMPTY;
1225 if(!prop || prop->type==PROP_DELETED)
1226 return S_OK;
1227
1228 return prop_get(obj, prop, &dp, var, ei, NULL);
1229 }
1230
1231 HRESULT jsdisp_get_idx(jsdisp_t *obj, DWORD idx, VARIANT *var, jsexcept_t *ei)
1232 {
1233 WCHAR name[12];
1234 DISPPARAMS dp = {NULL, NULL, 0, 0};
1235 dispex_prop_t *prop;
1236 HRESULT hres;
1237
1238 static const WCHAR formatW[] = {'%','d',0};
1239
1240 sprintfW(name, formatW, idx);
1241
1242 hres = find_prop_name_prot(obj, string_hash(name), name, &prop);
1243 if(FAILED(hres))
1244 return hres;
1245
1246 V_VT(var) = VT_EMPTY;
1247 if(!prop || prop->type==PROP_DELETED)
1248 return DISP_E_UNKNOWNNAME;
1249
1250 return prop_get(obj, prop, &dp, var, ei, NULL);
1251 }
1252
1253 HRESULT jsdisp_propget(jsdisp_t *jsdisp, DISPID id, VARIANT *val, jsexcept_t *ei)
1254 {
1255 DISPPARAMS dp = {NULL,NULL,0,0};
1256 dispex_prop_t *prop;
1257
1258 prop = get_prop(jsdisp, id);
1259 if(!prop)
1260 return DISP_E_MEMBERNOTFOUND;
1261
1262 V_VT(val) = VT_EMPTY;
1263 return prop_get(jsdisp, prop, &dp, val, ei, NULL);
1264 }
1265
1266 HRESULT disp_propget(script_ctx_t *ctx, IDispatch *disp, DISPID id, VARIANT *val, jsexcept_t *ei)
1267 {
1268 DISPPARAMS dp = {NULL,NULL,0,0};
1269 IDispatchEx *dispex;
1270 jsdisp_t *jsdisp;
1271 HRESULT hres;
1272
1273 jsdisp = iface_to_jsdisp((IUnknown*)disp);
1274 if(jsdisp) {
1275 hres = jsdisp_propget(jsdisp, id, val, ei);
1276 jsdisp_release(jsdisp);
1277 return hres;
1278 }
1279
1280 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1281 if(SUCCEEDED(hres)) {
1282 hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei,
1283 &ctx->jscaller->IServiceProvider_iface);
1284 IDispatchEx_Release(dispex);
1285 }else {
1286 ULONG err = 0;
1287
1288 TRACE("using IDispatch\n");
1289 hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, INVOKE_PROPERTYGET, &dp, val, &ei->ei, &err);
1290 }
1291 if(FAILED(hres))
1292 return hres;
1293
1294 ensure_retval_type(val);
1295 return S_OK;
1296 }
1297
1298 HRESULT jsdisp_delete_idx(jsdisp_t *obj, DWORD idx)
1299 {
1300 static const WCHAR formatW[] = {'%','d',0};
1301 WCHAR buf[12];
1302 dispex_prop_t *prop;
1303 HRESULT hres;
1304
1305 sprintfW(buf, formatW, idx);
1306
1307 hres = find_prop_name(obj, string_hash(buf), buf, &prop);
1308 if(FAILED(hres) || !prop)
1309 return hres;
1310
1311 return delete_prop(prop);
1312 }
1313
1314 VARIANT_BOOL jsdisp_is_own_prop(jsdisp_t *obj, BSTR name)
1315 {
1316 dispex_prop_t *prop;
1317 HRESULT hres;
1318
1319 hres = find_prop_name(obj, string_hash(name), name, &prop);
1320 if(FAILED(hres))
1321 return VARIANT_FALSE;
1322 else if(!prop)
1323 return VARIANT_FALSE;
1324
1325 return prop->type==PROP_VARIANT ? VARIANT_TRUE : VARIANT_FALSE;
1326 }
1327
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.