2 * Copyright 2008,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
20 #include "wine/port.h"
28 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
32 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
33 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
34 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
35 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
36 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
37 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
38 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
40 struct _except_frame_t {
49 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
51 if(!ctx->stack_size) {
52 ctx->stack = heap_alloc(16*sizeof(VARIANT));
56 }else if(ctx->stack_size == ctx->top) {
59 new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(VARIANT));
65 ctx->stack = new_stack;
69 ctx->stack[ctx->top++] = *v;
73 static HRESULT stack_push_bool(exec_ctx_t *ctx, BOOL b)
78 V_BOOL(&v) = b ? VARIANT_TRUE : VARIANT_FALSE;
79 return stack_push(ctx, &v);
82 static inline HRESULT stack_push_number(exec_ctx_t *ctx, double number)
86 num_set_val(&v, number);
87 return stack_push(ctx, &v);
90 static inline HRESULT stack_push_int(exec_ctx_t *ctx, INT n)
96 return stack_push(ctx, &v);
99 static inline HRESULT stack_push_string(exec_ctx_t *ctx, const WCHAR *str)
104 V_BSTR(&v) = SysAllocString(str);
105 return V_BSTR(&v) ? stack_push(ctx, &v) : E_OUTOFMEMORY;
108 static HRESULT stack_push_objid(exec_ctx_t *ctx, IDispatch *disp, DISPID id)
113 V_VT(&v) = VT_DISPATCH;
114 V_DISPATCH(&v) = disp;
115 hres = stack_push(ctx, &v);
121 return stack_push(ctx, &v);
124 static inline VARIANT *stack_top(exec_ctx_t *ctx)
127 return ctx->stack + ctx->top-1;
130 static inline VARIANT *stack_topn(exec_ctx_t *ctx, unsigned n)
132 assert(ctx->top > n);
133 return ctx->stack + ctx->top-1-n;
136 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
139 return ctx->stack + --ctx->top;
142 static void stack_popn(exec_ctx_t *ctx, unsigned n)
145 VariantClear(stack_pop(ctx));
148 static HRESULT stack_pop_number(exec_ctx_t *ctx, double *r)
154 hres = to_number(ctx->script, v, ctx->ei, r);
159 static HRESULT stack_pop_object(exec_ctx_t *ctx, IDispatch **r)
165 if(V_VT(v) == VT_DISPATCH) {
167 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_REQUIRED, NULL);
172 hres = to_object(ctx->script, v, r);
177 static inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
179 return to_int32(ctx->script, stack_pop(ctx), ctx->ei, r);
182 static inline HRESULT stack_pop_uint(exec_ctx_t *ctx, DWORD *r)
184 return to_uint32(ctx->script, stack_pop(ctx), ctx->ei, r);
187 static inline IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
189 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
191 *id = V_INT(stack_pop(ctx));
192 return V_DISPATCH(stack_pop(ctx));
195 static inline IDispatch *stack_topn_objid(exec_ctx_t *ctx, unsigned n, DISPID *id)
197 assert(V_VT(stack_topn(ctx, n)) == VT_INT && V_VT(stack_topn(ctx, n+1)) == VT_DISPATCH);
199 *id = V_INT(stack_topn(ctx, n));
200 return V_DISPATCH(stack_topn(ctx, n+1));
203 static void exprval_release(exprval_t *val)
206 case EXPRVAL_VARIANT:
207 if(V_VT(&val->u.var) != VT_EMPTY)
208 VariantClear(&val->u.var);
211 if(val->u.idref.disp)
212 IDispatch_Release(val->u.idref.disp);
214 case EXPRVAL_INVALID:
219 /* ECMA-262 3rd Edition 8.7.1 */
220 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
222 V_VT(ret) = VT_EMPTY;
225 case EXPRVAL_VARIANT:
226 return VariantCopy(ret, &val->u.var);
228 if(!val->u.idref.disp) {
229 FIXME("throw ReferenceError\n");
233 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei);
234 case EXPRVAL_INVALID:
238 ERR("type %d\n", val->type);
242 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
244 if(val->type == EXPRVAL_VARIANT) {
246 V_VT(&val->u.var) = VT_EMPTY;
250 return exprval_value(ctx, val, ei, ret);
253 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
255 val->type = EXPRVAL_IDREF;
256 val->u.idref.disp = disp;
257 val->u.idref.id = id;
260 IDispatch_AddRef(disp);
263 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
265 scope_chain_t *new_scope;
267 new_scope = heap_alloc(sizeof(scope_chain_t));
269 return E_OUTOFMEMORY;
274 new_scope->obj = obj;
278 new_scope->next = scope;
280 new_scope->next = NULL;
287 static void scope_pop(scope_chain_t **scope)
296 void scope_release(scope_chain_t *scope)
302 scope_release(scope->next);
304 jsdisp_release(scope->obj);
308 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
309 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
313 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
315 return E_OUTOFMEMORY;
318 ctx->is_global = is_global;
321 ctx->this_obj = this_obj;
322 else if(script_ctx->host_global)
323 ctx->this_obj = script_ctx->host_global;
325 ctx->this_obj = to_disp(script_ctx->global);
326 IDispatch_AddRef(ctx->this_obj);
328 jsdisp_addref(var_disp);
329 ctx->var_disp = var_disp;
331 script_addref(script_ctx);
332 ctx->script = script_ctx;
336 ctx->scope_chain = scope;
343 void exec_release(exec_ctx_t *ctx)
349 scope_release(ctx->scope_chain);
351 jsdisp_release(ctx->var_disp);
353 IDispatch_Release(ctx->this_obj);
355 script_release(ctx->script);
356 heap_free(ctx->stack);
360 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
365 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
367 TRACE("using IDispatch\n");
370 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
374 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
375 IDispatchEx_Release(dispex);
379 static inline BOOL is_null(const VARIANT *v)
381 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
384 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
386 IObjectIdentity *identity;
387 IUnknown *unk1, *unk2;
395 if(!disp1 || !disp2) {
400 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
404 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
406 IUnknown_Release(unk1);
413 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
414 if(SUCCEEDED(hres)) {
415 hres = IObjectIdentity_IsEqualObject(identity, unk2);
416 IObjectIdentity_Release(identity);
423 IUnknown_Release(unk1);
424 IUnknown_Release(unk2);
428 /* ECMA-262 3rd Edition 11.9.6 */
429 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
433 if(V_VT(lval) != V_VT(rval)) {
434 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
435 *ret = num_val(lval) == num_val(rval);
436 else if(is_null(lval))
437 *ret = is_null(rval);
449 *ret = V_I4(lval) == V_I4(rval);
452 *ret = V_R8(lval) == V_R8(rval);
456 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
457 else if(!V_BSTR(rval))
458 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
460 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
463 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
465 *ret = !V_BOOL(lval) == !V_BOOL(rval);
468 FIXME("unimplemented vt %d\n", V_VT(lval));
475 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
481 for(item = ctx->named_items; item; item = item->next) {
482 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
483 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
484 if(SUCCEEDED(hres)) {
486 exprval_set_idref(ret, item->disp, id);
495 /* ECMA-262 3rd Edition 10.1.4 */
496 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
498 scope_chain_t *scope;
503 TRACE("%s\n", debugstr_w(identifier));
505 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
506 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
507 if(SUCCEEDED(hres)) {
508 exprval_set_idref(ret, to_disp(scope->obj), id);
513 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
514 if(SUCCEEDED(hres)) {
515 exprval_set_idref(ret, to_disp(ctx->global), id);
519 for(item = ctx->named_items; item; item = item->next) {
520 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
527 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
528 SCRIPTINFO_IUNKNOWN, &unk, NULL);
530 WARN("GetItemInfo failed: %08x\n", hres);
534 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
535 IUnknown_Release(unk);
537 WARN("object does not implement IDispatch\n");
542 ret->type = EXPRVAL_VARIANT;
543 V_VT(&ret->u.var) = VT_DISPATCH;
544 V_DISPATCH(&ret->u.var) = item->disp;
545 IDispatch_AddRef(item->disp);
550 if(lookup_global_members(ctx, identifier, ret))
553 ret->type = EXPRVAL_INVALID;
557 /* ECMA-262 3rd Edition 12.2 */
558 static HRESULT interp_var_set(exec_ctx_t *ctx)
560 const BSTR name = ctx->code->instrs[ctx->ip].arg1.bstr;
564 TRACE("%s\n", debugstr_w(name));
567 hres = jsdisp_propput_name(ctx->var_disp, name, v, ctx->ei);
572 /* ECMA-262 3rd Edition 12.6.4 */
573 static HRESULT interp_forin(exec_ctx_t *ctx)
575 const HRESULT arg = ctx->code->instrs[ctx->ip].arg1.uint;
576 IDispatch *var_obj, *obj = NULL;
585 val = stack_pop(ctx);
587 assert(V_VT(stack_top(ctx)) == VT_I4);
588 id = V_I4(stack_top(ctx));
590 var_obj = stack_topn_objid(ctx, 1, &var_id);
592 FIXME("invalid ref\n");
597 if(V_VT(stack_topn(ctx, 3)) == VT_DISPATCH)
598 obj = V_DISPATCH(stack_topn(ctx, 3));
601 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
602 if(SUCCEEDED(hres)) {
603 hres = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, id, &id);
605 hres = IDispatchEx_GetMemberName(dispex, id, &name);
606 IDispatchEx_Release(dispex);
612 TRACE("No IDispatchEx\n");
621 V_I4(stack_top(ctx)) = id;
625 hres = disp_propput(ctx->script, var_obj, var_id, &v, ctx->ei);
634 return stack_push(ctx, val);
639 /* ECMA-262 3rd Edition 12.10 */
640 static HRESULT interp_push_scope(exec_ctx_t *ctx)
650 hres = to_object(ctx->script, v, &disp);
655 obj = to_jsdisp(disp);
657 IDispatch_Release(disp);
658 FIXME("disp is not jsdisp\n");
662 hres = scope_push(ctx->scope_chain, obj, &ctx->scope_chain);
667 /* ECMA-262 3rd Edition 12.10 */
668 static HRESULT interp_pop_scope(exec_ctx_t *ctx)
672 scope_pop(&ctx->scope_chain);
676 /* ECMA-262 3rd Edition 12.13 */
677 static HRESULT interp_case(exec_ctx_t *ctx)
679 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
687 hres = equal2_values(stack_top(ctx), v, &b);
701 /* ECMA-262 3rd Edition 12.13 */
702 static HRESULT interp_throw(exec_ctx_t *ctx)
706 ctx->ei->var = *stack_pop(ctx);
707 return DISP_E_EXCEPTION;
710 static HRESULT interp_throw_ref(exec_ctx_t *ctx)
712 const HRESULT arg = ctx->code->instrs[ctx->ip].arg1.uint;
714 TRACE("%08x\n", arg);
716 return throw_reference_error(ctx->script, ctx->ei, arg, NULL);
719 static HRESULT interp_throw_type(exec_ctx_t *ctx)
721 const HRESULT hres = ctx->code->instrs[ctx->ip].arg1.uint;
722 const WCHAR *str = ctx->code->instrs[ctx->ip].arg2.str;
724 TRACE("%08x %s\n", hres, debugstr_w(str));
726 return throw_type_error(ctx->script, ctx->ei, hres, str);
729 /* ECMA-262 3rd Edition 12.14 */
730 static HRESULT interp_push_except(exec_ctx_t *ctx)
732 const unsigned arg1 = ctx->code->instrs[ctx->ip].arg1.uint;
733 const BSTR arg2 = ctx->code->instrs[ctx->ip].arg2.bstr;
734 except_frame_t *except;
739 stack_top = ctx->top;
744 hres = stack_push_bool(ctx, TRUE);
747 hres = stack_push_bool(ctx, TRUE);
752 except = heap_alloc(sizeof(*except));
754 return E_OUTOFMEMORY;
756 except->stack_top = stack_top;
757 except->scope = ctx->scope_chain;
758 except->catch_off = arg1;
759 except->ident = arg2;
760 except->next = ctx->except_frame;
761 ctx->except_frame = except;
765 /* ECMA-262 3rd Edition 12.14 */
766 static HRESULT interp_pop_except(exec_ctx_t *ctx)
768 except_frame_t *except;
772 except = ctx->except_frame;
773 assert(except != NULL);
775 ctx->except_frame = except->next;
780 /* ECMA-262 3rd Edition 12.14 */
781 static HRESULT interp_end_finally(exec_ctx_t *ctx)
789 assert(V_VT(stack_top(ctx)) == VT_BOOL);
790 if(!V_BOOL(stack_top(ctx))) {
791 TRACE("passing exception\n");
795 ctx->ei->var = *stack_pop(ctx);
796 return DISP_E_EXCEPTION;
800 return stack_push(ctx, v);
803 /* ECMA-262 3rd Edition 13 */
804 static HRESULT interp_func(exec_ctx_t *ctx)
806 unsigned func_idx = ctx->code->instrs[ctx->ip].arg1.uint;
807 function_expression_t *expr;
812 TRACE("%d\n", func_idx);
814 expr = ctx->func_code->funcs[func_idx].expr;
816 hres = create_source_function(ctx->script, ctx->code, expr->parameter_list, ctx->func_code->funcs+func_idx,
817 ctx->scope_chain, &dispex);
821 var_set_jsdisp(&v, dispex);
822 return stack_push(ctx, &v);
825 /* ECMA-262 3rd Edition 11.2.1 */
826 static HRESULT interp_array(exec_ctx_t *ctx)
836 namev = stack_pop(ctx);
838 hres = stack_pop_object(ctx, &obj);
844 hres = to_string(ctx->script, namev, ctx->ei, &name);
847 IDispatch_Release(obj);
851 hres = disp_get_id(ctx->script, obj, name, 0, &id);
853 if(SUCCEEDED(hres)) {
854 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
855 }else if(hres == DISP_E_UNKNOWNNAME) {
859 IDispatch_Release(obj);
863 return stack_push(ctx, &v);
866 /* ECMA-262 3rd Edition 11.2.1 */
867 static HRESULT interp_member(exec_ctx_t *ctx)
869 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
877 hres = stack_pop_object(ctx, &obj);
881 hres = disp_get_id(ctx->script, obj, arg, 0, &id);
882 if(SUCCEEDED(hres)) {
884 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
885 }else if(hres == DISP_E_UNKNOWNNAME) {
889 IDispatch_Release(obj);
893 return stack_push(ctx, &v);
896 /* ECMA-262 3rd Edition 11.2.1 */
897 static HRESULT interp_memberid(exec_ctx_t *ctx)
899 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.lng;
900 VARIANT *objv, *namev;
908 namev = stack_pop(ctx);
909 objv = stack_pop(ctx);
911 hres = to_object(ctx->script, objv, &obj);
913 if(SUCCEEDED(hres)) {
914 hres = to_string(ctx->script, namev, ctx->ei, &name);
916 IDispatch_Release(obj);
922 hres = disp_get_id(ctx->script, obj, name, arg, &id);
925 IDispatch_Release(obj);
926 if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
928 id = JS_E_INVALID_PROPERTY;
934 return stack_push_objid(ctx, obj, id);
937 /* ECMA-262 3rd Edition 11.2.1 */
938 static HRESULT interp_refval(exec_ctx_t *ctx)
947 disp = stack_topn_objid(ctx, 0, &id);
949 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
951 hres = disp_propget(ctx->script, disp, id, &v, ctx->ei);
955 return stack_push(ctx, &v);
958 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
964 dp->rgdispidNamedArgs = NULL;
967 assert(ctx->top >= arg_cnt);
969 for(i=1; i*2 <= arg_cnt; i++) {
970 tmp = ctx->stack[ctx->top-i];
971 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
972 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
975 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
978 /* ECMA-262 3rd Edition 11.2.2 */
979 static HRESULT interp_new(exec_ctx_t *ctx)
981 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
988 constr = stack_topn(ctx, arg);
990 /* NOTE: Should use to_object here */
992 if(V_VT(constr) == VT_NULL)
993 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
994 else if(V_VT(constr) != VT_DISPATCH)
995 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_ACTION, NULL);
996 else if(!V_DISPATCH(constr))
997 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
999 jsstack_to_dp(ctx, arg, &dp);
1000 hres = disp_call(ctx->script, V_DISPATCH(constr), DISPID_VALUE,
1001 DISPATCH_CONSTRUCT, &dp, &v, ctx->ei);
1005 stack_popn(ctx, arg+1);
1006 return stack_push(ctx, &v);
1009 /* ECMA-262 3rd Edition 11.2.3 */
1010 static HRESULT interp_call(exec_ctx_t *ctx)
1012 const unsigned argn = ctx->code->instrs[ctx->ip].arg1.uint;
1013 const int do_ret = ctx->code->instrs[ctx->ip].arg2.lng;
1018 TRACE("%d %d\n", argn, do_ret);
1020 objv = stack_topn(ctx, argn);
1021 if(V_VT(objv) != VT_DISPATCH)
1022 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1024 jsstack_to_dp(ctx, argn, &dp);
1025 hres = disp_call(ctx->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1026 do_ret ? &v : NULL, ctx->ei);
1030 stack_popn(ctx, argn+1);
1031 return do_ret ? stack_push(ctx, &v) : S_OK;
1035 /* ECMA-262 3rd Edition 11.2.3 */
1036 static HRESULT interp_call_member(exec_ctx_t *ctx)
1038 const unsigned argn = ctx->code->instrs[ctx->ip].arg1.uint;
1039 const int do_ret = ctx->code->instrs[ctx->ip].arg2.lng;
1046 TRACE("%d %d\n", argn, do_ret);
1048 obj = stack_topn_objid(ctx, argn, &id);
1050 return throw_type_error(ctx->script, ctx->ei, id, NULL);
1052 jsstack_to_dp(ctx, argn, &dp);
1053 hres = disp_call(ctx->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, ctx->ei);
1057 stack_popn(ctx, argn+2);
1058 return do_ret ? stack_push(ctx, &v) : S_OK;
1062 /* ECMA-262 3rd Edition 11.1.1 */
1063 static HRESULT interp_this(exec_ctx_t *ctx)
1069 V_VT(&v) = VT_DISPATCH;
1070 V_DISPATCH(&v) = ctx->this_obj;
1071 IDispatch_AddRef(ctx->this_obj);
1072 return stack_push(ctx, &v);
1075 /* ECMA-262 3rd Edition 10.1.4 */
1076 static HRESULT interp_ident(exec_ctx_t *ctx)
1078 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1083 TRACE("%s\n", debugstr_w(arg));
1085 hres = identifier_eval(ctx->script, arg, &exprval);
1089 if(exprval.type == EXPRVAL_INVALID)
1090 return throw_type_error(ctx->script, ctx->ei, JS_E_UNDEFINED_VARIABLE, arg);
1092 hres = exprval_to_value(ctx->script, &exprval, ctx->ei, &v);
1093 exprval_release(&exprval);
1097 return stack_push(ctx, &v);
1100 /* ECMA-262 3rd Edition 10.1.4 */
1101 static HRESULT interp_identid(exec_ctx_t *ctx)
1103 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1104 const unsigned flags = ctx->code->instrs[ctx->ip].arg2.uint;
1108 TRACE("%s %x\n", debugstr_w(arg), flags);
1110 hres = identifier_eval(ctx->script, arg, &exprval);
1114 if(exprval.type == EXPRVAL_INVALID && (flags & fdexNameEnsure)) {
1117 hres = jsdisp_get_id(ctx->script->global, arg, fdexNameEnsure, &id);
1121 exprval_set_idref(&exprval, to_disp(ctx->script->global), id);
1124 if(exprval.type != EXPRVAL_IDREF) {
1125 WARN("invalid ref\n");
1126 exprval_release(&exprval);
1127 return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1130 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1133 /* ECMA-262 3rd Edition 7.8.1 */
1134 static HRESULT interp_null(exec_ctx_t *ctx)
1141 return stack_push(ctx, &v);
1144 /* ECMA-262 3rd Edition 7.8.2 */
1145 static HRESULT interp_bool(exec_ctx_t *ctx)
1147 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
1149 TRACE("%s\n", arg ? "true" : "false");
1151 return stack_push_bool(ctx, arg);
1154 /* ECMA-262 3rd Edition 7.8.3 */
1155 static HRESULT interp_int(exec_ctx_t *ctx)
1157 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
1164 return stack_push(ctx, &v);
1167 /* ECMA-262 3rd Edition 7.8.3 */
1168 static HRESULT interp_double(exec_ctx_t *ctx)
1170 const double arg = *ctx->code->instrs[ctx->ip].arg1.dbl;
1173 TRACE("%lf\n", arg);
1177 return stack_push(ctx, &v);
1180 /* ECMA-262 3rd Edition 7.8.4 */
1181 static HRESULT interp_str(exec_ctx_t *ctx)
1183 const WCHAR *str = ctx->code->instrs[ctx->ip].arg1.str;
1186 TRACE("%s\n", debugstr_w(str));
1189 V_BSTR(&v) = SysAllocString(str);
1191 return E_OUTOFMEMORY;
1193 return stack_push(ctx, &v);
1196 /* ECMA-262 3rd Edition 7.8 */
1197 static HRESULT interp_regexp(exec_ctx_t *ctx)
1199 const WCHAR *source = ctx->code->instrs[ctx->ip].arg1.str;
1200 const LONG flags = ctx->code->instrs[ctx->ip].arg2.lng;
1205 TRACE("%s %x\n", debugstr_w(source), flags);
1207 hres = create_regexp(ctx->script, source, strlenW(source), flags, ®exp);
1211 var_set_jsdisp(&v, regexp);
1212 return stack_push(ctx, &v);
1215 /* ECMA-262 3rd Edition 11.1.4 */
1216 static HRESULT interp_carray(exec_ctx_t *ctx)
1218 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1226 hres = create_array(ctx->script, arg, &array);
1233 hres = jsdisp_propput_idx(array, i, v, ctx->ei);
1236 jsdisp_release(array);
1241 var_set_jsdisp(&r, array);
1242 return stack_push(ctx, &r);
1245 /* ECMA-262 3rd Edition 11.1.5 */
1246 static HRESULT interp_new_obj(exec_ctx_t *ctx)
1254 hres = create_object(ctx->script, NULL, &obj);
1258 var_set_jsdisp(&v, obj);
1259 return stack_push(ctx, &v);
1262 /* ECMA-262 3rd Edition 11.1.5 */
1263 static HRESULT interp_obj_prop(exec_ctx_t *ctx)
1265 const BSTR name = ctx->code->instrs[ctx->ip].arg1.bstr;
1270 TRACE("%s\n", debugstr_w(name));
1274 assert(V_VT(stack_top(ctx)) == VT_DISPATCH);
1275 obj = as_jsdisp(V_DISPATCH(stack_top(ctx)));
1277 hres = jsdisp_propput_name(obj, name, v, ctx->ei);
1282 /* ECMA-262 3rd Edition 11.11 */
1283 static HRESULT interp_cnd_nz(exec_ctx_t *ctx)
1285 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1291 hres = to_boolean(stack_top(ctx), &b);
1304 /* ECMA-262 3rd Edition 11.11 */
1305 static HRESULT interp_cnd_z(exec_ctx_t *ctx)
1307 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1313 hres = to_boolean(stack_top(ctx), &b);
1326 /* ECMA-262 3rd Edition 11.10 */
1327 static HRESULT interp_or(exec_ctx_t *ctx)
1334 hres = stack_pop_int(ctx, &r);
1338 hres = stack_pop_int(ctx, &l);
1342 return stack_push_int(ctx, l|r);
1345 /* ECMA-262 3rd Edition 11.10 */
1346 static HRESULT interp_xor(exec_ctx_t *ctx)
1353 hres = stack_pop_int(ctx, &r);
1357 hres = stack_pop_int(ctx, &l);
1361 return stack_push_int(ctx, l^r);
1364 /* ECMA-262 3rd Edition 11.10 */
1365 static HRESULT interp_and(exec_ctx_t *ctx)
1372 hres = stack_pop_int(ctx, &r);
1376 hres = stack_pop_int(ctx, &l);
1380 return stack_push_int(ctx, l&r);
1383 /* ECMA-262 3rd Edition 11.8.6 */
1384 static HRESULT interp_instanceof(exec_ctx_t *ctx)
1386 jsdisp_t *obj, *iter, *tmp = NULL;
1391 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
1394 if(V_VT(v) != VT_DISPATCH || !V_DISPATCH(v)) {
1396 return throw_type_error(ctx->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1399 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1400 IDispatch_Release(V_DISPATCH(v));
1402 FIXME("non-jsdisp objects not supported\n");
1406 if(is_class(obj, JSCLASS_FUNCTION)) {
1407 hres = jsdisp_propget_name(obj, prototypeW, &prot, ctx->ei);
1409 hres = throw_type_error(ctx->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1411 jsdisp_release(obj);
1417 if(V_VT(&prot) == VT_DISPATCH) {
1418 if(V_VT(v) == VT_DISPATCH)
1419 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1420 for(iter = tmp; !ret && iter; iter = iter->prototype) {
1421 hres = disp_cmp(V_DISPATCH(&prot), to_disp(iter), &ret);
1427 jsdisp_release(tmp);
1429 FIXME("prototype is not an object\n");
1433 VariantClear(&prot);
1438 return stack_push_bool(ctx, ret);
1441 /* ECMA-262 3rd Edition 11.8.7 */
1442 static HRESULT interp_in(exec_ctx_t *ctx)
1452 obj = stack_pop(ctx);
1455 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
1458 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1461 hres = to_string(ctx->script, v, ctx->ei, &str);
1464 IDispatch_Release(V_DISPATCH(obj));
1468 hres = disp_get_id(ctx->script, V_DISPATCH(obj), str, 0, &id);
1469 IDispatch_Release(V_DISPATCH(obj));
1473 else if(hres == DISP_E_UNKNOWNNAME)
1478 return stack_push_bool(ctx, ret);
1481 /* ECMA-262 3rd Edition 11.6.1 */
1482 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1487 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
1491 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
1497 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1498 BSTR lstr = NULL, rstr = NULL;
1500 if(V_VT(&l) == VT_BSTR)
1503 hres = to_string(ctx, &l, ei, &lstr);
1505 if(SUCCEEDED(hres)) {
1506 if(V_VT(&r) == VT_BSTR)
1509 hres = to_string(ctx, &r, ei, &rstr);
1512 if(SUCCEEDED(hres)) {
1515 len1 = SysStringLen(lstr);
1516 len2 = SysStringLen(rstr);
1518 V_VT(retv) = VT_BSTR;
1519 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1521 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1523 memcpy(V_BSTR(retv)+len1, rstr, len2*sizeof(WCHAR));
1524 V_BSTR(retv)[len1+len2] = 0;
1527 if(V_VT(&l) != VT_BSTR)
1528 SysFreeString(lstr);
1529 if(V_VT(&r) != VT_BSTR)
1530 SysFreeString(rstr);
1534 hres = to_number(ctx, &l, ei, &nl);
1535 if(SUCCEEDED(hres)) {
1536 hres = to_number(ctx, &r, ei, &nr);
1538 num_set_val(retv, nl + nr);
1547 /* ECMA-262 3rd Edition 11.6.1 */
1548 static HRESULT interp_add(exec_ctx_t *ctx)
1550 VARIANT *l, *r, ret;
1556 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
1558 hres = add_eval(ctx->script, l, r, ctx->ei, &ret);
1564 return stack_push(ctx, &ret);
1567 /* ECMA-262 3rd Edition 11.6.2 */
1568 static HRESULT interp_sub(exec_ctx_t *ctx)
1575 hres = stack_pop_number(ctx, &r);
1579 hres = stack_pop_number(ctx, &l);
1583 return stack_push_number(ctx, l-r);
1586 /* ECMA-262 3rd Edition 11.5.1 */
1587 static HRESULT interp_mul(exec_ctx_t *ctx)
1594 hres = stack_pop_number(ctx, &r);
1598 hres = stack_pop_number(ctx, &l);
1602 return stack_push_number(ctx, l*r);
1605 /* ECMA-262 3rd Edition 11.5.2 */
1606 static HRESULT interp_div(exec_ctx_t *ctx)
1613 hres = stack_pop_number(ctx, &r);
1617 hres = stack_pop_number(ctx, &l);
1621 return stack_push_number(ctx, l/r);
1624 /* ECMA-262 3rd Edition 11.5.3 */
1625 static HRESULT interp_mod(exec_ctx_t *ctx)
1632 hres = stack_pop_number(ctx, &r);
1636 hres = stack_pop_number(ctx, &l);
1640 return stack_push_number(ctx, fmod(l, r));
1643 /* ECMA-262 3rd Edition 11.4.2 */
1644 static HRESULT interp_delete(exec_ctx_t *ctx)
1646 VARIANT *obj_var, *name_var;
1647 IDispatchEx *dispex;
1655 name_var = stack_pop(ctx);
1656 obj_var = stack_pop(ctx);
1658 hres = to_object(ctx->script, obj_var, &obj);
1659 VariantClear(obj_var);
1661 VariantClear(name_var);
1665 hres = to_string(ctx->script, name_var, ctx->ei, &name);
1666 VariantClear(name_var);
1668 IDispatch_Release(obj);
1672 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
1673 if(SUCCEEDED(hres)) {
1674 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->script, fdexNameCaseSensitive));
1676 IDispatchEx_Release(dispex);
1682 IDispatch_Release(obj);
1683 SysFreeString(name);
1687 return stack_push_bool(ctx, ret);
1690 /* ECMA-262 3rd Edition 11.4.2 */
1691 static HRESULT interp_delete_ident(exec_ctx_t *ctx)
1693 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1694 IDispatchEx *dispex;
1699 TRACE("%s\n", debugstr_w(arg));
1701 hres = identifier_eval(ctx->script, arg, &exprval);
1705 if(exprval.type != EXPRVAL_IDREF) {
1706 FIXME("Unsupported exprval\n");
1707 exprval_release(&exprval);
1711 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
1712 IDispatch_Release(exprval.u.idref.disp);
1713 if(SUCCEEDED(hres)) {
1714 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
1715 IDispatchEx_Release(dispex);
1722 return stack_push_bool(ctx, ret);
1725 /* ECMA-262 3rd Edition 11.4.2 */
1726 static HRESULT interp_void(exec_ctx_t *ctx)
1734 V_VT(&v) = VT_EMPTY;
1735 return stack_push(ctx, &v);
1738 /* ECMA-262 3rd Edition 11.4.3 */
1739 static HRESULT typeof_string(VARIANT *v, const WCHAR **ret)
1761 if(V_DISPATCH(v) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(v)))) {
1762 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
1763 jsdisp_release(dispex);
1770 FIXME("unhandled vt %d\n", V_VT(v));
1777 /* ECMA-262 3rd Edition 11.4.3 */
1778 static HRESULT interp_typeofid(exec_ctx_t *ctx)
1786 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
1790 obj = stack_pop_objid(ctx, &id);
1792 return stack_push_string(ctx, undefinedW);
1794 V_VT(&v) = VT_EMPTY;
1795 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1796 IDispatch_Release(obj);
1798 return stack_push_string(ctx, unknownW);
1800 hres = typeof_string(&v, &ret);
1805 return stack_push_string(ctx, ret);
1808 /* ECMA-262 3rd Edition 11.4.3 */
1809 static HRESULT interp_typeofident(exec_ctx_t *ctx)
1811 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1817 TRACE("%s\n", debugstr_w(arg));
1819 hres = identifier_eval(ctx->script, arg, &exprval);
1823 if(exprval.type == EXPRVAL_INVALID) {
1824 hres = stack_push_string(ctx, undefinedW);
1825 exprval_release(&exprval);
1829 hres = exprval_to_value(ctx->script, &exprval, ctx->ei, &v);
1830 exprval_release(&exprval);
1834 hres = typeof_string(&v, &ret);
1839 return stack_push_string(ctx, ret);
1842 /* ECMA-262 3rd Edition 11.4.3 */
1843 static HRESULT interp_typeof(exec_ctx_t *ctx)
1852 hres = typeof_string(v, &ret);
1857 return stack_push_string(ctx, ret);
1860 /* ECMA-262 3rd Edition 11.4.7 */
1861 static HRESULT interp_minus(exec_ctx_t *ctx)
1868 hres = stack_pop_number(ctx, &n);
1872 return stack_push_number(ctx, -n);
1875 /* ECMA-262 3rd Edition 11.4.6 */
1876 static HRESULT interp_tonum(exec_ctx_t *ctx)
1885 hres = to_number(ctx->script, v, ctx->ei, &n);
1890 return stack_push_number(ctx, n);
1893 /* ECMA-262 3rd Edition 11.3.1 */
1894 static HRESULT interp_postinc(exec_ctx_t *ctx)
1896 const int arg = ctx->code->instrs[ctx->ip].arg1.lng;
1904 obj = stack_pop_objid(ctx, &id);
1906 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1908 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1909 if(SUCCEEDED(hres)) {
1913 hres = to_number(ctx->script, &v, ctx->ei, &n);
1914 if(SUCCEEDED(hres)) {
1915 num_set_val(&inc, n+(double)arg);
1916 hres = disp_propput(ctx->script, obj, id, &inc, ctx->ei);
1921 IDispatch_Release(obj);
1925 return stack_push(ctx, &v);
1928 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
1929 static HRESULT interp_preinc(exec_ctx_t *ctx)
1931 const int arg = ctx->code->instrs[ctx->ip].arg1.lng;
1939 obj = stack_pop_objid(ctx, &id);
1941 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1943 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1944 if(SUCCEEDED(hres)) {
1947 hres = to_number(ctx->script, &v, ctx->ei, &n);
1949 if(SUCCEEDED(hres)) {
1950 num_set_val(&v, n+(double)arg);
1951 hres = disp_propput(ctx->script, obj, id, &v, ctx->ei);
1954 IDispatch_Release(obj);
1958 return stack_push(ctx, &v);
1961 /* ECMA-262 3rd Edition 11.9.3 */
1962 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
1964 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
1965 return equal2_values(lval, rval, ret);
1967 /* FIXME: NULL disps should be handled in more general way */
1968 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
1971 return equal_values(ctx, &v, rval, ei, ret);
1974 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
1977 return equal_values(ctx, lval, &v, ei, ret);
1980 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
1981 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
1986 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
1991 hres = to_number(ctx, lval, ei, &n);
1995 /* FIXME: optimize */
1998 return equal_values(ctx, &v, rval, ei, ret);
2001 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2006 hres = to_number(ctx, rval, ei, &n);
2010 /* FIXME: optimize */
2013 return equal_values(ctx, lval, &v, ei, ret);
2016 if(V_VT(rval) == VT_BOOL) {
2020 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2021 return equal_values(ctx, lval, &v, ei, ret);
2024 if(V_VT(lval) == VT_BOOL) {
2028 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2029 return equal_values(ctx, &v, rval, ei, ret);
2033 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2037 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2041 hres = equal_values(ctx, lval, &v, ei, ret);
2048 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2052 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2056 hres = equal_values(ctx, &v, rval, ei, ret);
2067 /* ECMA-262 3rd Edition 11.9.1 */
2068 static HRESULT interp_eq(exec_ctx_t *ctx)
2077 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2079 hres = equal_values(ctx->script, l, r, ctx->ei, &b);
2085 return stack_push_bool(ctx, b);
2088 /* ECMA-262 3rd Edition 11.9.2 */
2089 static HRESULT interp_neq(exec_ctx_t *ctx)
2098 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2100 hres = equal_values(ctx->script, l, r, ctx->ei, &b);
2106 return stack_push_bool(ctx, !b);
2109 /* ECMA-262 3rd Edition 11.9.4 */
2110 static HRESULT interp_eq2(exec_ctx_t *ctx)
2121 hres = equal2_values(r, l, &b);
2127 return stack_push_bool(ctx, b);
2130 /* ECMA-262 3rd Edition 11.9.5 */
2131 static HRESULT interp_neq2(exec_ctx_t *ctx)
2142 hres = equal2_values(r, l, &b);
2148 return stack_push_bool(ctx, !b);
2151 /* ECMA-262 3rd Edition 11.8.5 */
2152 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2158 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2162 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2168 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2169 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2170 SysFreeString(V_BSTR(&l));
2171 SysFreeString(V_BSTR(&r));
2175 hres = to_number(ctx, &l, ei, &ln);
2178 hres = to_number(ctx, &r, ei, &rn);
2183 *ret = !isnan(ln) && !isnan(rn) && ((ln < rn) ^ greater);
2187 /* ECMA-262 3rd Edition 11.8.1 */
2188 static HRESULT interp_lt(exec_ctx_t *ctx)
2197 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2199 hres = less_eval(ctx->script, l, r, FALSE, ctx->ei, &b);
2205 return stack_push_bool(ctx, b);
2208 /* ECMA-262 3rd Edition 11.8.1 */
2209 static HRESULT interp_lteq(exec_ctx_t *ctx)
2218 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
2220 hres = less_eval(ctx->script, r, l, TRUE, ctx->ei, &b);
2226 return stack_push_bool(ctx, b);
2229 /* ECMA-262 3rd Edition 11.8.2 */
2230 static HRESULT interp_gt(exec_ctx_t *ctx)
2239 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
2241 hres = less_eval(ctx->script, r, l, FALSE, ctx->ei, &b);
2247 return stack_push_bool(ctx, b);
2250 /* ECMA-262 3rd Edition 11.8.4 */
2251 static HRESULT interp_gteq(exec_ctx_t *ctx)
2260 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
2262 hres = less_eval(ctx->script, l, r, TRUE, ctx->ei, &b);
2268 return stack_push_bool(ctx, b);
2271 /* ECMA-262 3rd Edition 11.4.8 */
2272 static HRESULT interp_bneg(exec_ctx_t *ctx)
2281 hres = to_int32(ctx->script, v, ctx->ei, &i);
2288 return stack_push(ctx, &r);
2291 /* ECMA-262 3rd Edition 11.4.9 */
2292 static HRESULT interp_neg(exec_ctx_t *ctx)
2301 hres = to_boolean(v, &b);
2306 return stack_push_bool(ctx, !b);
2309 /* ECMA-262 3rd Edition 11.7.1 */
2310 static HRESULT interp_lshift(exec_ctx_t *ctx)
2316 hres = stack_pop_uint(ctx, &r);
2320 hres = stack_pop_int(ctx, &l);
2324 return stack_push_int(ctx, l << (r&0x1f));
2327 /* ECMA-262 3rd Edition 11.7.2 */
2328 static HRESULT interp_rshift(exec_ctx_t *ctx)
2334 hres = stack_pop_uint(ctx, &r);
2338 hres = stack_pop_int(ctx, &l);
2342 return stack_push_int(ctx, l >> (r&0x1f));
2345 /* ECMA-262 3rd Edition 11.7.3 */
2346 static HRESULT interp_rshift2(exec_ctx_t *ctx)
2351 hres = stack_pop_uint(ctx, &r);
2355 hres = stack_pop_uint(ctx, &l);
2359 return stack_push_int(ctx, l >> (r&0x1f));
2362 /* ECMA-262 3rd Edition 11.13.1 */
2363 static HRESULT interp_assign(exec_ctx_t *ctx)
2373 disp = stack_pop_objid(ctx, &id);
2376 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
2378 hres = disp_propput(ctx->script, disp, id, v, ctx->ei);
2379 IDispatch_Release(disp);
2385 return stack_push(ctx, v);
2388 /* JScript extension */
2389 static HRESULT interp_assign_call(exec_ctx_t *ctx)
2391 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2392 DISPID propput_dispid = DISPID_PROPERTYPUT;
2401 disp = stack_topn_objid(ctx, arg+1, &id);
2403 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
2405 jsstack_to_dp(ctx, arg+1, &dp);
2407 dp.rgdispidNamedArgs = &propput_dispid;
2408 hres = disp_call(ctx->script, disp, id, DISPATCH_PROPERTYPUT, &dp, NULL, ctx->ei);
2413 stack_popn(ctx, arg+2);
2414 return stack_push(ctx, v);
2417 static HRESULT interp_undefined(exec_ctx_t *ctx)
2423 V_VT(&v) = VT_EMPTY;
2424 return stack_push(ctx, &v);
2427 static HRESULT interp_jmp(exec_ctx_t *ctx)
2429 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2437 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2439 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2447 hres = to_boolean(v, &b);
2459 static HRESULT interp_pop(exec_ctx_t *ctx)
2467 static HRESULT interp_ret(exec_ctx_t *ctx)
2475 typedef HRESULT (*op_func_t)(exec_ctx_t*);
2477 static const op_func_t op_funcs[] = {
2478 #define X(x,a,b,c) interp_##x,
2483 static const unsigned op_move[] = {
2484 #define X(a,x,b,c) x,
2489 static HRESULT unwind_exception(exec_ctx_t *ctx)
2491 except_frame_t *except_frame;
2496 except_frame = ctx->except_frame;
2497 ctx->except_frame = except_frame->next;
2499 assert(except_frame->stack_top <= ctx->top);
2500 stack_popn(ctx, ctx->top - except_frame->stack_top);
2502 while(except_frame->scope != ctx->scope_chain)
2503 scope_pop(&ctx->scope_chain);
2505 ctx->ip = except_frame->catch_off;
2507 except_val = ctx->ei->var;
2508 memset(ctx->ei, 0, sizeof(*ctx->ei));
2510 ident = except_frame->ident;
2511 heap_free(except_frame);
2514 jsdisp_t *scope_obj;
2516 hres = create_dispex(ctx->script, NULL, NULL, &scope_obj);
2517 if(SUCCEEDED(hres)) {
2518 hres = jsdisp_propput_name(scope_obj, ident, &except_val, ctx->ei);
2520 jsdisp_release(scope_obj);
2522 VariantClear(&except_val);
2526 hres = scope_push(ctx->scope_chain, scope_obj, &ctx->scope_chain);
2527 jsdisp_release(scope_obj);
2531 hres = stack_push(ctx, &except_val);
2535 hres = stack_push_bool(ctx, FALSE);
2539 V_VT(&v) = VT_EMPTY;
2540 hres = stack_push(ctx, &v);
2546 static HRESULT enter_bytecode(script_ctx_t *ctx, bytecode_t *code, function_code_t *func, jsexcept_t *ei, VARIANT *ret)
2548 exec_ctx_t *exec_ctx = ctx->exec_ctx;
2549 except_frame_t *prev_except_frame;
2550 function_code_t *prev_func;
2551 unsigned prev_ip, prev_top;
2552 scope_chain_t *prev_scope;
2553 bytecode_t *prev_code;
2554 jsexcept_t *prev_ei;
2556 HRESULT hres = S_OK;
2560 prev_top = exec_ctx->top;
2561 prev_scope = exec_ctx->scope_chain;
2562 prev_except_frame = exec_ctx->except_frame;
2563 prev_ip = exec_ctx->ip;
2564 prev_ei = exec_ctx->ei;
2565 prev_code = exec_ctx->code;
2566 prev_func = exec_ctx->func_code;
2567 exec_ctx->ip = func->instr_off;
2569 exec_ctx->except_frame = NULL;
2570 exec_ctx->code = code;
2571 exec_ctx->func_code = func;
2573 while(exec_ctx->ip != -1) {
2574 op = code->instrs[exec_ctx->ip].op;
2575 hres = op_funcs[op](exec_ctx);
2577 TRACE("EXCEPTION\n");
2579 if(!exec_ctx->except_frame)
2582 hres = unwind_exception(exec_ctx);
2586 exec_ctx->ip += op_move[op];
2590 exec_ctx->ip = prev_ip;
2591 exec_ctx->ei = prev_ei;
2592 exec_ctx->except_frame = prev_except_frame;
2593 exec_ctx->code = prev_code;
2594 exec_ctx->func_code = prev_func;
2597 while(exec_ctx->scope_chain != prev_scope)
2598 scope_pop(&exec_ctx->scope_chain);
2599 stack_popn(exec_ctx, exec_ctx->top-prev_top);
2603 assert(exec_ctx->top == prev_top+1 || exec_ctx->top == prev_top);
2604 assert(exec_ctx->scope_chain == prev_scope);
2606 if(exec_ctx->top == prev_top)
2607 V_VT(ret) = VT_EMPTY;
2609 *ret = *stack_pop(exec_ctx);
2613 HRESULT exec_source(exec_ctx_t *ctx, bytecode_t *code, function_code_t *func, BOOL from_eval,
2614 jsexcept_t *ei, VARIANT *retv)
2616 exec_ctx_t *prev_ctx;
2620 HRESULT hres = S_OK;
2622 for(i = 0; i < func->func_cnt; i++) {
2623 function_expression_t *expr;
2627 if(!func->funcs[i].name)
2630 expr = func->funcs[i].expr;
2631 hres = create_source_function(ctx->script, code, expr->parameter_list, func->funcs+i,
2632 ctx->scope_chain, &func_obj);
2636 var_set_jsdisp(&var, func_obj);
2637 hres = jsdisp_propput_name(ctx->var_disp, func->funcs[i].name, &var, ei);
2638 jsdisp_release(func_obj);
2643 for(var = func->source_elements->variables; var; var = var->next) {
2647 name = SysAllocString(var->identifier);
2649 return E_OUTOFMEMORY;
2651 if(!ctx->is_global || !lookup_global_members(ctx->script, name, NULL))
2652 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
2653 SysFreeString(name);
2658 prev_ctx = ctx->script->exec_ctx;
2659 ctx->script->exec_ctx = ctx;
2661 hres = enter_bytecode(ctx->script, code, func, ei, &val);
2662 assert(ctx->script->exec_ctx == ctx);
2663 ctx->script->exec_ctx = prev_ctx;