1 /*
2 * Copyright 2011 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 "vbscript.h"
22
23 #include "wine/debug.h"
24
25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
26
27 static inline BOOL is_func_id(vbdisp_t *This, DISPID id)
28 {
29 return id < This->desc->func_cnt;
30 }
31
32 static BOOL get_func_id(vbdisp_t *This, const WCHAR *name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
33 {
34 unsigned i;
35
36 for(i = invoke_type == VBDISP_ANY ? 0 : 1; i < This->desc->func_cnt; i++) {
37 if(invoke_type == VBDISP_ANY) {
38 if(!search_private && !This->desc->funcs[i].is_public)
39 continue;
40 if(!i && !This->desc->funcs[0].name) /* default value may not exist */
41 continue;
42 }else {
43 if(!This->desc->funcs[i].entries[invoke_type]
44 || (!search_private && !This->desc->funcs[i].entries[invoke_type]->is_public))
45 continue;
46 }
47
48 if(!strcmpiW(This->desc->funcs[i].name, name)) {
49 *id = i;
50 return TRUE;
51 }
52 }
53
54 return FALSE;
55 }
56
57 HRESULT vbdisp_get_id(vbdisp_t *This, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
58 {
59 unsigned i;
60
61 if(get_func_id(This, name, invoke_type, search_private, id))
62 return S_OK;
63
64 for(i=0; i < This->desc->prop_cnt; i++) {
65 if(!search_private && !This->desc->props[i].is_public)
66 continue;
67
68 if(!strcmpiW(This->desc->props[i].name, name)) {
69 *id = i + This->desc->func_cnt;
70 return S_OK;
71 }
72 }
73
74 if(This->desc->typeinfo) {
75 HRESULT hres;
76
77 hres = ITypeInfo_GetIDsOfNames(This->desc->typeinfo, &name, 1, id);
78 if(SUCCEEDED(hres))
79 return S_OK;
80 }
81
82 *id = -1;
83 return DISP_E_UNKNOWNNAME;
84 }
85
86 static VARIANT *get_propput_arg(const DISPPARAMS *dp)
87 {
88 unsigned i;
89
90 for(i=0; i < dp->cNamedArgs; i++) {
91 if(dp->rgdispidNamedArgs[i] == DISPID_PROPERTYPUT)
92 return dp->rgvarg+i;
93 }
94
95 return NULL;
96 }
97
98 static HRESULT invoke_variant_prop(vbdisp_t *This, VARIANT *v, WORD flags, DISPPARAMS *dp, VARIANT *res)
99 {
100 HRESULT hres;
101
102 switch(flags) {
103 case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
104 if(dp->cArgs) {
105 WARN("called with arguments\n");
106 return DISP_E_MEMBERNOTFOUND; /* That's what tests show */
107 }
108
109 hres = VariantCopy(res, v);
110 break;
111
112 case DISPATCH_PROPERTYPUT: {
113 VARIANT *put_val;
114
115 put_val = get_propput_arg(dp);
116 if(!put_val) {
117 WARN("no value to set\n");
118 return DISP_E_PARAMNOTOPTIONAL;
119 }
120
121 if(res)
122 V_VT(res) = VT_EMPTY;
123
124 hres = VariantCopy(v, put_val);
125 break;
126 }
127
128 default:
129 FIXME("unimplemented flags %x\n", flags);
130 return E_NOTIMPL;
131 }
132
133 return hres;
134 }
135
136 static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
137 {
138 VARIANT *args, arg_buf[8];
139 unsigned argn;
140
141 switch(flags) {
142 case DISPATCH_PROPERTYGET:
143 if(!(prop->flags & (BP_GET|BP_GETPUT))) {
144 FIXME("property does not support DISPATCH_PROPERTYGET\n");
145 return E_FAIL;
146 }
147 break;
148 case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
149 break;
150 case DISPATCH_METHOD:
151 if(prop->flags & (BP_GET|BP_GETPUT)) {
152 FIXME("Call on property\n");
153 return E_FAIL;
154 }
155 break;
156 case DISPATCH_PROPERTYPUT:
157 if(!(prop->flags & (BP_GET|BP_GETPUT))) {
158 FIXME("property does not support DISPATCH_PROPERTYPUT\n");
159 return E_FAIL;
160 }
161
162 FIXME("call put\n");
163 return E_NOTIMPL;
164 default:
165 FIXME("unsupported flags %x\n", flags);
166 return E_NOTIMPL;
167 }
168
169 argn = arg_cnt(dp);
170
171 if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) {
172 FIXME("invalid number of arguments\n");
173 return E_FAIL;
174 }
175
176 args = dp->rgvarg;
177
178 if(argn == 1) {
179 if(V_VT(dp->rgvarg) == (VT_BYREF|VT_VARIANT))
180 args = V_VARIANTREF(dp->rgvarg);
181 }else {
182 unsigned i;
183
184 assert(argn < sizeof(arg_buf)/sizeof(*arg_buf));
185
186 for(i=0; i < argn; i++) {
187 if(V_VT(dp->rgvarg+i) == (VT_BYREF|VT_VARIANT)) {
188 for(i=0; i < argn; i++) {
189 if(V_VT(dp->rgvarg+i) == (VT_BYREF|VT_VARIANT))
190 arg_buf[i] = *V_VARIANTREF(dp->rgvarg+i);
191 else
192 arg_buf[i] = dp->rgvarg[i];
193 }
194 args = arg_buf;
195 break;
196 }
197 }
198 }
199
200 return prop->proc(This, args, dp->cArgs, res);
201 }
202
203 static BOOL run_terminator(vbdisp_t *This)
204 {
205 DISPPARAMS dp = {0};
206
207 if(This->terminator_ran)
208 return TRUE;
209 This->terminator_ran = TRUE;
210
211 if(!This->desc->class_terminate_id)
212 return TRUE;
213
214 This->ref++;
215 exec_script(This->desc->ctx, This->desc->funcs[This->desc->class_terminate_id].entries[VBDISP_CALLGET],
216 (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
217 return !--This->ref;
218 }
219
220 static void clean_props(vbdisp_t *This)
221 {
222 unsigned i;
223
224 if(!This->desc)
225 return;
226
227 for(i=0; i < This->desc->prop_cnt; i++)
228 VariantClear(This->props+i);
229 }
230
231 static inline vbdisp_t *impl_from_IDispatchEx(IDispatchEx *iface)
232 {
233 return CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface);
234 }
235
236 static HRESULT WINAPI DispatchEx_QueryInterface(IDispatchEx *iface, REFIID riid, void **ppv)
237 {
238 vbdisp_t *This = impl_from_IDispatchEx(iface);
239
240 if(IsEqualGUID(&IID_IUnknown, riid)) {
241 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
242 *ppv = &This->IDispatchEx_iface;
243 }else if(IsEqualGUID(&IID_IDispatch, riid)) {
244 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
245 *ppv = &This->IDispatchEx_iface;
246 }else if(IsEqualGUID(&IID_IDispatchEx, riid)) {
247 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
248 *ppv = &This->IDispatchEx_iface;
249 }else {
250 WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
251 *ppv = NULL;
252 return E_NOINTERFACE;
253 }
254
255 IUnknown_AddRef((IUnknown*)*ppv);
256 return S_OK;
257 }
258
259 static ULONG WINAPI DispatchEx_AddRef(IDispatchEx *iface)
260 {
261 vbdisp_t *This = impl_from_IDispatchEx(iface);
262 LONG ref = InterlockedIncrement(&This->ref);
263
264 TRACE("(%p) ref=%d\n", This, ref);
265
266 return ref;
267 }
268
269 static ULONG WINAPI DispatchEx_Release(IDispatchEx *iface)
270 {
271 vbdisp_t *This = impl_from_IDispatchEx(iface);
272 LONG ref = InterlockedDecrement(&This->ref);
273
274 TRACE("(%p) ref=%d\n", This, ref);
275
276 if(!ref && run_terminator(This)) {
277 clean_props(This);
278 list_remove(&This->entry);
279 heap_free(This);
280 }
281
282 return ref;
283 }
284
285 static HRESULT WINAPI DispatchEx_GetTypeInfoCount(IDispatchEx *iface, UINT *pctinfo)
286 {
287 vbdisp_t *This = impl_from_IDispatchEx(iface);
288
289 TRACE("(%p)->(%p)\n", This, pctinfo);
290
291 *pctinfo = 1;
292 return S_OK;
293 }
294
295 static HRESULT WINAPI DispatchEx_GetTypeInfo(IDispatchEx *iface, UINT iTInfo, LCID lcid,
296 ITypeInfo **ppTInfo)
297 {
298 vbdisp_t *This = impl_from_IDispatchEx(iface);
299 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
300 return E_NOTIMPL;
301 }
302
303 static HRESULT WINAPI DispatchEx_GetIDsOfNames(IDispatchEx *iface, REFIID riid,
304 LPOLESTR *rgszNames, UINT cNames, LCID lcid,
305 DISPID *rgDispId)
306 {
307 vbdisp_t *This = impl_from_IDispatchEx(iface);
308 FIXME("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid), rgszNames, cNames,
309 lcid, rgDispId);
310 return E_NOTIMPL;
311 }
312
313 static HRESULT WINAPI DispatchEx_Invoke(IDispatchEx *iface, DISPID dispIdMember,
314 REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
315 VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
316 {
317 vbdisp_t *This = impl_from_IDispatchEx(iface);
318 FIXME("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
319 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
320 return E_NOTIMPL;
321 }
322
323 static HRESULT WINAPI DispatchEx_GetDispID(IDispatchEx *iface, BSTR bstrName, DWORD grfdex, DISPID *pid)
324 {
325 vbdisp_t *This = impl_from_IDispatchEx(iface);
326
327 TRACE("(%p)->(%s %x %p)\n", This, debugstr_w(bstrName), grfdex, pid);
328
329 if(!This->desc)
330 return E_UNEXPECTED;
331
332 if(grfdex & ~(fdexNameEnsure|fdexNameCaseInsensitive)) {
333 FIXME("unsupported flags %x\n", grfdex);
334 return E_NOTIMPL;
335 }
336
337 return vbdisp_get_id(This, bstrName, VBDISP_ANY, FALSE, pid);
338 }
339
340 static HRESULT WINAPI DispatchEx_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
341 VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
342 {
343 vbdisp_t *This = impl_from_IDispatchEx(iface);
344
345 TRACE("(%p)->(%x %x %x %p %p %p %p)\n", This, id, lcid, wFlags, pdp, pvarRes, pei, pspCaller);
346
347 if(!This->desc)
348 return E_UNEXPECTED;
349
350 if(pvarRes)
351 V_VT(pvarRes) = VT_EMPTY;
352
353 if(id < 0)
354 return DISP_E_MEMBERNOTFOUND;
355
356 if(is_func_id(This, id)) {
357 function_t *func;
358
359 switch(wFlags) {
360 case DISPATCH_METHOD:
361 case DISPATCH_METHOD|DISPATCH_PROPERTYGET:
362 func = This->desc->funcs[id].entries[VBDISP_CALLGET];
363 if(!func) {
364 FIXME("no invoke/getter\n");
365 return DISP_E_MEMBERNOTFOUND;
366 }
367
368 return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, pdp, pvarRes);
369 case DISPATCH_PROPERTYPUT: {
370 VARIANT *put_val;
371 DISPPARAMS dp = {NULL, NULL, 1, 0};
372
373 if(arg_cnt(pdp)) {
374 FIXME("arguments not implemented\n");
375 return E_NOTIMPL;
376 }
377
378 put_val = get_propput_arg(pdp);
379 if(!put_val) {
380 WARN("no value to set\n");
381 return DISP_E_PARAMNOTOPTIONAL;
382 }
383
384 dp.rgvarg = put_val;
385 func = This->desc->funcs[id].entries[V_VT(put_val) == VT_DISPATCH ? VBDISP_SET : VBDISP_LET];
386 if(!func) {
387 FIXME("no letter/setter\n");
388 return DISP_E_MEMBERNOTFOUND;
389 }
390
391 return exec_script(This->desc->ctx, func, (IDispatch*)&This->IDispatchEx_iface, &dp, NULL);
392 }
393 default:
394 FIXME("flags %x\n", wFlags);
395 return DISP_E_MEMBERNOTFOUND;
396 }
397 }
398
399 if(id < This->desc->prop_cnt + This->desc->func_cnt)
400 return invoke_variant_prop(This, This->props+(id-This->desc->func_cnt), wFlags, pdp, pvarRes);
401
402 if(This->desc->builtin_prop_cnt) {
403 unsigned min = 0, max = This->desc->builtin_prop_cnt-1, i;
404
405 while(min <= max) {
406 i = (min+max)/2;
407 if(This->desc->builtin_props[i].id == id)
408 return invoke_builtin(This, This->desc->builtin_props+i, wFlags, pdp, pvarRes);
409 if(This->desc->builtin_props[i].id < id)
410 min = i+1;
411 else
412 max = i-1;
413 }
414 }
415
416 return DISP_E_MEMBERNOTFOUND;
417 }
418
419 static HRESULT WINAPI DispatchEx_DeleteMemberByName(IDispatchEx *iface, BSTR bstrName, DWORD grfdex)
420 {
421 vbdisp_t *This = impl_from_IDispatchEx(iface);
422 FIXME("(%p)->(%s %x)\n", This, debugstr_w(bstrName), grfdex);
423 return E_NOTIMPL;
424 }
425
426 static HRESULT WINAPI DispatchEx_DeleteMemberByDispID(IDispatchEx *iface, DISPID id)
427 {
428 vbdisp_t *This = impl_from_IDispatchEx(iface);
429 FIXME("(%p)->(%x)\n", This, id);
430 return E_NOTIMPL;
431 }
432
433 static HRESULT WINAPI DispatchEx_GetMemberProperties(IDispatchEx *iface, DISPID id, DWORD grfdexFetch, DWORD *pgrfdex)
434 {
435 vbdisp_t *This = impl_from_IDispatchEx(iface);
436 FIXME("(%p)->(%x %x %p)\n", This, id, grfdexFetch, pgrfdex);
437 return E_NOTIMPL;
438 }
439
440 static HRESULT WINAPI DispatchEx_GetMemberName(IDispatchEx *iface, DISPID id, BSTR *pbstrName)
441 {
442 vbdisp_t *This = impl_from_IDispatchEx(iface);
443 FIXME("(%p)->(%x %p)\n", This, id, pbstrName);
444 return E_NOTIMPL;
445 }
446
447 static HRESULT WINAPI DispatchEx_GetNextDispID(IDispatchEx *iface, DWORD grfdex, DISPID id, DISPID *pid)
448 {
449 vbdisp_t *This = impl_from_IDispatchEx(iface);
450 FIXME("(%p)->(%x %x %p)\n", This, grfdex, id, pid);
451 return E_NOTIMPL;
452 }
453
454 static HRESULT WINAPI DispatchEx_GetNameSpaceParent(IDispatchEx *iface, IUnknown **ppunk)
455 {
456 vbdisp_t *This = impl_from_IDispatchEx(iface);
457 FIXME("(%p)->(%p)\n", This, ppunk);
458 return E_NOTIMPL;
459 }
460
461 static IDispatchExVtbl DispatchExVtbl = {
462 DispatchEx_QueryInterface,
463 DispatchEx_AddRef,
464 DispatchEx_Release,
465 DispatchEx_GetTypeInfoCount,
466 DispatchEx_GetTypeInfo,
467 DispatchEx_GetIDsOfNames,
468 DispatchEx_Invoke,
469 DispatchEx_GetDispID,
470 DispatchEx_InvokeEx,
471 DispatchEx_DeleteMemberByName,
472 DispatchEx_DeleteMemberByDispID,
473 DispatchEx_GetMemberProperties,
474 DispatchEx_GetMemberName,
475 DispatchEx_GetNextDispID,
476 DispatchEx_GetNameSpaceParent
477 };
478
479 static inline vbdisp_t *unsafe_impl_from_IDispatch(IDispatch *iface)
480 {
481 return iface->lpVtbl == (IDispatchVtbl*)&DispatchExVtbl
482 ? CONTAINING_RECORD(iface, vbdisp_t, IDispatchEx_iface)
483 : NULL;
484 }
485
486 HRESULT create_vbdisp(const class_desc_t *desc, vbdisp_t **ret)
487 {
488 vbdisp_t *vbdisp;
489
490 vbdisp = heap_alloc_zero( FIELD_OFFSET( vbdisp_t, props[desc->prop_cnt] ));
491 if(!vbdisp)
492 return E_OUTOFMEMORY;
493
494 vbdisp->IDispatchEx_iface.lpVtbl = &DispatchExVtbl;
495 vbdisp->ref = 1;
496 vbdisp->desc = desc;
497
498 if(desc->class_initialize_id) {
499 DISPPARAMS dp = {0};
500 HRESULT hres;
501
502 hres = exec_script(desc->ctx, desc->funcs[desc->class_initialize_id].entries[VBDISP_CALLGET],
503 (IDispatch*)&vbdisp->IDispatchEx_iface, &dp, NULL);
504 if(FAILED(hres)) {
505 IDispatchEx_Release(&vbdisp->IDispatchEx_iface);
506 return hres;
507 }
508 }
509
510 list_add_tail(&desc->ctx->objects, &vbdisp->entry);
511 *ret = vbdisp;
512 return S_OK;
513 }
514
515 void collect_objects(script_ctx_t *ctx)
516 {
517 vbdisp_t *iter, *iter2;
518
519 LIST_FOR_EACH_ENTRY_SAFE(iter, iter2, &ctx->objects, vbdisp_t, entry)
520 run_terminator(iter);
521
522 while(!list_empty(&ctx->objects)) {
523 iter = LIST_ENTRY(list_head(&ctx->objects), vbdisp_t, entry);
524
525 IDispatchEx_AddRef(&iter->IDispatchEx_iface);
526 clean_props(iter);
527 iter->desc = NULL;
528 list_remove(&iter->entry);
529 list_init(&iter->entry);
530 IDispatchEx_Release(&iter->IDispatchEx_iface);
531 }
532 }
533
534 HRESULT disp_get_id(IDispatch *disp, BSTR name, vbdisp_invoke_type_t invoke_type, BOOL search_private, DISPID *id)
535 {
536 IDispatchEx *dispex;
537 vbdisp_t *vbdisp;
538 HRESULT hres;
539
540 vbdisp = unsafe_impl_from_IDispatch(disp);
541 if(vbdisp)
542 return vbdisp_get_id(vbdisp, name, invoke_type, search_private, id);
543
544 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
545 if(FAILED(hres)) {
546 TRACE("using IDispatch\n");
547 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
548 }
549
550 hres = IDispatchEx_GetDispID(dispex, name, fdexNameCaseInsensitive, id);
551 IDispatchEx_Release(dispex);
552 return hres;
553 }
554
555 HRESULT disp_call(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp, VARIANT *retv)
556 {
557 const WORD flags = DISPATCH_METHOD|(retv ? DISPATCH_PROPERTYGET : 0);
558 IDispatchEx *dispex;
559 EXCEPINFO ei;
560 HRESULT hres;
561
562 memset(&ei, 0, sizeof(ei));
563 if(retv)
564 V_VT(retv) = VT_EMPTY;
565
566 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
567 if(FAILED(hres)) {
568 UINT err = 0;
569
570 TRACE("using IDispatch\n");
571 return IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, flags, dp, retv, &ei, &err);
572 }
573
574 hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, flags, dp, retv, &ei, NULL /* CALLER_FIXME */);
575 IDispatchEx_Release(dispex);
576 return hres;
577 }
578
579 HRESULT disp_propput(script_ctx_t *ctx, IDispatch *disp, DISPID id, DISPPARAMS *dp)
580 {
581 IDispatchEx *dispex;
582 EXCEPINFO ei = {0};
583 HRESULT hres;
584
585 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
586 if(SUCCEEDED(hres)) {
587 hres = IDispatchEx_InvokeEx(dispex, id, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, NULL /* FIXME! */);
588 IDispatchEx_Release(dispex);
589 }else {
590 ULONG err = 0;
591
592 TRACE("using IDispatch\n");
593 hres = IDispatch_Invoke(disp, id, &IID_NULL, ctx->lcid, DISPATCH_PROPERTYPUT, dp, NULL, &ei, &err);
594 }
595
596 return hres;
597 }
598
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.