mfplat: Read queue subscriber within the critical section.
[wine/zf.git] / dlls / vbscript / interp.c
blob11d95e57758486ea5700da2a0c7133c244f33081
1 /*
2 * Copyright 2011 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
19 #include <assert.h>
21 #include "vbscript.h"
23 #include "wine/debug.h"
25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
27 static DISPID propput_dispid = DISPID_PROPERTYPUT;
29 typedef struct {
30 vbscode_t *code;
31 instr_t *instr;
32 script_ctx_t *script;
33 function_t *func;
34 vbdisp_t *vbthis;
36 VARIANT *args;
37 VARIANT *vars;
38 SAFEARRAY **arrays;
40 dynamic_var_t *dynamic_vars;
41 heap_pool_t heap;
43 BOOL resume_next;
45 unsigned stack_size;
46 unsigned top;
47 VARIANT *stack;
49 VARIANT ret_val;
50 } exec_ctx_t;
52 typedef HRESULT (*instr_func_t)(exec_ctx_t*);
54 typedef enum {
55 REF_NONE,
56 REF_DISP,
57 REF_VAR,
58 REF_OBJ,
59 REF_CONST,
60 REF_FUNC
61 } ref_type_t;
63 typedef struct {
64 ref_type_t type;
65 union {
66 struct {
67 IDispatch *disp;
68 DISPID id;
69 } d;
70 VARIANT *v;
71 function_t *f;
72 IDispatch *obj;
73 } u;
74 } ref_t;
76 typedef struct {
77 VARIANT *v;
78 VARIANT store;
79 BOOL owned;
80 } variant_val_t;
82 static BOOL lookup_dynamic_vars(dynamic_var_t *var, const WCHAR *name, ref_t *ref)
84 while(var) {
85 if(!wcsicmp(var->name, name)) {
86 ref->type = var->is_const ? REF_CONST : REF_VAR;
87 ref->u.v = &var->v;
88 return TRUE;
91 var = var->next;
94 return FALSE;
97 static BOOL lookup_global_vars(ScriptDisp *script, const WCHAR *name, ref_t *ref)
99 dynamic_var_t **vars = script->global_vars;
100 size_t i, cnt = script->global_vars_cnt;
102 for(i = 0; i < cnt; i++) {
103 if(!wcsicmp(vars[i]->name, name)) {
104 ref->type = vars[i]->is_const ? REF_CONST : REF_VAR;
105 ref->u.v = &vars[i]->v;
106 return TRUE;
110 return FALSE;
113 static BOOL lookup_global_funcs(ScriptDisp *script, const WCHAR *name, ref_t *ref)
115 function_t **funcs = script->global_funcs;
116 size_t i, cnt = script->global_funcs_cnt;
118 for(i = 0; i < cnt; i++) {
119 if(!wcsicmp(funcs[i]->name, name)) {
120 ref->type = REF_FUNC;
121 ref->u.f = funcs[i];
122 return TRUE;
126 return FALSE;
129 static HRESULT lookup_identifier(exec_ctx_t *ctx, BSTR name, vbdisp_invoke_type_t invoke_type, ref_t *ref)
131 ScriptDisp *script_obj = ctx->script->script_obj;
132 named_item_t *item;
133 unsigned i;
134 DISPID id;
135 HRESULT hres;
137 if((ctx->func->type == FUNC_FUNCTION || ctx->func->type == FUNC_PROPGET)
138 && !wcsicmp(name, ctx->func->name)) {
139 ref->type = REF_VAR;
140 ref->u.v = &ctx->ret_val;
141 return S_OK;
144 if(ctx->func->type != FUNC_GLOBAL) {
145 for(i=0; i < ctx->func->var_cnt; i++) {
146 if(!wcsicmp(ctx->func->vars[i].name, name)) {
147 ref->type = REF_VAR;
148 ref->u.v = ctx->vars+i;
149 return S_OK;
153 for(i=0; i < ctx->func->arg_cnt; i++) {
154 if(!wcsicmp(ctx->func->args[i].name, name)) {
155 ref->type = REF_VAR;
156 ref->u.v = ctx->args+i;
157 return S_OK;
161 if(lookup_dynamic_vars(ctx->dynamic_vars, name, ref))
162 return S_OK;
164 if(ctx->vbthis) {
165 /* FIXME: Bind such identifier while generating bytecode. */
166 for(i=0; i < ctx->vbthis->desc->prop_cnt; i++) {
167 if(!wcsicmp(ctx->vbthis->desc->props[i].name, name)) {
168 ref->type = REF_VAR;
169 ref->u.v = ctx->vbthis->props+i;
170 return S_OK;
174 hres = vbdisp_get_id(ctx->vbthis, name, invoke_type, TRUE, &id);
175 if(SUCCEEDED(hres)) {
176 ref->type = REF_DISP;
177 ref->u.d.disp = (IDispatch*)&ctx->vbthis->IDispatchEx_iface;
178 ref->u.d.id = id;
179 return S_OK;
184 if(ctx->code->named_item) {
185 if(lookup_global_vars(ctx->code->named_item->script_obj, name, ref))
186 return S_OK;
187 if(lookup_global_funcs(ctx->code->named_item->script_obj, name, ref))
188 return S_OK;
191 if(ctx->func->code_ctx->named_item && ctx->func->code_ctx->named_item->disp &&
192 !(ctx->func->code_ctx->named_item->flags & SCRIPTITEM_CODEONLY))
194 hres = disp_get_id(ctx->func->code_ctx->named_item->disp, name, invoke_type, TRUE, &id);
195 if(SUCCEEDED(hres)) {
196 ref->type = REF_DISP;
197 ref->u.d.disp = ctx->func->code_ctx->named_item->disp;
198 ref->u.d.id = id;
199 return S_OK;
203 if(lookup_global_vars(script_obj, name, ref))
204 return S_OK;
205 if(lookup_global_funcs(script_obj, name, ref))
206 return S_OK;
208 hres = get_builtin_id(ctx->script->global_obj, name, &id);
209 if(SUCCEEDED(hres)) {
210 ref->type = REF_DISP;
211 ref->u.d.disp = &ctx->script->global_obj->IDispatch_iface;
212 ref->u.d.id = id;
213 return S_OK;
216 item = lookup_named_item(ctx->script, name, SCRIPTITEM_ISVISIBLE);
217 if(item && item->disp) {
218 ref->type = REF_OBJ;
219 ref->u.obj = item->disp;
220 return S_OK;
223 LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
224 if((item->flags & SCRIPTITEM_GLOBALMEMBERS)) {
225 hres = disp_get_id(item->disp, name, invoke_type, FALSE, &id);
226 if(SUCCEEDED(hres)) {
227 ref->type = REF_DISP;
228 ref->u.d.disp = item->disp;
229 ref->u.d.id = id;
230 return S_OK;
235 ref->type = REF_NONE;
236 return S_OK;
239 static HRESULT add_dynamic_var(exec_ctx_t *ctx, const WCHAR *name,
240 BOOL is_const, VARIANT **out_var)
242 ScriptDisp *script_obj = ctx->code->named_item ? ctx->code->named_item->script_obj : ctx->script->script_obj;
243 dynamic_var_t *new_var;
244 heap_pool_t *heap;
245 WCHAR *str;
246 unsigned size;
248 heap = ctx->func->type == FUNC_GLOBAL ? &script_obj->heap : &ctx->heap;
250 new_var = heap_pool_alloc(heap, sizeof(*new_var));
251 if(!new_var)
252 return E_OUTOFMEMORY;
254 size = (lstrlenW(name)+1)*sizeof(WCHAR);
255 str = heap_pool_alloc(heap, size);
256 if(!str)
257 return E_OUTOFMEMORY;
258 memcpy(str, name, size);
259 new_var->name = str;
260 new_var->is_const = is_const;
261 new_var->array = NULL;
262 V_VT(&new_var->v) = VT_EMPTY;
264 if(ctx->func->type == FUNC_GLOBAL) {
265 size_t cnt = script_obj->global_vars_cnt + 1;
266 if(cnt > script_obj->global_vars_size) {
267 dynamic_var_t **new_vars;
268 if(script_obj->global_vars)
269 new_vars = heap_realloc(script_obj->global_vars, cnt * 2 * sizeof(*new_vars));
270 else
271 new_vars = heap_alloc(cnt * 2 * sizeof(*new_vars));
272 if(!new_vars)
273 return E_OUTOFMEMORY;
274 script_obj->global_vars = new_vars;
275 script_obj->global_vars_size = cnt * 2;
277 script_obj->global_vars[script_obj->global_vars_cnt++] = new_var;
278 }else {
279 new_var->next = ctx->dynamic_vars;
280 ctx->dynamic_vars = new_var;
283 *out_var = &new_var->v;
284 return S_OK;
287 void clear_ei(EXCEPINFO *ei)
289 SysFreeString(ei->bstrSource);
290 SysFreeString(ei->bstrDescription);
291 SysFreeString(ei->bstrHelpFile);
292 memset(ei, 0, sizeof(*ei));
295 static void clear_error_loc(script_ctx_t *ctx)
297 if(ctx->error_loc_code) {
298 release_vbscode(ctx->error_loc_code);
299 ctx->error_loc_code = NULL;
303 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
305 assert(ctx->top);
306 return ctx->stack + --ctx->top;
309 static inline VARIANT *stack_top(exec_ctx_t *ctx, unsigned n)
311 assert(ctx->top >= n);
312 return ctx->stack + (ctx->top-n-1);
315 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
317 if(ctx->stack_size == ctx->top) {
318 VARIANT *new_stack;
320 new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(*ctx->stack));
321 if(!new_stack) {
322 VariantClear(v);
323 return E_OUTOFMEMORY;
326 ctx->stack = new_stack;
327 ctx->stack_size *= 2;
330 ctx->stack[ctx->top++] = *v;
331 return S_OK;
334 static inline HRESULT stack_push_null(exec_ctx_t *ctx)
336 VARIANT v;
337 V_VT(&v) = VT_NULL;
338 return stack_push(ctx, &v);
341 static void stack_popn(exec_ctx_t *ctx, unsigned n)
343 while(n--)
344 VariantClear(stack_pop(ctx));
347 static void stack_pop_deref(exec_ctx_t *ctx, variant_val_t *r)
349 VARIANT *v;
351 v = stack_pop(ctx);
352 if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
353 r->owned = FALSE;
354 r->v = V_VARIANTREF(v);
355 }else {
356 r->owned = TRUE;
357 r->v = v;
361 static inline void release_val(variant_val_t *v)
363 if(v->owned)
364 VariantClear(v->v);
367 static HRESULT stack_pop_val(exec_ctx_t *ctx, variant_val_t *r)
369 stack_pop_deref(ctx, r);
371 if(V_VT(r->v) == VT_DISPATCH) {
372 HRESULT hres;
374 hres = get_disp_value(ctx->script, V_DISPATCH(r->v), &r->store);
375 if(r->owned && V_DISPATCH(r->v))
376 IDispatch_Release(V_DISPATCH(r->v));
377 if(FAILED(hres))
378 return hres;
380 r->owned = TRUE;
381 r->v = &r->store;
384 return S_OK;
387 static HRESULT stack_assume_val(exec_ctx_t *ctx, unsigned n)
389 VARIANT *v = stack_top(ctx, n);
390 HRESULT hres;
392 if(V_VT(v) == (VT_BYREF|VT_VARIANT)) {
393 VARIANT *ref = V_VARIANTREF(v);
395 V_VT(v) = VT_EMPTY;
396 hres = VariantCopy(v, ref);
397 if(FAILED(hres))
398 return hres;
401 if(V_VT(v) == VT_DISPATCH) {
402 IDispatch *disp;
404 disp = V_DISPATCH(v);
405 hres = get_disp_value(ctx->script, disp, v);
406 if(disp)
407 IDispatch_Release(disp);
408 if(FAILED(hres))
409 return hres;
412 return S_OK;
415 static int stack_pop_bool(exec_ctx_t *ctx, BOOL *b)
417 variant_val_t val;
418 HRESULT hres;
420 hres = stack_pop_val(ctx, &val);
421 if(FAILED(hres))
422 return hres;
424 switch (V_VT(val.v))
426 case VT_BOOL:
427 *b = V_BOOL(val.v);
428 break;
429 case VT_NULL:
430 case VT_EMPTY:
431 *b = FALSE;
432 break;
433 case VT_I2:
434 *b = V_I2(val.v);
435 break;
436 case VT_I4:
437 *b = V_I4(val.v);
438 break;
439 default:
440 FIXME("unsupported for %s\n", debugstr_variant(val.v));
441 release_val(&val);
442 return E_NOTIMPL;
444 return S_OK;
447 static HRESULT stack_pop_disp(exec_ctx_t *ctx, IDispatch **ret)
449 VARIANT *v = stack_pop(ctx);
451 if(V_VT(v) == VT_DISPATCH) {
452 *ret = V_DISPATCH(v);
453 return S_OK;
456 if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
457 FIXME("not supported type: %s\n", debugstr_variant(v));
458 VariantClear(v);
459 return E_FAIL;
462 v = V_BYREF(v);
463 if(V_VT(v) != VT_DISPATCH) {
464 FIXME("not disp %s\n", debugstr_variant(v));
465 return E_FAIL;
468 if(V_DISPATCH(v))
469 IDispatch_AddRef(V_DISPATCH(v));
470 *ret = V_DISPATCH(v);
471 return S_OK;
474 static HRESULT stack_assume_disp(exec_ctx_t *ctx, unsigned n, IDispatch **disp)
476 VARIANT *v = stack_top(ctx, n), *ref;
478 if(V_VT(v) != VT_DISPATCH && (disp || V_VT(v) != VT_UNKNOWN)) {
479 if(V_VT(v) != (VT_VARIANT|VT_BYREF)) {
480 FIXME("not supported type: %s\n", debugstr_variant(v));
481 return E_FAIL;
484 ref = V_VARIANTREF(v);
485 if(V_VT(ref) != VT_DISPATCH && (disp || V_VT(ref) != VT_UNKNOWN)) {
486 FIXME("not disp %s\n", debugstr_variant(ref));
487 return E_FAIL;
490 V_VT(v) = V_VT(ref);
491 V_UNKNOWN(v) = V_UNKNOWN(ref);
492 if(V_UNKNOWN(v))
493 IUnknown_AddRef(V_UNKNOWN(v));
496 if(disp)
497 *disp = V_DISPATCH(v);
498 return S_OK;
501 static inline void instr_jmp(exec_ctx_t *ctx, unsigned addr)
503 ctx->instr = ctx->code->instrs + addr;
506 static void vbstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, BOOL is_propput, DISPPARAMS *dp)
508 dp->cNamedArgs = is_propput ? 1 : 0;
509 dp->cArgs = arg_cnt + dp->cNamedArgs;
510 dp->rgdispidNamedArgs = is_propput ? &propput_dispid : NULL;
512 if(arg_cnt) {
513 VARIANT tmp;
514 unsigned i;
516 assert(ctx->top >= arg_cnt);
518 for(i=1; i*2 <= arg_cnt; i++) {
519 tmp = ctx->stack[ctx->top-i];
520 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
521 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
524 dp->rgvarg = ctx->stack + ctx->top-dp->cArgs;
525 }else {
526 dp->rgvarg = is_propput ? ctx->stack+ctx->top-1 : NULL;
530 static HRESULT array_access(exec_ctx_t *ctx, SAFEARRAY *array, DISPPARAMS *dp, VARIANT **ret)
532 unsigned i, argc = arg_cnt(dp);
533 LONG *indices;
534 HRESULT hres;
536 if(!array) {
537 FIXME("NULL array\n");
538 return E_FAIL;
541 hres = SafeArrayLock(array);
542 if(FAILED(hres))
543 return hres;
545 if(array->cDims != argc) {
546 FIXME("argc %d does not match cDims %d\n", dp->cArgs, array->cDims);
547 SafeArrayUnlock(array);
548 return E_FAIL;
551 indices = heap_alloc(sizeof(*indices) * argc);
552 if(!indices) {
553 SafeArrayUnlock(array);
554 return E_OUTOFMEMORY;
557 for(i=0; i<argc; i++) {
558 hres = to_int(get_arg(dp, i), indices+i);
559 if(FAILED(hres)) {
560 heap_free(indices);
561 SafeArrayUnlock(array);
562 return hres;
566 hres = SafeArrayPtrOfIndex(array, indices, (void**)ret);
567 SafeArrayUnlock(array);
568 heap_free(indices);
569 return hres;
572 static HRESULT variant_call(exec_ctx_t *ctx, VARIANT *v, unsigned arg_cnt, VARIANT *res)
574 SAFEARRAY *array = NULL;
575 DISPPARAMS dp;
576 HRESULT hres;
578 TRACE("%s\n", debugstr_variant(v));
580 if(V_VT(v) == (VT_VARIANT|VT_BYREF))
581 v = V_VARIANTREF(v);
583 switch(V_VT(v)) {
584 case VT_ARRAY|VT_BYREF|VT_VARIANT:
585 array = *V_ARRAYREF(v);
586 break;
587 case VT_ARRAY|VT_VARIANT:
588 array = V_ARRAY(v);
589 break;
590 case VT_DISPATCH:
591 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
592 hres = disp_call(ctx->script, V_DISPATCH(v), DISPID_VALUE, &dp, res);
593 break;
594 default:
595 FIXME("unsupported on %s\n", debugstr_variant(v));
596 return E_NOTIMPL;
599 if(array) {
600 if(!res) {
601 FIXME("no res\n");
602 return E_NOTIMPL;
605 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
606 hres = array_access(ctx, array, &dp, &v);
607 if(FAILED(hres))
608 return hres;
610 V_VT(res) = VT_BYREF|VT_VARIANT;
611 V_BYREF(res) = v;
614 stack_popn(ctx, arg_cnt);
615 return S_OK;
618 static HRESULT do_icall(exec_ctx_t *ctx, VARIANT *res)
620 BSTR identifier = ctx->instr->arg1.bstr;
621 const unsigned arg_cnt = ctx->instr->arg2.uint;
622 DISPPARAMS dp;
623 ref_t ref;
624 HRESULT hres;
626 TRACE("%s %u\n", debugstr_w(identifier), arg_cnt);
628 hres = lookup_identifier(ctx, identifier, VBDISP_CALLGET, &ref);
629 if(FAILED(hres))
630 return hres;
632 switch(ref.type) {
633 case REF_VAR:
634 case REF_CONST:
635 if(arg_cnt)
636 return variant_call(ctx, ref.u.v, arg_cnt, res);
638 if(!res) {
639 FIXME("REF_VAR no res\n");
640 return E_NOTIMPL;
643 V_VT(res) = VT_BYREF|VT_VARIANT;
644 V_BYREF(res) = V_VT(ref.u.v) == (VT_VARIANT|VT_BYREF) ? V_VARIANTREF(ref.u.v) : ref.u.v;
645 break;
646 case REF_DISP:
647 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
648 hres = disp_call(ctx->script, ref.u.d.disp, ref.u.d.id, &dp, res);
649 if(FAILED(hres))
650 return hres;
651 break;
652 case REF_FUNC:
653 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
654 hres = exec_script(ctx->script, FALSE, ref.u.f, NULL, &dp, res);
655 if(FAILED(hres))
656 return hres;
657 break;
658 case REF_OBJ:
659 if(arg_cnt) {
660 FIXME("arguments on object\n");
661 return E_NOTIMPL;
664 if(res) {
665 IDispatch_AddRef(ref.u.obj);
666 V_VT(res) = VT_DISPATCH;
667 V_DISPATCH(res) = ref.u.obj;
669 break;
670 case REF_NONE:
671 if(res && !ctx->func->code_ctx->option_explicit && arg_cnt == 0) {
672 VARIANT *new;
673 hres = add_dynamic_var(ctx, identifier, FALSE, &new);
674 if(FAILED(hres))
675 return hres;
676 V_VT(res) = VT_BYREF|VT_VARIANT;
677 V_BYREF(res) = new;
678 break;
680 FIXME("%s not found\n", debugstr_w(identifier));
681 return DISP_E_UNKNOWNNAME;
684 stack_popn(ctx, arg_cnt);
685 return S_OK;
688 static HRESULT interp_icall(exec_ctx_t *ctx)
690 VARIANT v;
691 HRESULT hres;
693 TRACE("\n");
695 hres = do_icall(ctx, &v);
696 if(FAILED(hres))
697 return hres;
699 return stack_push(ctx, &v);
702 static HRESULT interp_icallv(exec_ctx_t *ctx)
704 TRACE("\n");
705 return do_icall(ctx, NULL);
708 static HRESULT interp_vcall(exec_ctx_t *ctx)
710 const unsigned arg_cnt = ctx->instr->arg1.uint;
711 VARIANT res, *v;
712 HRESULT hres;
714 TRACE("\n");
716 v = stack_pop(ctx);
717 hres = variant_call(ctx, v, arg_cnt, &res);
718 VariantClear(v);
719 if(FAILED(hres))
720 return hres;
722 return stack_push(ctx, &res);
725 static HRESULT interp_vcallv(exec_ctx_t *ctx)
727 const unsigned arg_cnt = ctx->instr->arg1.uint;
728 VARIANT *v;
729 HRESULT hres;
731 TRACE("\n");
733 v = stack_pop(ctx);
734 hres = variant_call(ctx, v, arg_cnt, NULL);
735 VariantClear(v);
736 return hres;
739 static HRESULT do_mcall(exec_ctx_t *ctx, VARIANT *res)
741 const BSTR identifier = ctx->instr->arg1.bstr;
742 const unsigned arg_cnt = ctx->instr->arg2.uint;
743 IDispatch *obj;
744 DISPPARAMS dp;
745 DISPID id;
746 HRESULT hres;
748 hres = stack_pop_disp(ctx, &obj);
749 if(FAILED(hres))
750 return hres;
752 if(!obj) {
753 FIXME("NULL obj\n");
754 return E_FAIL;
757 vbstack_to_dp(ctx, arg_cnt, FALSE, &dp);
759 hres = disp_get_id(obj, identifier, VBDISP_CALLGET, FALSE, &id);
760 if(SUCCEEDED(hres))
761 hres = disp_call(ctx->script, obj, id, &dp, res);
762 IDispatch_Release(obj);
763 if(FAILED(hres))
764 return hres;
766 stack_popn(ctx, arg_cnt);
767 return S_OK;
770 static HRESULT interp_mcall(exec_ctx_t *ctx)
772 VARIANT res;
773 HRESULT hres;
775 TRACE("\n");
777 hres = do_mcall(ctx, &res);
778 if(FAILED(hres))
779 return hres;
781 return stack_push(ctx, &res);
784 static HRESULT interp_mcallv(exec_ctx_t *ctx)
786 TRACE("\n");
788 return do_mcall(ctx, NULL);
791 static HRESULT assign_value(exec_ctx_t *ctx, VARIANT *dst, VARIANT *src, WORD flags)
793 VARIANT value;
794 HRESULT hres;
796 V_VT(&value) = VT_EMPTY;
797 hres = VariantCopyInd(&value, src);
798 if(FAILED(hres))
799 return hres;
801 if(V_VT(&value) == VT_DISPATCH && !(flags & DISPATCH_PROPERTYPUTREF)) {
802 IDispatch *disp = V_DISPATCH(&value);
804 V_VT(&value) = VT_EMPTY;
805 hres = get_disp_value(ctx->script, disp, &value);
806 if(disp)
807 IDispatch_Release(disp);
808 if(FAILED(hres))
809 return hres;
812 VariantClear(dst);
813 *dst = value;
814 return S_OK;
817 static HRESULT assign_ident(exec_ctx_t *ctx, BSTR name, WORD flags, DISPPARAMS *dp)
819 ref_t ref;
820 HRESULT hres;
822 hres = lookup_identifier(ctx, name, VBDISP_LET, &ref);
823 if(FAILED(hres))
824 return hres;
826 switch(ref.type) {
827 case REF_VAR: {
828 VARIANT *v = ref.u.v;
830 if(V_VT(v) == (VT_VARIANT|VT_BYREF))
831 v = V_VARIANTREF(v);
833 if(arg_cnt(dp)) {
834 SAFEARRAY *array;
836 if(V_VT(v) == VT_DISPATCH) {
837 hres = disp_propput(ctx->script, V_DISPATCH(v), DISPID_VALUE, flags, dp);
838 break;
841 if(!(V_VT(v) & VT_ARRAY)) {
842 FIXME("array assign on type %d\n", V_VT(v));
843 return E_FAIL;
846 switch(V_VT(v)) {
847 case VT_ARRAY|VT_BYREF|VT_VARIANT:
848 array = *V_ARRAYREF(v);
849 break;
850 case VT_ARRAY|VT_VARIANT:
851 array = V_ARRAY(v);
852 break;
853 default:
854 FIXME("Unsupported array type %x\n", V_VT(v));
855 return E_NOTIMPL;
858 if(!array) {
859 FIXME("null array\n");
860 return E_FAIL;
863 hres = array_access(ctx, array, dp, &v);
864 if(FAILED(hres))
865 return hres;
866 }else if(V_VT(v) == (VT_ARRAY|VT_BYREF|VT_VARIANT)) {
867 FIXME("non-array assign\n");
868 return E_NOTIMPL;
871 hres = assign_value(ctx, v, dp->rgvarg, flags);
872 break;
874 case REF_DISP:
875 hres = disp_propput(ctx->script, ref.u.d.disp, ref.u.d.id, flags, dp);
876 break;
877 case REF_FUNC:
878 FIXME("functions not implemented\n");
879 return E_NOTIMPL;
880 case REF_OBJ:
881 FIXME("REF_OBJ\n");
882 return E_NOTIMPL;
883 case REF_CONST:
884 FIXME("REF_CONST\n");
885 return E_NOTIMPL;
886 case REF_NONE:
887 if(ctx->func->code_ctx->option_explicit) {
888 FIXME("throw exception\n");
889 hres = E_FAIL;
890 }else {
891 VARIANT *new_var;
893 if(arg_cnt(dp)) {
894 FIXME("arg_cnt %d not supported\n", arg_cnt(dp));
895 return E_NOTIMPL;
898 TRACE("creating variable %s\n", debugstr_w(name));
899 hres = add_dynamic_var(ctx, name, FALSE, &new_var);
900 if(SUCCEEDED(hres))
901 hres = assign_value(ctx, new_var, dp->rgvarg, flags);
905 return hres;
908 static HRESULT interp_assign_ident(exec_ctx_t *ctx)
910 const BSTR arg = ctx->instr->arg1.bstr;
911 const unsigned arg_cnt = ctx->instr->arg2.uint;
912 DISPPARAMS dp;
913 HRESULT hres;
915 TRACE("%s\n", debugstr_w(arg));
917 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
918 hres = assign_ident(ctx, arg, DISPATCH_PROPERTYPUT, &dp);
919 if(FAILED(hres))
920 return hres;
922 stack_popn(ctx, arg_cnt+1);
923 return S_OK;
926 static HRESULT interp_set_ident(exec_ctx_t *ctx)
928 const BSTR arg = ctx->instr->arg1.bstr;
929 const unsigned arg_cnt = ctx->instr->arg2.uint;
930 DISPPARAMS dp;
931 HRESULT hres;
933 TRACE("%s %u\n", debugstr_w(arg), arg_cnt);
935 hres = stack_assume_disp(ctx, arg_cnt, NULL);
936 if(FAILED(hres))
937 return hres;
939 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
940 hres = assign_ident(ctx, arg, DISPATCH_PROPERTYPUTREF, &dp);
941 if(FAILED(hres))
942 return hres;
944 stack_popn(ctx, arg_cnt + 1);
945 return S_OK;
948 static HRESULT interp_assign_member(exec_ctx_t *ctx)
950 BSTR identifier = ctx->instr->arg1.bstr;
951 const unsigned arg_cnt = ctx->instr->arg2.uint;
952 IDispatch *obj;
953 DISPPARAMS dp;
954 DISPID id;
955 HRESULT hres;
957 TRACE("%s\n", debugstr_w(identifier));
959 hres = stack_assume_disp(ctx, arg_cnt+1, &obj);
960 if(FAILED(hres))
961 return hres;
963 if(!obj) {
964 FIXME("NULL obj\n");
965 return E_FAIL;
968 hres = disp_get_id(obj, identifier, VBDISP_LET, FALSE, &id);
969 if(SUCCEEDED(hres)) {
970 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
971 hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUT, &dp);
973 if(FAILED(hres))
974 return hres;
976 stack_popn(ctx, arg_cnt+2);
977 return S_OK;
980 static HRESULT interp_set_member(exec_ctx_t *ctx)
982 BSTR identifier = ctx->instr->arg1.bstr;
983 const unsigned arg_cnt = ctx->instr->arg2.uint;
984 IDispatch *obj;
985 DISPPARAMS dp;
986 DISPID id;
987 HRESULT hres;
989 TRACE("%s\n", debugstr_w(identifier));
991 hres = stack_assume_disp(ctx, arg_cnt+1, &obj);
992 if(FAILED(hres))
993 return hres;
995 if(!obj) {
996 FIXME("NULL obj\n");
997 return E_FAIL;
1000 hres = stack_assume_disp(ctx, arg_cnt, NULL);
1001 if(FAILED(hres))
1002 return hres;
1004 hres = disp_get_id(obj, identifier, VBDISP_SET, FALSE, &id);
1005 if(SUCCEEDED(hres)) {
1006 vbstack_to_dp(ctx, arg_cnt, TRUE, &dp);
1007 hres = disp_propput(ctx->script, obj, id, DISPATCH_PROPERTYPUTREF, &dp);
1009 if(FAILED(hres))
1010 return hres;
1012 stack_popn(ctx, arg_cnt+2);
1013 return S_OK;
1016 static HRESULT interp_const(exec_ctx_t *ctx)
1018 BSTR arg = ctx->instr->arg1.bstr;
1019 VARIANT *v;
1020 ref_t ref;
1021 HRESULT hres;
1023 TRACE("%s\n", debugstr_w(arg));
1025 assert(ctx->func->type == FUNC_GLOBAL);
1027 hres = lookup_identifier(ctx, arg, VBDISP_CALLGET, &ref);
1028 if(FAILED(hres))
1029 return hres;
1031 if(ref.type != REF_NONE) {
1032 FIXME("%s already defined\n", debugstr_w(arg));
1033 return E_FAIL;
1036 hres = stack_assume_val(ctx, 0);
1037 if(FAILED(hres))
1038 return hres;
1040 hres = add_dynamic_var(ctx, arg, TRUE, &v);
1041 if(FAILED(hres))
1042 return hres;
1044 *v = *stack_pop(ctx);
1045 return S_OK;
1048 static HRESULT interp_val(exec_ctx_t *ctx)
1050 variant_val_t val;
1051 VARIANT v;
1052 HRESULT hres;
1054 TRACE("\n");
1056 hres = stack_pop_val(ctx, &val);
1057 if(FAILED(hres))
1058 return hres;
1060 if(!val.owned) {
1061 V_VT(&v) = VT_EMPTY;
1062 hres = VariantCopy(&v, val.v);
1063 if(FAILED(hres))
1064 return hres;
1067 return stack_push(ctx, val.owned ? val.v : &v);
1070 static HRESULT interp_pop(exec_ctx_t *ctx)
1072 const unsigned n = ctx->instr->arg1.uint;
1074 TRACE("%u\n", n);
1076 stack_popn(ctx, n);
1077 return S_OK;
1080 static HRESULT interp_stack(exec_ctx_t *ctx)
1082 const unsigned n = ctx->instr->arg1.uint;
1083 VARIANT v;
1084 HRESULT hres;
1086 TRACE("%#x\n", n);
1088 if(n == ~0)
1089 return MAKE_VBSERROR(505);
1090 assert(n < ctx->top);
1092 V_VT(&v) = VT_EMPTY;
1093 hres = VariantCopy(&v, ctx->stack + n);
1094 if(FAILED(hres))
1095 return hres;
1097 return stack_push(ctx, &v);
1100 static HRESULT interp_deref(exec_ctx_t *ctx)
1102 VARIANT copy, *v = stack_top(ctx, 0);
1103 HRESULT hres;
1105 TRACE("%s\n", debugstr_variant(v));
1107 if(V_VT(v) != (VT_BYREF|VT_VARIANT))
1108 return S_OK;
1110 V_VT(&copy) = VT_EMPTY;
1111 hres = VariantCopy(&copy, V_VARIANTREF(v));
1112 if(SUCCEEDED(hres))
1113 *v = copy;
1114 return hres;
1117 static HRESULT interp_new(exec_ctx_t *ctx)
1119 const WCHAR *arg = ctx->instr->arg1.bstr;
1120 class_desc_t *class_desc = NULL;
1121 vbdisp_t *obj;
1122 VARIANT v;
1123 HRESULT hres;
1125 TRACE("%s\n", debugstr_w(arg));
1127 if(!wcsicmp(arg, L"regexp")) {
1128 V_VT(&v) = VT_DISPATCH;
1129 hres = create_regexp(&V_DISPATCH(&v));
1130 if(FAILED(hres))
1131 return hres;
1133 return stack_push(ctx, &v);
1136 if(ctx->code->named_item)
1137 for(class_desc = ctx->code->named_item->script_obj->classes; class_desc; class_desc = class_desc->next)
1138 if(!wcsicmp(class_desc->name, arg))
1139 break;
1140 if(!class_desc)
1141 for(class_desc = ctx->script->script_obj->classes; class_desc; class_desc = class_desc->next)
1142 if(!wcsicmp(class_desc->name, arg))
1143 break;
1144 if(!class_desc) {
1145 FIXME("Class %s not found\n", debugstr_w(arg));
1146 return E_FAIL;
1149 hres = create_vbdisp(class_desc, &obj);
1150 if(FAILED(hres))
1151 return hres;
1153 V_VT(&v) = VT_DISPATCH;
1154 V_DISPATCH(&v) = (IDispatch*)&obj->IDispatchEx_iface;
1155 return stack_push(ctx, &v);
1158 static HRESULT interp_dim(exec_ctx_t *ctx)
1160 ScriptDisp *script_obj = ctx->code->named_item ? ctx->code->named_item->script_obj : ctx->script->script_obj;
1161 const BSTR ident = ctx->instr->arg1.bstr;
1162 const unsigned array_id = ctx->instr->arg2.uint;
1163 const array_desc_t *array_desc;
1164 SAFEARRAY **array_ref;
1165 VARIANT *v;
1166 HRESULT hres;
1168 TRACE("%s\n", debugstr_w(ident));
1170 assert(array_id < ctx->func->array_cnt);
1172 if(ctx->func->type == FUNC_GLOBAL) {
1173 unsigned i;
1174 for(i = 0; i < script_obj->global_vars_cnt; i++) {
1175 if(!wcsicmp(script_obj->global_vars[i]->name, ident))
1176 break;
1178 assert(i < script_obj->global_vars_cnt);
1179 v = &script_obj->global_vars[i]->v;
1180 array_ref = &script_obj->global_vars[i]->array;
1181 }else {
1182 ref_t ref;
1184 if(!ctx->arrays) {
1185 ctx->arrays = heap_alloc_zero(ctx->func->array_cnt * sizeof(SAFEARRAY*));
1186 if(!ctx->arrays)
1187 return E_OUTOFMEMORY;
1190 hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
1191 if(FAILED(hres)) {
1192 FIXME("lookup %s failed: %08x\n", debugstr_w(ident), hres);
1193 return hres;
1196 if(ref.type != REF_VAR) {
1197 FIXME("got ref.type = %d\n", ref.type);
1198 return E_FAIL;
1201 v = ref.u.v;
1202 array_ref = ctx->arrays + array_id;
1205 if(*array_ref) {
1206 FIXME("Array already initialized\n");
1207 return E_FAIL;
1210 array_desc = ctx->func->array_descs + array_id;
1211 if(array_desc->dim_cnt) {
1212 *array_ref = SafeArrayCreate(VT_VARIANT, array_desc->dim_cnt, array_desc->bounds);
1213 if(!*array_ref)
1214 return E_OUTOFMEMORY;
1217 V_VT(v) = VT_ARRAY|VT_BYREF|VT_VARIANT;
1218 V_ARRAYREF(v) = array_ref;
1219 return S_OK;
1222 static HRESULT array_bounds_from_stack(exec_ctx_t *ctx, unsigned dim_cnt, SAFEARRAYBOUND **ret)
1224 SAFEARRAYBOUND *bounds;
1225 unsigned i;
1226 int dim;
1227 HRESULT hres;
1229 if(!(bounds = heap_alloc(dim_cnt * sizeof(*bounds))))
1230 return E_OUTOFMEMORY;
1232 for(i = 0; i < dim_cnt; i++) {
1233 hres = to_int(stack_top(ctx, dim_cnt - i - 1), &dim);
1234 if(FAILED(hres)) {
1235 heap_free(bounds);
1236 return hres;
1239 bounds[i].cElements = dim + 1;
1240 bounds[i].lLbound = 0;
1243 stack_popn(ctx, dim_cnt);
1244 *ret = bounds;
1245 return S_OK;
1248 static HRESULT interp_redim(exec_ctx_t *ctx)
1250 BSTR identifier = ctx->instr->arg1.bstr;
1251 const unsigned dim_cnt = ctx->instr->arg2.uint;
1252 SAFEARRAYBOUND *bounds;
1253 SAFEARRAY *array;
1254 ref_t ref;
1255 HRESULT hres;
1257 TRACE("%s %u\n", debugstr_w(identifier), dim_cnt);
1259 hres = lookup_identifier(ctx, identifier, VBDISP_LET, &ref);
1260 if(FAILED(hres)) {
1261 FIXME("lookup %s failed: %08x\n", debugstr_w(identifier), hres);
1262 return hres;
1265 if(ref.type != REF_VAR) {
1266 FIXME("got ref.type = %d\n", ref.type);
1267 return E_FAIL;
1270 hres = array_bounds_from_stack(ctx, dim_cnt, &bounds);
1271 if(FAILED(hres))
1272 return hres;
1274 array = SafeArrayCreate(VT_VARIANT, dim_cnt, bounds);
1275 heap_free(bounds);
1276 if(!array)
1277 return E_OUTOFMEMORY;
1279 /* FIXME: We should check if we're not modifying an existing static array here */
1281 VariantClear(ref.u.v);
1282 V_VT(ref.u.v) = VT_ARRAY|VT_VARIANT;
1283 V_ARRAY(ref.u.v) = array;
1284 return S_OK;
1287 static HRESULT interp_redim_preserve(exec_ctx_t *ctx)
1289 BSTR identifier = ctx->instr->arg1.bstr;
1290 const unsigned dim_cnt = ctx->instr->arg2.uint;
1291 unsigned i;
1292 SAFEARRAYBOUND *bounds;
1293 SAFEARRAY *array;
1294 ref_t ref;
1295 HRESULT hres;
1297 TRACE("%s %u\n", debugstr_w(identifier), dim_cnt);
1299 hres = lookup_identifier(ctx, identifier, VBDISP_LET, &ref);
1300 if(FAILED(hres)) {
1301 FIXME("lookup %s failed: %08x\n", debugstr_w(identifier), hres);
1302 return hres;
1305 if(ref.type != REF_VAR) {
1306 FIXME("got ref.type = %d\n", ref.type);
1307 return E_FAIL;
1310 if(!(V_VT(ref.u.v) & VT_ARRAY)) {
1311 FIXME("ReDim Preserve not valid on type %d\n", V_VT(ref.u.v));
1312 return E_FAIL;
1315 array = V_ARRAY(ref.u.v);
1317 hres = array_bounds_from_stack(ctx, dim_cnt, &bounds);
1318 if(FAILED(hres))
1319 return hres;
1321 if(array == NULL || array->cDims == 0) {
1322 /* can initially allocate the array */
1323 array = SafeArrayCreate(VT_VARIANT, dim_cnt, bounds);
1324 VariantClear(ref.u.v);
1325 V_VT(ref.u.v) = VT_ARRAY|VT_VARIANT;
1326 V_ARRAY(ref.u.v) = array;
1327 return S_OK;
1328 } else if(array->cDims != dim_cnt) {
1329 /* can't otherwise change the number of dimensions */
1330 TRACE("Can't resize %s, cDims %d != %d\n", debugstr_w(identifier), array->cDims, dim_cnt);
1331 return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1332 } else {
1333 /* can resize the last dimensions (if others match */
1334 for(i = 0; i+1 < dim_cnt; ++i) {
1335 if(array->rgsabound[array->cDims - 1 - i].cElements != bounds[i].cElements) {
1336 TRACE("Can't resize %s, bound[%d] %d != %d\n", debugstr_w(identifier), i, array->rgsabound[i].cElements, bounds[i].cElements);
1337 return MAKE_VBSERROR(VBSE_OUT_OF_BOUNDS);
1340 return SafeArrayRedim(array, &bounds[dim_cnt-1]);
1344 static HRESULT interp_step(exec_ctx_t *ctx)
1346 const BSTR ident = ctx->instr->arg2.bstr;
1347 BOOL gteq_zero;
1348 VARIANT zero;
1349 ref_t ref;
1350 HRESULT hres;
1352 TRACE("%s\n", debugstr_w(ident));
1354 V_VT(&zero) = VT_I2;
1355 V_I2(&zero) = 0;
1356 hres = VarCmp(stack_top(ctx, 0), &zero, ctx->script->lcid, 0);
1357 if(FAILED(hres))
1358 return hres;
1360 gteq_zero = hres == VARCMP_GT || hres == VARCMP_EQ;
1362 hres = lookup_identifier(ctx, ident, VBDISP_ANY, &ref);
1363 if(FAILED(hres))
1364 return hres;
1366 if(ref.type != REF_VAR) {
1367 FIXME("%s is not REF_VAR\n", debugstr_w(ident));
1368 return E_FAIL;
1371 hres = VarCmp(ref.u.v, stack_top(ctx, 1), ctx->script->lcid, 0);
1372 if(FAILED(hres))
1373 return hres;
1375 if(hres == VARCMP_EQ || hres == (gteq_zero ? VARCMP_LT : VARCMP_GT)) {
1376 ctx->instr++;
1377 }else {
1378 stack_popn(ctx, 2);
1379 instr_jmp(ctx, ctx->instr->arg1.uint);
1381 return S_OK;
1384 static HRESULT interp_newenum(exec_ctx_t *ctx)
1386 variant_val_t v;
1387 VARIANT *r;
1388 HRESULT hres;
1390 TRACE("\n");
1392 stack_pop_deref(ctx, &v);
1393 assert(V_VT(stack_top(ctx, 0)) == VT_EMPTY);
1394 r = stack_top(ctx, 0);
1396 switch(V_VT(v.v)) {
1397 case VT_DISPATCH|VT_BYREF:
1398 case VT_DISPATCH: {
1399 IEnumVARIANT *iter;
1400 DISPPARAMS dp = {0};
1401 VARIANT iterv;
1403 hres = disp_call(ctx->script, V_ISBYREF(v.v) ? *V_DISPATCHREF(v.v) : V_DISPATCH(v.v), DISPID_NEWENUM, &dp, &iterv);
1404 release_val(&v);
1405 if(FAILED(hres))
1406 return hres;
1408 if(V_VT(&iterv) != VT_UNKNOWN && V_VT(&iterv) != VT_DISPATCH) {
1409 FIXME("Unsupported iterv %s\n", debugstr_variant(&iterv));
1410 VariantClear(&iterv);
1411 return hres;
1414 hres = IUnknown_QueryInterface(V_UNKNOWN(&iterv), &IID_IEnumVARIANT, (void**)&iter);
1415 IUnknown_Release(V_UNKNOWN(&iterv));
1416 if(FAILED(hres)) {
1417 FIXME("Could not get IEnumVARIANT iface: %08x\n", hres);
1418 return hres;
1421 V_VT(r) = VT_UNKNOWN;
1422 V_UNKNOWN(r) = (IUnknown*)iter;
1423 break;
1425 case VT_VARIANT|VT_ARRAY:
1426 case VT_VARIANT|VT_ARRAY|VT_BYREF: {
1427 IEnumVARIANT *iter;
1429 hres = create_safearray_iter(V_ISBYREF(v.v) ? *V_ARRAYREF(v.v) : V_ARRAY(v.v), &iter);
1430 if(FAILED(hres))
1431 return hres;
1433 V_VT(r) = VT_UNKNOWN;
1434 V_UNKNOWN(r) = (IUnknown*)iter;
1435 break;
1437 default:
1438 FIXME("Unsupported for %s\n", debugstr_variant(v.v));
1439 release_val(&v);
1440 return E_NOTIMPL;
1443 return S_OK;
1446 static HRESULT interp_enumnext(exec_ctx_t *ctx)
1448 const unsigned loop_end = ctx->instr->arg1.uint;
1449 const BSTR ident = ctx->instr->arg2.bstr;
1450 VARIANT v;
1451 DISPPARAMS dp = {&v, &propput_dispid, 1, 1};
1452 IEnumVARIANT *iter;
1453 BOOL do_continue;
1454 HRESULT hres;
1456 TRACE("\n");
1458 if(V_VT(stack_top(ctx, 0)) == VT_EMPTY) {
1459 FIXME("uninitialized\n");
1460 return E_FAIL;
1463 assert(V_VT(stack_top(ctx, 0)) == VT_UNKNOWN);
1464 iter = (IEnumVARIANT*)V_UNKNOWN(stack_top(ctx, 0));
1466 V_VT(&v) = VT_EMPTY;
1467 hres = IEnumVARIANT_Next(iter, 1, &v, NULL);
1468 if(FAILED(hres))
1469 return hres;
1471 do_continue = hres == S_OK;
1472 hres = assign_ident(ctx, ident, DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &dp);
1473 VariantClear(&v);
1474 if(FAILED(hres))
1475 return hres;
1477 if(do_continue) {
1478 ctx->instr++;
1479 }else {
1480 stack_popn(ctx, 1);
1481 instr_jmp(ctx, loop_end);
1483 return S_OK;
1486 static HRESULT interp_jmp(exec_ctx_t *ctx)
1488 const unsigned arg = ctx->instr->arg1.uint;
1490 TRACE("%u\n", arg);
1492 instr_jmp(ctx, arg);
1493 return S_OK;
1496 static HRESULT interp_jmp_false(exec_ctx_t *ctx)
1498 const unsigned arg = ctx->instr->arg1.uint;
1499 HRESULT hres;
1500 BOOL b;
1502 TRACE("%u\n", arg);
1504 hres = stack_pop_bool(ctx, &b);
1505 if(FAILED(hres))
1506 return hres;
1508 if(b)
1509 ctx->instr++;
1510 else
1511 instr_jmp(ctx, ctx->instr->arg1.uint);
1512 return S_OK;
1515 static HRESULT interp_jmp_true(exec_ctx_t *ctx)
1517 const unsigned arg = ctx->instr->arg1.uint;
1518 HRESULT hres;
1519 BOOL b;
1521 TRACE("%u\n", arg);
1523 hres = stack_pop_bool(ctx, &b);
1524 if(FAILED(hres))
1525 return hres;
1527 if(b)
1528 instr_jmp(ctx, ctx->instr->arg1.uint);
1529 else
1530 ctx->instr++;
1531 return S_OK;
1534 static HRESULT interp_ret(exec_ctx_t *ctx)
1536 TRACE("\n");
1538 ctx->instr = NULL;
1539 return S_OK;
1542 static HRESULT interp_retval(exec_ctx_t *ctx)
1544 variant_val_t val;
1545 HRESULT hres;
1547 TRACE("\n");
1549 stack_pop_deref(ctx, &val);
1551 if(val.owned) {
1552 VariantClear(&ctx->ret_val);
1553 ctx->ret_val = *val.v;
1555 else {
1556 hres = VariantCopy(&ctx->ret_val, val.v);
1557 if(FAILED(hres))
1558 return hres;
1561 return S_OK;
1564 static HRESULT interp_stop(exec_ctx_t *ctx)
1566 WARN("\n");
1568 /* NOTE: this should have effect in debugging mode (that we don't support yet) */
1569 return S_OK;
1572 static HRESULT interp_me(exec_ctx_t *ctx)
1574 IDispatch *disp;
1575 VARIANT v;
1577 TRACE("\n");
1579 if(ctx->vbthis) {
1580 disp = (IDispatch*)&ctx->vbthis->IDispatchEx_iface;
1581 }else if(ctx->code->named_item) {
1582 disp = (ctx->code->named_item->flags & SCRIPTITEM_CODEONLY)
1583 ? (IDispatch*)&ctx->code->named_item->script_obj->IDispatchEx_iface
1584 : ctx->code->named_item->disp;
1585 }else {
1586 named_item_t *item;
1587 disp = NULL;
1588 LIST_FOR_EACH_ENTRY(item, &ctx->script->named_items, named_item_t, entry) {
1589 if(!(item->flags & SCRIPTITEM_GLOBALMEMBERS)) continue;
1590 disp = item->disp;
1591 break;
1593 if(!disp)
1594 disp = (IDispatch*)&ctx->script->script_obj->IDispatchEx_iface;
1597 IDispatch_AddRef(disp);
1598 V_VT(&v) = VT_DISPATCH;
1599 V_DISPATCH(&v) = disp;
1600 return stack_push(ctx, &v);
1603 static HRESULT interp_bool(exec_ctx_t *ctx)
1605 const VARIANT_BOOL arg = ctx->instr->arg1.lng;
1606 VARIANT v;
1608 TRACE("%s\n", arg ? "true" : "false");
1610 V_VT(&v) = VT_BOOL;
1611 V_BOOL(&v) = arg;
1612 return stack_push(ctx, &v);
1615 static HRESULT interp_errmode(exec_ctx_t *ctx)
1617 const int err_mode = ctx->instr->arg1.uint;
1619 TRACE("%d\n", err_mode);
1621 ctx->resume_next = err_mode;
1622 clear_ei(&ctx->script->ei);
1623 return S_OK;
1626 static HRESULT interp_string(exec_ctx_t *ctx)
1628 VARIANT v;
1630 TRACE("\n");
1632 V_VT(&v) = VT_BSTR;
1633 V_BSTR(&v) = SysAllocString(ctx->instr->arg1.str);
1634 if(!V_BSTR(&v))
1635 return E_OUTOFMEMORY;
1637 return stack_push(ctx, &v);
1640 static HRESULT interp_int(exec_ctx_t *ctx)
1642 const LONG arg = ctx->instr->arg1.lng;
1643 VARIANT v;
1645 TRACE("%d\n", arg);
1647 if(arg == (INT16)arg) {
1648 V_VT(&v) = VT_I2;
1649 V_I2(&v) = arg;
1650 }else {
1651 V_VT(&v) = VT_I4;
1652 V_I4(&v) = arg;
1654 return stack_push(ctx, &v);
1657 static HRESULT interp_double(exec_ctx_t *ctx)
1659 const DOUBLE *arg = ctx->instr->arg1.dbl;
1660 VARIANT v;
1662 TRACE("%lf\n", *arg);
1664 V_VT(&v) = VT_R8;
1665 V_R8(&v) = *arg;
1666 return stack_push(ctx, &v);
1669 static HRESULT interp_empty(exec_ctx_t *ctx)
1671 VARIANT v;
1673 TRACE("\n");
1675 V_VT(&v) = VT_EMPTY;
1676 return stack_push(ctx, &v);
1679 static HRESULT interp_null(exec_ctx_t *ctx)
1681 TRACE("\n");
1682 return stack_push_null(ctx);
1685 static HRESULT interp_nothing(exec_ctx_t *ctx)
1687 VARIANT v;
1689 TRACE("\n");
1691 V_VT(&v) = VT_DISPATCH;
1692 V_DISPATCH(&v) = NULL;
1693 return stack_push(ctx, &v);
1696 static HRESULT interp_hres(exec_ctx_t *ctx)
1698 const unsigned arg = ctx->instr->arg1.uint;
1699 VARIANT v;
1701 TRACE("%d\n", arg);
1703 V_VT(&v) = VT_ERROR;
1704 V_ERROR(&v) = arg;
1705 return stack_push(ctx, &v);
1708 static HRESULT interp_not(exec_ctx_t *ctx)
1710 variant_val_t val;
1711 VARIANT v;
1712 HRESULT hres;
1714 TRACE("\n");
1716 hres = stack_pop_val(ctx, &val);
1717 if(FAILED(hres))
1718 return hres;
1720 hres = VarNot(val.v, &v);
1721 release_val(&val);
1722 if(FAILED(hres))
1723 return hres;
1725 return stack_push(ctx, &v);
1728 static HRESULT interp_and(exec_ctx_t *ctx)
1730 variant_val_t r, l;
1731 VARIANT v;
1732 HRESULT hres;
1734 TRACE("\n");
1736 hres = stack_pop_val(ctx, &r);
1737 if(FAILED(hres))
1738 return hres;
1740 hres = stack_pop_val(ctx, &l);
1741 if(SUCCEEDED(hres)) {
1742 hres = VarAnd(l.v, r.v, &v);
1743 release_val(&l);
1745 release_val(&r);
1746 if(FAILED(hres))
1747 return hres;
1749 return stack_push(ctx, &v);
1752 static HRESULT interp_or(exec_ctx_t *ctx)
1754 variant_val_t r, l;
1755 VARIANT v;
1756 HRESULT hres;
1758 TRACE("\n");
1760 hres = stack_pop_val(ctx, &r);
1761 if(FAILED(hres))
1762 return hres;
1764 hres = stack_pop_val(ctx, &l);
1765 if(SUCCEEDED(hres)) {
1766 hres = VarOr(l.v, r.v, &v);
1767 release_val(&l);
1769 release_val(&r);
1770 if(FAILED(hres))
1771 return hres;
1773 return stack_push(ctx, &v);
1776 static HRESULT interp_xor(exec_ctx_t *ctx)
1778 variant_val_t r, l;
1779 VARIANT v;
1780 HRESULT hres;
1782 TRACE("\n");
1784 hres = stack_pop_val(ctx, &r);
1785 if(FAILED(hres))
1786 return hres;
1788 hres = stack_pop_val(ctx, &l);
1789 if(SUCCEEDED(hres)) {
1790 hres = VarXor(l.v, r.v, &v);
1791 release_val(&l);
1793 release_val(&r);
1794 if(FAILED(hres))
1795 return hres;
1797 return stack_push(ctx, &v);
1800 static HRESULT interp_eqv(exec_ctx_t *ctx)
1802 variant_val_t r, l;
1803 VARIANT v;
1804 HRESULT hres;
1806 TRACE("\n");
1808 hres = stack_pop_val(ctx, &r);
1809 if(FAILED(hres))
1810 return hres;
1812 hres = stack_pop_val(ctx, &l);
1813 if(SUCCEEDED(hres)) {
1814 hres = VarEqv(l.v, r.v, &v);
1815 release_val(&l);
1817 release_val(&r);
1818 if(FAILED(hres))
1819 return hres;
1821 return stack_push(ctx, &v);
1824 static HRESULT interp_imp(exec_ctx_t *ctx)
1826 variant_val_t r, l;
1827 VARIANT v;
1828 HRESULT hres;
1830 TRACE("\n");
1832 hres = stack_pop_val(ctx, &r);
1833 if(FAILED(hres))
1834 return hres;
1836 hres = stack_pop_val(ctx, &l);
1837 if(SUCCEEDED(hres)) {
1838 hres = VarImp(l.v, r.v, &v);
1839 release_val(&l);
1841 release_val(&r);
1842 if(FAILED(hres))
1843 return hres;
1845 return stack_push(ctx, &v);
1848 static HRESULT var_cmp(exec_ctx_t *ctx, VARIANT *l, VARIANT *r)
1850 TRACE("%s %s\n", debugstr_variant(l), debugstr_variant(r));
1852 /* FIXME: Fix comparing string to number */
1854 return VarCmp(l, r, ctx->script->lcid, 0);
1857 static HRESULT cmp_oper(exec_ctx_t *ctx)
1859 variant_val_t l, r;
1860 HRESULT hres;
1862 hres = stack_pop_val(ctx, &r);
1863 if(FAILED(hres))
1864 return hres;
1866 hres = stack_pop_val(ctx, &l);
1867 if(SUCCEEDED(hres)) {
1868 hres = var_cmp(ctx, l.v, r.v);
1869 release_val(&l);
1872 release_val(&r);
1873 return hres;
1876 static HRESULT interp_equal(exec_ctx_t *ctx)
1878 VARIANT v;
1879 HRESULT hres;
1881 TRACE("\n");
1883 hres = cmp_oper(ctx);
1884 if(FAILED(hres))
1885 return hres;
1886 if(hres == VARCMP_NULL)
1887 return stack_push_null(ctx);
1889 V_VT(&v) = VT_BOOL;
1890 V_BOOL(&v) = hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1891 return stack_push(ctx, &v);
1894 static HRESULT interp_nequal(exec_ctx_t *ctx)
1896 VARIANT v;
1897 HRESULT hres;
1899 TRACE("\n");
1901 hres = cmp_oper(ctx);
1902 if(FAILED(hres))
1903 return hres;
1904 if(hres == VARCMP_NULL)
1905 return stack_push_null(ctx);
1907 V_VT(&v) = VT_BOOL;
1908 V_BOOL(&v) = hres != VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1909 return stack_push(ctx, &v);
1912 static HRESULT interp_gt(exec_ctx_t *ctx)
1914 VARIANT v;
1915 HRESULT hres;
1917 TRACE("\n");
1919 hres = cmp_oper(ctx);
1920 if(FAILED(hres))
1921 return hres;
1922 if(hres == VARCMP_NULL)
1923 return stack_push_null(ctx);
1925 V_VT(&v) = VT_BOOL;
1926 V_BOOL(&v) = hres == VARCMP_GT ? VARIANT_TRUE : VARIANT_FALSE;
1927 return stack_push(ctx, &v);
1930 static HRESULT interp_gteq(exec_ctx_t *ctx)
1932 VARIANT v;
1933 HRESULT hres;
1935 TRACE("\n");
1937 hres = cmp_oper(ctx);
1938 if(FAILED(hres))
1939 return hres;
1940 if(hres == VARCMP_NULL)
1941 return stack_push_null(ctx);
1943 V_VT(&v) = VT_BOOL;
1944 V_BOOL(&v) = hres == VARCMP_GT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1945 return stack_push(ctx, &v);
1948 static HRESULT interp_lt(exec_ctx_t *ctx)
1950 VARIANT v;
1951 HRESULT hres;
1953 TRACE("\n");
1955 hres = cmp_oper(ctx);
1956 if(FAILED(hres))
1957 return hres;
1958 if(hres == VARCMP_NULL)
1959 return stack_push_null(ctx);
1961 V_VT(&v) = VT_BOOL;
1962 V_BOOL(&v) = hres == VARCMP_LT ? VARIANT_TRUE : VARIANT_FALSE;
1963 return stack_push(ctx, &v);
1966 static HRESULT interp_lteq(exec_ctx_t *ctx)
1968 VARIANT v;
1969 HRESULT hres;
1971 TRACE("\n");
1973 hres = cmp_oper(ctx);
1974 if(FAILED(hres))
1975 return hres;
1976 if(hres == VARCMP_NULL)
1977 return stack_push_null(ctx);
1979 V_VT(&v) = VT_BOOL;
1980 V_BOOL(&v) = hres == VARCMP_LT || hres == VARCMP_EQ ? VARIANT_TRUE : VARIANT_FALSE;
1981 return stack_push(ctx, &v);
1984 static HRESULT interp_case(exec_ctx_t *ctx)
1986 const unsigned arg = ctx->instr->arg1.uint;
1987 variant_val_t v;
1988 HRESULT hres;
1990 TRACE("%d\n", arg);
1992 hres = stack_pop_val(ctx, &v);
1993 if(FAILED(hres))
1994 return hres;
1996 hres = var_cmp(ctx, stack_top(ctx, 0), v.v);
1997 release_val(&v);
1998 if(FAILED(hres))
1999 return hres;
2001 if(hres == VARCMP_EQ) {
2002 stack_popn(ctx, 1);
2003 instr_jmp(ctx, arg);
2004 }else {
2005 ctx->instr++;
2008 return S_OK;
2011 static HRESULT interp_is(exec_ctx_t *ctx)
2013 IUnknown *l = NULL, *r = NULL;
2014 variant_val_t v;
2015 HRESULT hres = S_OK;
2017 TRACE("\n");
2019 stack_pop_deref(ctx, &v);
2020 if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
2021 FIXME("Unhandled type %s\n", debugstr_variant(v.v));
2022 hres = E_NOTIMPL;
2023 }else if(V_UNKNOWN(v.v)) {
2024 hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&r);
2026 if(v.owned) VariantClear(v.v);
2027 if(FAILED(hres))
2028 return hres;
2030 stack_pop_deref(ctx, &v);
2031 if(V_VT(v.v) != VT_DISPATCH && V_VT(v.v) != VT_UNKNOWN) {
2032 FIXME("Unhandled type %s\n", debugstr_variant(v.v));
2033 hres = E_NOTIMPL;
2034 }else if(V_UNKNOWN(v.v)) {
2035 hres = IUnknown_QueryInterface(V_UNKNOWN(v.v), &IID_IUnknown, (void**)&l);
2037 if(v.owned) VariantClear(v.v);
2039 if(SUCCEEDED(hres)) {
2040 VARIANT res;
2041 V_VT(&res) = VT_BOOL;
2042 if(r == l)
2043 V_BOOL(&res) = VARIANT_TRUE;
2044 else if(!r || !l)
2045 V_BOOL(&res) = VARIANT_FALSE;
2046 else {
2047 IObjectIdentity *identity;
2048 hres = IUnknown_QueryInterface(l, &IID_IObjectIdentity, (void**)&identity);
2049 if(SUCCEEDED(hres)) {
2050 hres = IObjectIdentity_IsEqualObject(identity, r);
2051 IObjectIdentity_Release(identity);
2053 V_BOOL(&res) = hres == S_OK ? VARIANT_TRUE : VARIANT_FALSE;
2055 hres = stack_push(ctx, &res);
2057 if(r)
2058 IUnknown_Release(r);
2059 if(l)
2060 IUnknown_Release(l);
2061 return hres;
2064 static HRESULT interp_concat(exec_ctx_t *ctx)
2066 variant_val_t r, l;
2067 VARIANT v;
2068 HRESULT hres;
2070 TRACE("\n");
2072 hres = stack_pop_val(ctx, &r);
2073 if(FAILED(hres))
2074 return hres;
2076 hres = stack_pop_val(ctx, &l);
2077 if(SUCCEEDED(hres)) {
2078 hres = VarCat(l.v, r.v, &v);
2079 release_val(&l);
2081 release_val(&r);
2082 if(FAILED(hres))
2083 return hres;
2085 return stack_push(ctx, &v);
2088 static HRESULT interp_add(exec_ctx_t *ctx)
2090 variant_val_t r, l;
2091 VARIANT v;
2092 HRESULT hres;
2094 TRACE("\n");
2096 hres = stack_pop_val(ctx, &r);
2097 if(FAILED(hres))
2098 return hres;
2100 hres = stack_pop_val(ctx, &l);
2101 if(SUCCEEDED(hres)) {
2102 hres = VarAdd(l.v, r.v, &v);
2103 release_val(&l);
2105 release_val(&r);
2106 if(FAILED(hres))
2107 return hres;
2109 return stack_push(ctx, &v);
2112 static HRESULT interp_sub(exec_ctx_t *ctx)
2114 variant_val_t r, l;
2115 VARIANT v;
2116 HRESULT hres;
2118 TRACE("\n");
2120 hres = stack_pop_val(ctx, &r);
2121 if(FAILED(hres))
2122 return hres;
2124 hres = stack_pop_val(ctx, &l);
2125 if(SUCCEEDED(hres)) {
2126 hres = VarSub(l.v, r.v, &v);
2127 release_val(&l);
2129 release_val(&r);
2130 if(FAILED(hres))
2131 return hres;
2133 return stack_push(ctx, &v);
2136 static HRESULT interp_mod(exec_ctx_t *ctx)
2138 variant_val_t r, l;
2139 VARIANT v;
2140 HRESULT hres;
2142 TRACE("\n");
2144 hres = stack_pop_val(ctx, &r);
2145 if(FAILED(hres))
2146 return hres;
2148 hres = stack_pop_val(ctx, &l);
2149 if(SUCCEEDED(hres)) {
2150 hres = VarMod(l.v, r.v, &v);
2151 release_val(&l);
2153 release_val(&r);
2154 if(FAILED(hres))
2155 return hres;
2157 return stack_push(ctx, &v);
2160 static HRESULT interp_idiv(exec_ctx_t *ctx)
2162 variant_val_t r, l;
2163 VARIANT v;
2164 HRESULT hres;
2166 TRACE("\n");
2168 hres = stack_pop_val(ctx, &r);
2169 if(FAILED(hres))
2170 return hres;
2172 hres = stack_pop_val(ctx, &l);
2173 if(SUCCEEDED(hres)) {
2174 hres = VarIdiv(l.v, r.v, &v);
2175 release_val(&l);
2177 release_val(&r);
2178 if(FAILED(hres))
2179 return hres;
2181 return stack_push(ctx, &v);
2184 static HRESULT interp_div(exec_ctx_t *ctx)
2186 variant_val_t r, l;
2187 VARIANT v;
2188 HRESULT hres;
2190 TRACE("\n");
2192 hres = stack_pop_val(ctx, &r);
2193 if(FAILED(hres))
2194 return hres;
2196 hres = stack_pop_val(ctx, &l);
2197 if(SUCCEEDED(hres)) {
2198 hres = VarDiv(l.v, r.v, &v);
2199 release_val(&l);
2201 release_val(&r);
2202 if(FAILED(hres))
2203 return hres;
2205 return stack_push(ctx, &v);
2208 static HRESULT interp_mul(exec_ctx_t *ctx)
2210 variant_val_t r, l;
2211 VARIANT v;
2212 HRESULT hres;
2214 TRACE("\n");
2216 hres = stack_pop_val(ctx, &r);
2217 if(FAILED(hres))
2218 return hres;
2220 hres = stack_pop_val(ctx, &l);
2221 if(SUCCEEDED(hres)) {
2222 hres = VarMul(l.v, r.v, &v);
2223 release_val(&l);
2225 release_val(&r);
2226 if(FAILED(hres))
2227 return hres;
2229 return stack_push(ctx, &v);
2232 static HRESULT interp_exp(exec_ctx_t *ctx)
2234 variant_val_t r, l;
2235 VARIANT v;
2236 HRESULT hres;
2238 TRACE("\n");
2240 hres = stack_pop_val(ctx, &r);
2241 if(FAILED(hres))
2242 return hres;
2244 hres = stack_pop_val(ctx, &l);
2245 if(SUCCEEDED(hres)) {
2246 hres = VarPow(l.v, r.v, &v);
2247 release_val(&l);
2249 release_val(&r);
2250 if(FAILED(hres))
2251 return hres;
2253 return stack_push(ctx, &v);
2256 static HRESULT interp_neg(exec_ctx_t *ctx)
2258 variant_val_t val;
2259 VARIANT v;
2260 HRESULT hres;
2262 hres = stack_pop_val(ctx, &val);
2263 if(FAILED(hres))
2264 return hres;
2266 hres = VarNeg(val.v, &v);
2267 release_val(&val);
2268 if(FAILED(hres))
2269 return hres;
2271 return stack_push(ctx, &v);
2274 static HRESULT interp_incc(exec_ctx_t *ctx)
2276 const BSTR ident = ctx->instr->arg1.bstr;
2277 VARIANT v;
2278 ref_t ref;
2279 HRESULT hres;
2281 TRACE("\n");
2283 hres = lookup_identifier(ctx, ident, VBDISP_LET, &ref);
2284 if(FAILED(hres))
2285 return hres;
2287 if(ref.type != REF_VAR) {
2288 FIXME("ref.type is not REF_VAR\n");
2289 return E_FAIL;
2292 hres = VarAdd(stack_top(ctx, 0), ref.u.v, &v);
2293 if(FAILED(hres))
2294 return hres;
2296 VariantClear(ref.u.v);
2297 *ref.u.v = v;
2298 return S_OK;
2301 static HRESULT interp_catch(exec_ctx_t *ctx)
2303 /* Nothing to do here, the OP is for unwinding only. */
2304 return S_OK;
2307 static const instr_func_t op_funcs[] = {
2308 #define X(x,n,a,b) interp_ ## x,
2309 OP_LIST
2310 #undef X
2313 static const unsigned op_move[] = {
2314 #define X(x,n,a,b) n,
2315 OP_LIST
2316 #undef X
2319 void release_dynamic_var(dynamic_var_t *var)
2321 VariantClear(&var->v);
2322 if(var->array)
2323 SafeArrayDestroy(var->array);
2326 static void release_exec(exec_ctx_t *ctx)
2328 dynamic_var_t *var;
2329 unsigned i;
2331 VariantClear(&ctx->ret_val);
2333 for(var = ctx->dynamic_vars; var; var = var->next)
2334 release_dynamic_var(var);
2336 if(ctx->vbthis)
2337 IDispatchEx_Release(&ctx->vbthis->IDispatchEx_iface);
2339 if(ctx->args) {
2340 for(i=0; i < ctx->func->arg_cnt; i++)
2341 VariantClear(ctx->args+i);
2344 if(ctx->vars) {
2345 for(i=0; i < ctx->func->var_cnt; i++)
2346 VariantClear(ctx->vars+i);
2349 if(ctx->arrays) {
2350 for(i=0; i < ctx->func->array_cnt; i++) {
2351 if(ctx->arrays[i])
2352 SafeArrayDestroy(ctx->arrays[i]);
2354 heap_free(ctx->arrays);
2357 heap_pool_free(&ctx->heap);
2358 heap_free(ctx->args);
2359 heap_free(ctx->vars);
2360 heap_free(ctx->stack);
2363 HRESULT exec_script(script_ctx_t *ctx, BOOL extern_caller, function_t *func, vbdisp_t *vbthis, DISPPARAMS *dp, VARIANT *res)
2365 exec_ctx_t exec = {func->code_ctx};
2366 vbsop_t op;
2367 HRESULT hres = S_OK;
2369 exec.code = func->code_ctx;
2371 if(dp ? func->arg_cnt != arg_cnt(dp) : func->arg_cnt) {
2372 FIXME("wrong arg_cnt %d, expected %d\n", dp ? arg_cnt(dp) : 0, func->arg_cnt);
2373 return E_FAIL;
2376 heap_pool_init(&exec.heap);
2378 TRACE("%s(", debugstr_w(func->name));
2379 if(func->arg_cnt) {
2380 VARIANT *v;
2381 unsigned i;
2383 exec.args = heap_alloc_zero(func->arg_cnt * sizeof(VARIANT));
2384 if(!exec.args) {
2385 release_exec(&exec);
2386 return E_OUTOFMEMORY;
2389 for(i=0; i < func->arg_cnt; i++) {
2390 v = get_arg(dp, i);
2391 TRACE("%s%s", i ? ", " : "", debugstr_variant(v));
2392 if(V_VT(v) == (VT_VARIANT|VT_BYREF)) {
2393 if(func->args[i].by_ref)
2394 exec.args[i] = *v;
2395 else
2396 hres = VariantCopyInd(exec.args+i, V_VARIANTREF(v));
2397 }else {
2398 hres = VariantCopyInd(exec.args+i, v);
2400 if(FAILED(hres)) {
2401 release_exec(&exec);
2402 return hres;
2405 }else {
2406 exec.args = NULL;
2408 TRACE(")\n");
2410 if(func->var_cnt) {
2411 exec.vars = heap_alloc_zero(func->var_cnt * sizeof(VARIANT));
2412 if(!exec.vars) {
2413 release_exec(&exec);
2414 return E_OUTOFMEMORY;
2416 }else {
2417 exec.vars = NULL;
2420 exec.stack_size = 16;
2421 exec.top = 0;
2422 exec.stack = heap_alloc(exec.stack_size * sizeof(VARIANT));
2423 if(!exec.stack) {
2424 release_exec(&exec);
2425 return E_OUTOFMEMORY;
2428 if(extern_caller)
2429 IActiveScriptSite_OnEnterScript(ctx->site);
2431 if(vbthis) {
2432 IDispatchEx_AddRef(&vbthis->IDispatchEx_iface);
2433 exec.vbthis = vbthis;
2436 exec.instr = exec.code->instrs + func->code_off;
2437 exec.script = ctx;
2438 exec.func = func;
2440 while(exec.instr) {
2441 op = exec.instr->op;
2442 hres = op_funcs[op](&exec);
2443 if(FAILED(hres)) {
2444 if(hres != SCRIPT_E_RECORDED) {
2445 clear_ei(&ctx->ei);
2447 ctx->ei.scode = hres = map_hres(hres);
2448 ctx->ei.bstrSource = get_vbscript_string(VBS_RUNTIME_ERROR);
2449 ctx->ei.bstrDescription = get_vbscript_error_string(hres);
2450 }else {
2451 hres = ctx->ei.scode;
2454 if(exec.resume_next) {
2455 unsigned stack_off;
2457 WARN("Failed %08x in resume next mode\n", hres);
2460 * Unwinding here is simple. We need to find the next OP_catch, which contains
2461 * information about expected stack size and jump offset on error. Generated
2462 * bytecode needs to guarantee, that simple jump and stack adjustment will
2463 * guarantee proper execution continuation.
2465 while((++exec.instr)->op != OP_catch);
2467 TRACE("unwind jmp %d stack_off %d\n", exec.instr->arg1.uint, exec.instr->arg2.uint);
2469 clear_error_loc(ctx);
2470 stack_off = exec.instr->arg2.uint;
2471 instr_jmp(&exec, exec.instr->arg1.uint);
2473 if(exec.top > stack_off) {
2474 stack_popn(&exec, exec.top-stack_off);
2475 }else if(exec.top < stack_off) {
2476 VARIANT v;
2478 V_VT(&v) = VT_EMPTY;
2479 while(exec.top < stack_off) {
2480 hres = stack_push(&exec, &v);
2481 if(FAILED(hres))
2482 break;
2486 continue;
2487 }else {
2488 if(!ctx->error_loc_code) {
2489 grab_vbscode(exec.code);
2490 ctx->error_loc_code = exec.code;
2491 ctx->error_loc_offset = exec.instr->loc;
2493 stack_popn(&exec, exec.top);
2494 break;
2498 exec.instr += op_move[op];
2501 assert(!exec.top);
2503 if(extern_caller) {
2504 if(FAILED(hres)) {
2505 if(!ctx->ei.scode)
2506 ctx->ei.scode = hres;
2507 hres = report_script_error(ctx, ctx->error_loc_code, ctx->error_loc_offset);
2508 clear_error_loc(ctx);
2510 IActiveScriptSite_OnLeaveScript(ctx->site);
2513 if(SUCCEEDED(hres) && res) {
2514 *res = exec.ret_val;
2515 V_VT(&exec.ret_val) = VT_EMPTY;
2518 release_exec(&exec);
2519 return hres;