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
23 #include "wine/debug.h"
25 WINE_DEFAULT_DEBUG_CHANNEL(vbscript
);
37 dynamic_var_t
*dynamic_vars
;
49 typedef HRESULT (*instr_func_t
)(exec_ctx_t
*);
79 static BOOL
lookup_dynamic_vars(dynamic_var_t
*var
, const WCHAR
*name
, ref_t
*ref
)
82 if(!strcmpiW(var
->name
, name
)) {
83 ref
->type
= var
->is_const
? REF_CONST
: REF_VAR
;
94 static HRESULT
lookup_identifier(exec_ctx_t
*ctx
, BSTR name
, vbdisp_invoke_type_t invoke_type
, ref_t
*ref
)
102 static const WCHAR errW
[] = {'e','r','r',0};
104 if(invoke_type
== VBDISP_LET
105 && (ctx
->func
->type
== FUNC_FUNCTION
|| ctx
->func
->type
== FUNC_PROPGET
|| ctx
->func
->type
== FUNC_DEFGET
)
106 && !strcmpiW(name
, ctx
->func
->name
)) {
108 ref
->u
.v
= &ctx
->ret_val
;
112 for(i
=0; i
< ctx
->func
->var_cnt
; i
++) {
113 if(!strcmpiW(ctx
->func
->vars
[i
].name
, name
)) {
115 ref
->u
.v
= ctx
->vars
+i
;
120 for(i
=0; i
< ctx
->func
->arg_cnt
; i
++) {
121 if(!strcmpiW(ctx
->func
->args
[i
].name
, name
)) {
123 ref
->u
.v
= ctx
->args
+i
;
128 if(lookup_dynamic_vars(ctx
->func
->type
== FUNC_GLOBAL
? ctx
->script
->global_vars
: ctx
->dynamic_vars
, name
, ref
))
131 if(ctx
->func
->type
!= FUNC_GLOBAL
) {
132 hres
= disp_get_id(ctx
->this_obj
, name
, invoke_type
, TRUE
, &id
);
133 if(SUCCEEDED(hres
)) {
134 ref
->type
= REF_DISP
;
135 ref
->u
.d
.disp
= ctx
->this_obj
;
141 if(ctx
->func
->type
!= FUNC_GLOBAL
&& lookup_dynamic_vars(ctx
->script
->global_vars
, name
, ref
))
144 for(func
= ctx
->script
->global_funcs
; func
; func
= func
->next
) {
145 if(!strcmpiW(func
->name
, name
)) {
146 ref
->type
= REF_FUNC
;
152 if(!strcmpiW(name
, errW
)) {
154 ref
->u
.obj
= (IDispatch
*)&ctx
->script
->err_obj
->IDispatchEx_iface
;
158 hres
= vbdisp_get_id(ctx
->script
->global_obj
, name
, invoke_type
, TRUE
, &id
);
159 if(SUCCEEDED(hres
)) {
160 ref
->type
= REF_DISP
;
161 ref
->u
.d
.disp
= (IDispatch
*)&ctx
->script
->global_obj
->IDispatchEx_iface
;
166 LIST_FOR_EACH_ENTRY(item
, &ctx
->script
->named_items
, named_item_t
, entry
) {
167 if((item
->flags
& SCRIPTITEM_ISVISIBLE
) && !strcmpiW(item
->name
, name
)) {
171 hres
= IActiveScriptSite_GetItemInfo(ctx
->script
->site
, name
, SCRIPTINFO_IUNKNOWN
, &unk
, NULL
);
173 WARN("GetItemInfo failed: %08x\n", hres
);
177 hres
= IUnknown_QueryInterface(unk
, &IID_IDispatch
, (void**)&item
->disp
);
178 IUnknown_Release(unk
);
180 WARN("object does not implement IDispatch\n");
186 ref
->u
.obj
= item
->disp
;
191 LIST_FOR_EACH_ENTRY(item
, &ctx
->script
->named_items
, named_item_t
, entry
) {
192 if((item
->flags
& SCRIPTITEM_GLOBALMEMBERS
)) {
193 hres
= disp_get_id(item
->disp
, name
, invoke_type
, FALSE
, &id
);
194 if(SUCCEEDED(hres
)) {
195 ref
->type
= REF_DISP
;
196 ref
->u
.d
.disp
= item
->disp
;
203 ref
->type
= REF_NONE
;
207 static HRESULT
add_dynamic_var(exec_ctx_t
*ctx
, const WCHAR
*name
, BOOL is_const
, VARIANT
*val
, BOOL own_val
)
209 dynamic_var_t
*new_var
;
215 heap
= ctx
->func
->type
== FUNC_GLOBAL
? &ctx
->script
->heap
: &ctx
->heap
;
217 new_var
= vbsheap_alloc(heap
, sizeof(*new_var
));
219 return E_OUTOFMEMORY
;
221 size
= (strlenW(name
)+1)*sizeof(WCHAR
);
222 str
= vbsheap_alloc(heap
, size
);
224 return E_OUTOFMEMORY
;
225 memcpy(str
, name
, size
);
227 new_var
->is_const
= is_const
;
232 V_VT(&new_var
->v
) = VT_EMPTY
;
233 hres
= VariantCopy(&new_var
->v
, val
);
238 if(ctx
->func
->type
== FUNC_GLOBAL
) {
239 new_var
->next
= ctx
->script
->global_vars
;
240 ctx
->script
->global_vars
= new_var
;
242 new_var
->next
= ctx
->dynamic_vars
;
243 ctx
->dynamic_vars
= new_var
;
249 static inline VARIANT
*stack_pop(exec_ctx_t
*ctx
)
252 return ctx
->stack
+ --ctx
->top
;
255 static inline VARIANT
*stack_top(exec_ctx_t
*ctx
, unsigned n
)
257 assert(ctx
->top
>= n
);
258 return ctx
->stack
+ (ctx
->top
-n
-1);
261 static HRESULT
stack_push(exec_ctx_t
*ctx
, VARIANT
*v
)
263 if(ctx
->stack_size
== ctx
->top
) {
266 new_stack
= heap_realloc(ctx
->stack
, ctx
->stack_size
*2*sizeof(*ctx
->stack
));
269 return E_OUTOFMEMORY
;
272 ctx
->stack
= new_stack
;
273 ctx
->stack_size
*= 2;
276 ctx
->stack
[ctx
->top
++] = *v
;
280 static void stack_popn(exec_ctx_t
*ctx
, unsigned n
)
283 VariantClear(stack_pop(ctx
));
286 static HRESULT
stack_pop_val(exec_ctx_t
*ctx
, variant_val_t
*v
)
290 var
= stack_pop(ctx
);
292 if(V_VT(var
) == (VT_BYREF
|VT_VARIANT
)) {
294 var
= V_VARIANTREF(var
);
299 if(V_VT(var
) == VT_DISPATCH
) {
303 hres
= disp_call(ctx
->script
, V_DISPATCH(var
), DISPID_VALUE
, &dp
, &v
->store
);
305 IDispatch_Release(V_DISPATCH(var
));
318 static HRESULT
stack_assume_val(exec_ctx_t
*ctx
, unsigned n
)
320 VARIANT
*v
= stack_top(ctx
, n
);
323 if(V_VT(v
) == (VT_BYREF
|VT_VARIANT
)) {
324 VARIANT
*ref
= V_VARIANTREF(v
);
327 hres
= VariantCopy(v
, ref
);
332 if(V_VT(v
) == VT_DISPATCH
) {
336 disp
= V_DISPATCH(v
);
338 hres
= disp_call(ctx
->script
, disp
, DISPID_VALUE
, &dp
, v
);
339 IDispatch_Release(disp
);
347 static inline void release_val(variant_val_t
*v
)
353 static int stack_pop_bool(exec_ctx_t
*ctx
, BOOL
*b
)
358 hres
= stack_pop_val(ctx
, &val
);
374 FIXME("unsupported for %s\n", debugstr_variant(val
.v
));
381 static HRESULT
stack_pop_disp(exec_ctx_t
*ctx
, IDispatch
**ret
)
383 VARIANT
*v
= stack_pop(ctx
);
385 if(V_VT(v
) == VT_DISPATCH
) {
386 *ret
= V_DISPATCH(v
);
390 if(V_VT(v
) != (VT_VARIANT
|VT_BYREF
)) {
391 FIXME("not supported type: %s\n", debugstr_variant(v
));
397 if(V_VT(v
) != VT_DISPATCH
) {
398 FIXME("not disp %s\n", debugstr_variant(v
));
403 IDispatch_AddRef(V_DISPATCH(v
));
404 *ret
= V_DISPATCH(v
);
408 static HRESULT
stack_assume_disp(exec_ctx_t
*ctx
, unsigned n
, IDispatch
**disp
)
410 VARIANT
*v
= stack_top(ctx
, n
), *ref
;
412 if(V_VT(v
) != VT_DISPATCH
) {
413 if(V_VT(v
) != (VT_VARIANT
|VT_BYREF
)) {
414 FIXME("not supported type: %s\n", debugstr_variant(v
));
418 ref
= V_VARIANTREF(v
);
419 if(V_VT(ref
) != VT_DISPATCH
) {
420 FIXME("not disp %s\n", debugstr_variant(ref
));
424 V_VT(v
) = VT_DISPATCH
;
425 V_DISPATCH(v
) = V_DISPATCH(ref
);
427 IDispatch_AddRef(V_DISPATCH(v
));
431 *disp
= V_DISPATCH(v
);
435 static inline void instr_jmp(exec_ctx_t
*ctx
, unsigned addr
)
437 ctx
->instr
= ctx
->code
->instrs
+ addr
;
440 static void vbstack_to_dp(exec_ctx_t
*ctx
, unsigned arg_cnt
, BOOL is_propput
, DISPPARAMS
*dp
)
442 static DISPID propput_dispid
= DISPID_PROPERTYPUT
;
444 dp
->cNamedArgs
= is_propput
? 1 : 0;
445 dp
->cArgs
= arg_cnt
+ dp
->cNamedArgs
;
446 dp
->rgdispidNamedArgs
= is_propput
? &propput_dispid
: NULL
;
452 assert(ctx
->top
>= arg_cnt
);
454 for(i
=1; i
*2 <= arg_cnt
; i
++) {
455 tmp
= ctx
->stack
[ctx
->top
-i
];
456 ctx
->stack
[ctx
->top
-i
] = ctx
->stack
[ctx
->top
-arg_cnt
+i
-1];
457 ctx
->stack
[ctx
->top
-arg_cnt
+i
-1] = tmp
;
460 dp
->rgvarg
= ctx
->stack
+ ctx
->top
-dp
->cArgs
;
462 dp
->rgvarg
= is_propput
? ctx
->stack
+ctx
->top
-1 : NULL
;
466 static HRESULT
do_icall(exec_ctx_t
*ctx
, VARIANT
*res
)
468 BSTR identifier
= ctx
->instr
->arg1
.bstr
;
469 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
474 hres
= lookup_identifier(ctx
, identifier
, VBDISP_CALLGET
, &ref
);
478 vbstack_to_dp(ctx
, arg_cnt
, FALSE
, &dp
);
484 FIXME("REF_VAR no res\n");
489 FIXME("arguments not implemented\n");
493 V_VT(res
) = VT_BYREF
|VT_VARIANT
;
494 V_BYREF(res
) = V_VT(ref
.u
.v
) == (VT_VARIANT
|VT_BYREF
) ? V_VARIANTREF(ref
.u
.v
) : ref
.u
.v
;
497 hres
= disp_call(ctx
->script
, ref
.u
.d
.disp
, ref
.u
.d
.id
, &dp
, res
);
502 hres
= exec_script(ctx
->script
, ref
.u
.f
, NULL
, &dp
, res
);
508 FIXME("arguments on object\n");
513 IDispatch_AddRef(ref
.u
.obj
);
514 V_VT(res
) = VT_DISPATCH
;
515 V_DISPATCH(res
) = ref
.u
.obj
;
519 FIXME("%s not found\n", debugstr_w(identifier
));
520 return DISP_E_UNKNOWNNAME
;
523 stack_popn(ctx
, arg_cnt
);
527 static HRESULT
interp_icall(exec_ctx_t
*ctx
)
534 hres
= do_icall(ctx
, &v
);
538 return stack_push(ctx
, &v
);
541 static HRESULT
interp_icallv(exec_ctx_t
*ctx
)
544 return do_icall(ctx
, NULL
);
547 static HRESULT
do_mcall(exec_ctx_t
*ctx
, VARIANT
*res
)
549 const BSTR identifier
= ctx
->instr
->arg1
.bstr
;
550 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
556 hres
= stack_pop_disp(ctx
, &obj
);
565 vbstack_to_dp(ctx
, arg_cnt
, FALSE
, &dp
);
567 hres
= disp_get_id(obj
, identifier
, VBDISP_CALLGET
, FALSE
, &id
);
569 hres
= disp_call(ctx
->script
, obj
, id
, &dp
, res
);
570 IDispatch_Release(obj
);
574 stack_popn(ctx
, arg_cnt
);
578 static HRESULT
interp_mcall(exec_ctx_t
*ctx
)
585 hres
= do_mcall(ctx
, &res
);
589 return stack_push(ctx
, &res
);
592 static HRESULT
interp_mcallv(exec_ctx_t
*ctx
)
596 return do_mcall(ctx
, NULL
);
599 static HRESULT
assign_ident(exec_ctx_t
*ctx
, BSTR name
, DISPPARAMS
*dp
)
604 hres
= lookup_identifier(ctx
, name
, VBDISP_LET
, &ref
);
610 VARIANT
*v
= ref
.u
.v
;
613 FIXME("arg_cnt %d not supported\n", arg_cnt(dp
));
617 if(V_VT(v
) == (VT_VARIANT
|VT_BYREF
))
620 hres
= VariantCopy(v
, dp
->rgvarg
);
624 hres
= disp_propput(ctx
->script
, ref
.u
.d
.disp
, ref
.u
.d
.id
, dp
);
627 FIXME("functions not implemented\n");
633 FIXME("REF_CONST\n");
636 if(ctx
->func
->code_ctx
->option_explicit
) {
637 FIXME("throw exception\n");
641 FIXME("arg_cnt %d not supported\n", arg_cnt(dp
));
645 TRACE("creating variable %s\n", debugstr_w(name
));
646 hres
= add_dynamic_var(ctx
, name
, FALSE
, dp
->rgvarg
, FALSE
);
653 static HRESULT
interp_assign_ident(exec_ctx_t
*ctx
)
655 const BSTR arg
= ctx
->instr
->arg1
.bstr
;
656 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
660 TRACE("%s\n", debugstr_w(arg
));
662 hres
= stack_assume_val(ctx
, arg_cnt
);
666 vbstack_to_dp(ctx
, arg_cnt
, TRUE
, &dp
);
667 hres
= assign_ident(ctx
, arg
, &dp
);
671 stack_popn(ctx
, arg_cnt
+1);
675 static HRESULT
interp_set_ident(exec_ctx_t
*ctx
)
677 const BSTR arg
= ctx
->instr
->arg1
.bstr
;
678 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
682 TRACE("%s\n", debugstr_w(arg
));
685 FIXME("arguments not supported\n");
689 hres
= stack_assume_disp(ctx
, 0, NULL
);
693 vbstack_to_dp(ctx
, 0, TRUE
, &dp
);
694 hres
= assign_ident(ctx
, ctx
->instr
->arg1
.bstr
, &dp
);
702 static HRESULT
interp_assign_member(exec_ctx_t
*ctx
)
704 BSTR identifier
= ctx
->instr
->arg1
.bstr
;
705 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
711 TRACE("%s\n", debugstr_w(identifier
));
713 hres
= stack_assume_disp(ctx
, arg_cnt
+1, &obj
);
722 hres
= stack_assume_val(ctx
, arg_cnt
);
726 hres
= disp_get_id(obj
, identifier
, VBDISP_LET
, FALSE
, &id
);
727 if(SUCCEEDED(hres
)) {
728 vbstack_to_dp(ctx
, arg_cnt
, TRUE
, &dp
);
729 hres
= disp_propput(ctx
->script
, obj
, id
, &dp
);
734 stack_popn(ctx
, arg_cnt
+2);
738 static HRESULT
interp_set_member(exec_ctx_t
*ctx
)
740 BSTR identifier
= ctx
->instr
->arg1
.bstr
;
741 const unsigned arg_cnt
= ctx
->instr
->arg2
.uint
;
747 TRACE("%s\n", debugstr_w(identifier
));
750 FIXME("arguments not supported\n");
754 hres
= stack_assume_disp(ctx
, 1, &obj
);
763 hres
= stack_assume_disp(ctx
, 0, NULL
);
767 hres
= disp_get_id(obj
, identifier
, VBDISP_SET
, FALSE
, &id
);
768 if(SUCCEEDED(hres
)) {
769 vbstack_to_dp(ctx
, arg_cnt
, TRUE
, &dp
);
770 hres
= disp_propput(ctx
->script
, obj
, id
, &dp
);
779 static HRESULT
interp_const(exec_ctx_t
*ctx
)
781 BSTR arg
= ctx
->instr
->arg1
.bstr
;
786 TRACE("%s\n", debugstr_w(arg
));
788 assert(ctx
->func
->type
== FUNC_GLOBAL
);
790 hres
= lookup_identifier(ctx
, arg
, VBDISP_CALLGET
, &ref
);
794 if(ref
.type
!= REF_NONE
) {
795 FIXME("%s already defined\n", debugstr_w(arg
));
799 hres
= stack_pop_val(ctx
, &val
);
803 return add_dynamic_var(ctx
, arg
, TRUE
, val
.v
, val
.owned
);
806 static HRESULT
interp_val(exec_ctx_t
*ctx
)
814 hres
= stack_pop_val(ctx
, &val
);
820 hres
= VariantCopy(&v
, val
.v
);
825 return stack_push(ctx
, val
.owned
? val
.v
: &v
);
828 static HRESULT
interp_pop(exec_ctx_t
*ctx
)
830 const unsigned n
= ctx
->instr
->arg1
.uint
;
838 static HRESULT
interp_new(exec_ctx_t
*ctx
)
840 const WCHAR
*arg
= ctx
->instr
->arg1
.bstr
;
841 class_desc_t
*class_desc
;
846 TRACE("%s\n", debugstr_w(arg
));
848 for(class_desc
= ctx
->script
->classes
; class_desc
; class_desc
= class_desc
->next
) {
849 if(!strcmpiW(class_desc
->name
, arg
))
853 FIXME("Class %s not found\n", debugstr_w(arg
));
857 hres
= create_vbdisp(class_desc
, &obj
);
861 V_VT(&v
) = VT_DISPATCH
;
862 V_DISPATCH(&v
) = (IDispatch
*)&obj
->IDispatchEx_iface
;
863 return stack_push(ctx
, &v
);
866 static HRESULT
interp_step(exec_ctx_t
*ctx
)
868 const BSTR ident
= ctx
->instr
->arg2
.bstr
;
874 TRACE("%s\n", debugstr_w(ident
));
878 hres
= VarCmp(stack_top(ctx
, 0), &zero
, ctx
->script
->lcid
, 0);
882 gteq_zero
= hres
== VARCMP_GT
|| hres
== VARCMP_EQ
;
884 hres
= lookup_identifier(ctx
, ident
, VBDISP_ANY
, &ref
);
888 if(ref
.type
!= REF_VAR
) {
889 FIXME("%s is not REF_VAR\n", debugstr_w(ident
));
893 hres
= VarCmp(ref
.u
.v
, stack_top(ctx
, 1), ctx
->script
->lcid
, 0);
897 if(hres
== VARCMP_EQ
|| hres
== (gteq_zero
? VARCMP_LT
: VARCMP_GT
))
900 instr_jmp(ctx
, ctx
->instr
->arg1
.uint
);
904 static HRESULT
interp_jmp(exec_ctx_t
*ctx
)
906 const unsigned arg
= ctx
->instr
->arg1
.uint
;
914 static HRESULT
interp_jmp_false(exec_ctx_t
*ctx
)
916 const unsigned arg
= ctx
->instr
->arg1
.uint
;
922 hres
= stack_pop_bool(ctx
, &b
);
929 instr_jmp(ctx
, ctx
->instr
->arg1
.uint
);
933 static HRESULT
interp_jmp_true(exec_ctx_t
*ctx
)
935 const unsigned arg
= ctx
->instr
->arg1
.uint
;
941 hres
= stack_pop_bool(ctx
, &b
);
946 instr_jmp(ctx
, ctx
->instr
->arg1
.uint
);
952 static HRESULT
interp_ret(exec_ctx_t
*ctx
)
960 static HRESULT
interp_stop(exec_ctx_t
*ctx
)
964 /* NOTE: this should have effect in debugging mode (that we don't support yet) */
968 static HRESULT
interp_me(exec_ctx_t
*ctx
)
974 IDispatch_AddRef(ctx
->this_obj
);
975 V_VT(&v
) = VT_DISPATCH
;
976 V_DISPATCH(&v
) = ctx
->this_obj
;
977 return stack_push(ctx
, &v
);
980 static HRESULT
interp_bool(exec_ctx_t
*ctx
)
982 const VARIANT_BOOL arg
= ctx
->instr
->arg1
.lng
;
985 TRACE("%s\n", arg
? "true" : "false");
989 return stack_push(ctx
, &v
);
992 static HRESULT
interp_errmode(exec_ctx_t
*ctx
)
994 const int err_mode
= ctx
->instr
->arg1
.uint
;
996 TRACE("%d\n", err_mode
);
998 ctx
->resume_next
= err_mode
;
1002 static HRESULT
interp_string(exec_ctx_t
*ctx
)
1009 V_BSTR(&v
) = SysAllocString(ctx
->instr
->arg1
.str
);
1011 return E_OUTOFMEMORY
;
1013 return stack_push(ctx
, &v
);
1016 static HRESULT
interp_long(exec_ctx_t
*ctx
)
1018 const LONG arg
= ctx
->instr
->arg1
.lng
;
1025 return stack_push(ctx
, &v
);
1028 static HRESULT
interp_short(exec_ctx_t
*ctx
)
1030 const LONG arg
= ctx
->instr
->arg1
.lng
;
1037 return stack_push(ctx
, &v
);
1040 static HRESULT
interp_double(exec_ctx_t
*ctx
)
1042 const DOUBLE
*arg
= ctx
->instr
->arg1
.dbl
;
1045 TRACE("%lf\n", *arg
);
1049 return stack_push(ctx
, &v
);
1052 static HRESULT
interp_empty(exec_ctx_t
*ctx
)
1058 V_VT(&v
) = VT_EMPTY
;
1059 return stack_push(ctx
, &v
);
1062 static HRESULT
interp_null(exec_ctx_t
*ctx
)
1069 return stack_push(ctx
, &v
);
1072 static HRESULT
interp_nothing(exec_ctx_t
*ctx
)
1078 V_VT(&v
) = VT_DISPATCH
;
1079 V_DISPATCH(&v
) = NULL
;
1080 return stack_push(ctx
, &v
);
1083 static HRESULT
interp_not(exec_ctx_t
*ctx
)
1091 hres
= stack_pop_val(ctx
, &val
);
1095 hres
= VarNot(val
.v
, &v
);
1100 return stack_push(ctx
, &v
);
1103 static HRESULT
interp_and(exec_ctx_t
*ctx
)
1111 hres
= stack_pop_val(ctx
, &r
);
1115 hres
= stack_pop_val(ctx
, &l
);
1116 if(SUCCEEDED(hres
)) {
1117 hres
= VarAnd(l
.v
, r
.v
, &v
);
1124 return stack_push(ctx
, &v
);
1127 static HRESULT
interp_or(exec_ctx_t
*ctx
)
1135 hres
= stack_pop_val(ctx
, &r
);
1139 hres
= stack_pop_val(ctx
, &l
);
1140 if(SUCCEEDED(hres
)) {
1141 hres
= VarOr(l
.v
, r
.v
, &v
);
1148 return stack_push(ctx
, &v
);
1151 static HRESULT
interp_xor(exec_ctx_t
*ctx
)
1159 hres
= stack_pop_val(ctx
, &r
);
1163 hres
= stack_pop_val(ctx
, &l
);
1164 if(SUCCEEDED(hres
)) {
1165 hres
= VarXor(l
.v
, r
.v
, &v
);
1172 return stack_push(ctx
, &v
);
1175 static HRESULT
interp_eqv(exec_ctx_t
*ctx
)
1183 hres
= stack_pop_val(ctx
, &r
);
1187 hres
= stack_pop_val(ctx
, &l
);
1188 if(SUCCEEDED(hres
)) {
1189 hres
= VarEqv(l
.v
, r
.v
, &v
);
1196 return stack_push(ctx
, &v
);
1199 static HRESULT
interp_imp(exec_ctx_t
*ctx
)
1207 hres
= stack_pop_val(ctx
, &r
);
1211 hres
= stack_pop_val(ctx
, &l
);
1212 if(SUCCEEDED(hres
)) {
1213 hres
= VarImp(l
.v
, r
.v
, &v
);
1220 return stack_push(ctx
, &v
);
1223 static HRESULT
cmp_oper(exec_ctx_t
*ctx
)
1228 hres
= stack_pop_val(ctx
, &r
);
1232 hres
= stack_pop_val(ctx
, &l
);
1233 if(SUCCEEDED(hres
)) {
1234 if(V_VT(l
.v
) == VT_NULL
|| V_VT(r
.v
) == VT_NULL
) {
1235 FIXME("comparing nulls is not implemented\n");
1238 hres
= VarCmp(l
.v
, r
.v
, ctx
->script
->lcid
, 0);
1247 static HRESULT
interp_equal(exec_ctx_t
*ctx
)
1254 hres
= cmp_oper(ctx
);
1259 V_BOOL(&v
) = hres
== VARCMP_EQ
? VARIANT_TRUE
: VARIANT_FALSE
;
1260 return stack_push(ctx
, &v
);
1263 static HRESULT
interp_nequal(exec_ctx_t
*ctx
)
1270 hres
= cmp_oper(ctx
);
1275 V_BOOL(&v
) = hres
!= VARCMP_EQ
? VARIANT_TRUE
: VARIANT_FALSE
;
1276 return stack_push(ctx
, &v
);
1279 static HRESULT
interp_gt(exec_ctx_t
*ctx
)
1286 hres
= cmp_oper(ctx
);
1291 V_BOOL(&v
) = hres
== VARCMP_GT
? VARIANT_TRUE
: VARIANT_FALSE
;
1292 return stack_push(ctx
, &v
);
1295 static HRESULT
interp_gteq(exec_ctx_t
*ctx
)
1302 hres
= cmp_oper(ctx
);
1307 V_BOOL(&v
) = hres
== VARCMP_GT
|| hres
== VARCMP_EQ
? VARIANT_TRUE
: VARIANT_FALSE
;
1308 return stack_push(ctx
, &v
);
1311 static HRESULT
interp_lt(exec_ctx_t
*ctx
)
1318 hres
= cmp_oper(ctx
);
1323 V_BOOL(&v
) = hres
== VARCMP_LT
? VARIANT_TRUE
: VARIANT_FALSE
;
1324 return stack_push(ctx
, &v
);
1327 static HRESULT
interp_lteq(exec_ctx_t
*ctx
)
1334 hres
= cmp_oper(ctx
);
1339 V_BOOL(&v
) = hres
== VARCMP_LT
|| hres
== VARCMP_EQ
? VARIANT_TRUE
: VARIANT_FALSE
;
1340 return stack_push(ctx
, &v
);
1343 static HRESULT
disp_cmp(IDispatch
*disp1
, IDispatch
*disp2
, VARIANT_BOOL
*ret
)
1345 IObjectIdentity
*identity
;
1346 IUnknown
*unk1
, *unk2
;
1349 if(disp1
== disp2
) {
1350 *ret
= VARIANT_TRUE
;
1354 if(!disp1
|| !disp2
) {
1355 *ret
= VARIANT_FALSE
;
1359 hres
= IDispatch_QueryInterface(disp1
, &IID_IUnknown
, (void**)&unk1
);
1363 hres
= IDispatch_QueryInterface(disp2
, &IID_IUnknown
, (void**)&unk2
);
1365 IUnknown_Release(unk1
);
1370 *ret
= VARIANT_TRUE
;
1372 hres
= IUnknown_QueryInterface(unk1
, &IID_IObjectIdentity
, (void**)&identity
);
1373 if(SUCCEEDED(hres
)) {
1374 hres
= IObjectIdentity_IsEqualObject(identity
, unk2
);
1375 IObjectIdentity_Release(identity
);
1376 *ret
= hres
== S_OK
? VARIANT_TRUE
: VARIANT_FALSE
;
1378 *ret
= VARIANT_FALSE
;
1382 IUnknown_Release(unk1
);
1383 IUnknown_Release(unk2
);
1387 static HRESULT
interp_is(exec_ctx_t
*ctx
)
1395 hres
= stack_pop_disp(ctx
, &r
);
1399 hres
= stack_pop_disp(ctx
, &l
);
1400 if(SUCCEEDED(hres
)) {
1402 hres
= disp_cmp(l
, r
, &V_BOOL(&v
));
1404 IDispatch_Release(l
);
1407 IDispatch_Release(r
);
1411 return stack_push(ctx
, &v
);
1414 static HRESULT
interp_concat(exec_ctx_t
*ctx
)
1422 hres
= stack_pop_val(ctx
, &r
);
1426 hres
= stack_pop_val(ctx
, &l
);
1427 if(SUCCEEDED(hres
)) {
1428 hres
= VarCat(l
.v
, r
.v
, &v
);
1435 return stack_push(ctx
, &v
);
1438 static HRESULT
interp_add(exec_ctx_t
*ctx
)
1446 hres
= stack_pop_val(ctx
, &r
);
1450 hres
= stack_pop_val(ctx
, &l
);
1451 if(SUCCEEDED(hres
)) {
1452 hres
= VarAdd(l
.v
, r
.v
, &v
);
1459 return stack_push(ctx
, &v
);
1462 static HRESULT
interp_sub(exec_ctx_t
*ctx
)
1470 hres
= stack_pop_val(ctx
, &r
);
1474 hres
= stack_pop_val(ctx
, &l
);
1475 if(SUCCEEDED(hres
)) {
1476 hres
= VarSub(l
.v
, r
.v
, &v
);
1483 return stack_push(ctx
, &v
);
1486 static HRESULT
interp_mod(exec_ctx_t
*ctx
)
1494 hres
= stack_pop_val(ctx
, &r
);
1498 hres
= stack_pop_val(ctx
, &l
);
1499 if(SUCCEEDED(hres
)) {
1500 hres
= VarMod(l
.v
, r
.v
, &v
);
1507 return stack_push(ctx
, &v
);
1510 static HRESULT
interp_idiv(exec_ctx_t
*ctx
)
1518 hres
= stack_pop_val(ctx
, &r
);
1522 hres
= stack_pop_val(ctx
, &l
);
1523 if(SUCCEEDED(hres
)) {
1524 hres
= VarIdiv(l
.v
, r
.v
, &v
);
1531 return stack_push(ctx
, &v
);
1534 static HRESULT
interp_div(exec_ctx_t
*ctx
)
1542 hres
= stack_pop_val(ctx
, &r
);
1546 hres
= stack_pop_val(ctx
, &l
);
1547 if(SUCCEEDED(hres
)) {
1548 hres
= VarDiv(l
.v
, r
.v
, &v
);
1555 return stack_push(ctx
, &v
);
1558 static HRESULT
interp_mul(exec_ctx_t
*ctx
)
1566 hres
= stack_pop_val(ctx
, &r
);
1570 hres
= stack_pop_val(ctx
, &l
);
1571 if(SUCCEEDED(hres
)) {
1572 hres
= VarMul(l
.v
, r
.v
, &v
);
1579 return stack_push(ctx
, &v
);
1582 static HRESULT
interp_exp(exec_ctx_t
*ctx
)
1590 hres
= stack_pop_val(ctx
, &r
);
1594 hres
= stack_pop_val(ctx
, &l
);
1595 if(SUCCEEDED(hres
)) {
1596 hres
= VarPow(l
.v
, r
.v
, &v
);
1603 return stack_push(ctx
, &v
);
1606 static HRESULT
interp_neg(exec_ctx_t
*ctx
)
1612 hres
= stack_pop_val(ctx
, &val
);
1616 hres
= VarNeg(val
.v
, &v
);
1621 return stack_push(ctx
, &v
);
1624 static HRESULT
interp_incc(exec_ctx_t
*ctx
)
1626 const BSTR ident
= ctx
->instr
->arg1
.bstr
;
1633 hres
= lookup_identifier(ctx
, ident
, VBDISP_LET
, &ref
);
1637 if(ref
.type
!= REF_VAR
) {
1638 FIXME("ref.type is not REF_VAR\n");
1642 hres
= VarAdd(stack_top(ctx
, 0), ref
.u
.v
, &v
);
1646 VariantClear(ref
.u
.v
);
1651 static const instr_func_t op_funcs
[] = {
1652 #define X(x,n,a,b) interp_ ## x,
1657 static const unsigned op_move
[] = {
1658 #define X(x,n,a,b) n,
1663 void release_dynamic_vars(dynamic_var_t
*var
)
1666 VariantClear(&var
->v
);
1671 static void release_exec(exec_ctx_t
*ctx
)
1675 VariantClear(&ctx
->ret_val
);
1676 release_dynamic_vars(ctx
->dynamic_vars
);
1679 IDispatch_Release(ctx
->this_obj
);
1682 for(i
=0; i
< ctx
->func
->arg_cnt
; i
++)
1683 VariantClear(ctx
->args
+i
);
1687 for(i
=0; i
< ctx
->func
->var_cnt
; i
++)
1688 VariantClear(ctx
->vars
+i
);
1691 vbsheap_free(&ctx
->heap
);
1692 heap_free(ctx
->args
);
1693 heap_free(ctx
->vars
);
1694 heap_free(ctx
->stack
);
1697 HRESULT
exec_script(script_ctx_t
*ctx
, function_t
*func
, IDispatch
*this_obj
, DISPPARAMS
*dp
, VARIANT
*res
)
1699 exec_ctx_t exec
= {func
->code_ctx
};
1701 HRESULT hres
= S_OK
;
1703 exec
.code
= func
->code_ctx
;
1705 if(dp
? func
->arg_cnt
!= arg_cnt(dp
) : func
->arg_cnt
) {
1706 FIXME("wrong arg_cnt %d, expected %d\n", dp
? arg_cnt(dp
) : 0, func
->arg_cnt
);
1710 vbsheap_init(&exec
.heap
);
1716 exec
.args
= heap_alloc_zero(func
->arg_cnt
* sizeof(VARIANT
));
1718 release_exec(&exec
);
1719 return E_OUTOFMEMORY
;
1722 for(i
=0; i
< func
->arg_cnt
; i
++) {
1724 if(V_VT(v
) == (VT_VARIANT
|VT_BYREF
)) {
1725 if(func
->args
[i
].by_ref
)
1728 hres
= VariantCopy(exec
.args
+i
, V_VARIANTREF(v
));
1730 hres
= VariantCopy(exec
.args
+i
, v
);
1733 release_exec(&exec
);
1742 exec
.vars
= heap_alloc_zero(func
->var_cnt
* sizeof(VARIANT
));
1744 release_exec(&exec
);
1745 return E_OUTOFMEMORY
;
1751 exec
.stack_size
= 16;
1753 exec
.stack
= heap_alloc(exec
.stack_size
* sizeof(VARIANT
));
1755 release_exec(&exec
);
1756 return E_OUTOFMEMORY
;
1760 exec
.this_obj
= this_obj
;
1761 else if (ctx
->host_global
)
1762 exec
.this_obj
= ctx
->host_global
;
1764 exec
.this_obj
= (IDispatch
*)&ctx
->script_obj
->IDispatchEx_iface
;
1765 IDispatch_AddRef(exec
.this_obj
);
1767 exec
.instr
= exec
.code
->instrs
+ func
->code_off
;
1772 op
= exec
.instr
->op
;
1773 hres
= op_funcs
[op
](&exec
);
1775 if(exec
.resume_next
)
1776 FIXME("Failed %08x in resume next mode\n", hres
);
1778 WARN("Failed %08x\n", hres
);
1779 stack_popn(&exec
, exec
.top
);
1783 exec
.instr
+= op_move
[op
];
1787 if(func
->type
!= FUNC_FUNCTION
&& func
->type
!= FUNC_PROPGET
&& func
->type
!= FUNC_DEFGET
)
1788 assert(V_VT(&exec
.ret_val
) == VT_EMPTY
);
1790 if(SUCCEEDED(hres
) && res
) {
1791 *res
= exec
.ret_val
;
1792 V_VT(&exec
.ret_val
) = VT_EMPTY
;
1795 release_exec(&exec
);