2 * Copyright 2008 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 #define EXPR_NOVAL 0x0001
33 #define EXPR_NEWREF 0x0002
35 struct _return_type_t {
45 static inline HRESULT stat_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
47 return stat->eval(ctx, stat, rt, ret);
50 static inline HRESULT expr_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
52 return expr->eval(ctx, expr, flags, ei, ret);
55 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
57 if(!ctx->stack_size) {
58 ctx->stack = heap_alloc(16*sizeof(VARIANT));
62 }else if(ctx->stack_size == ctx->top) {
65 new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(VARIANT));
71 ctx->stack = new_stack;
75 ctx->stack[ctx->top++] = *v;
79 static HRESULT stack_push_bool(exec_ctx_t *ctx, BOOL b)
84 V_BOOL(&v) = b ? VARIANT_TRUE : VARIANT_FALSE;
85 return stack_push(ctx, &v);
88 static inline HRESULT stack_push_number(exec_ctx_t *ctx, double number)
92 num_set_val(&v, number);
93 return stack_push(ctx, &v);
96 static inline HRESULT stack_push_int(exec_ctx_t *ctx, INT n)
102 return stack_push(ctx, &v);
105 static HRESULT stack_push_objid(exec_ctx_t *ctx, IDispatch *disp, DISPID id)
110 V_VT(&v) = VT_DISPATCH;
111 V_DISPATCH(&v) = disp;
112 hres = stack_push(ctx, &v);
118 return stack_push(ctx, &v);
121 static inline VARIANT *stack_top(exec_ctx_t *ctx)
124 return ctx->stack + ctx->top-1;
127 static inline VARIANT *stack_topn(exec_ctx_t *ctx, unsigned n)
129 assert(ctx->top > n);
130 return ctx->stack + ctx->top-1-n;
133 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
136 return ctx->stack + --ctx->top;
139 static void stack_popn(exec_ctx_t *ctx, unsigned n)
142 VariantClear(stack_pop(ctx));
145 static HRESULT stack_pop_number(exec_ctx_t *ctx, VARIANT *r)
151 hres = to_number(ctx->parser->script, v, &ctx->ei, r);
156 static HRESULT stack_pop_object(exec_ctx_t *ctx, IDispatch **r)
162 if(V_VT(v) == VT_DISPATCH) {
167 hres = to_object(ctx->parser->script, v, r);
172 static inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
174 return to_int32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
177 static inline HRESULT stack_pop_uint(exec_ctx_t *ctx, DWORD *r)
179 return to_uint32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
182 static inline IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
184 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
186 *id = V_INT(stack_pop(ctx));
187 return V_DISPATCH(stack_pop(ctx));
190 static inline IDispatch *stack_topn_objid(exec_ctx_t *ctx, unsigned n, DISPID *id)
192 assert(V_VT(stack_topn(ctx, n)) == VT_INT && V_VT(stack_topn(ctx, n+1)) == VT_DISPATCH);
194 *id = V_INT(stack_topn(ctx, n));
195 return V_DISPATCH(stack_topn(ctx, n+1));
198 static void exprval_release(exprval_t *val)
201 case EXPRVAL_VARIANT:
202 if(V_VT(&val->u.var) != VT_EMPTY)
203 VariantClear(&val->u.var);
206 if(val->u.idref.disp)
207 IDispatch_Release(val->u.idref.disp);
209 case EXPRVAL_INVALID:
210 SysFreeString(val->u.identifier);
214 /* ECMA-262 3rd Edition 8.7.1 */
215 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
217 V_VT(ret) = VT_EMPTY;
220 case EXPRVAL_VARIANT:
221 return VariantCopy(ret, &val->u.var);
223 if(!val->u.idref.disp) {
224 FIXME("throw ReferenceError\n");
228 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
229 case EXPRVAL_INVALID:
230 return throw_type_error(ctx, ei, JS_E_UNDEFINED_VARIABLE, val->u.identifier);
233 ERR("type %d\n", val->type);
237 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
239 if(val->type == EXPRVAL_VARIANT) {
241 V_VT(&val->u.var) = VT_EMPTY;
245 return exprval_value(ctx, val, ei, ret);
248 static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
250 if(exprval->type != EXPRVAL_VARIANT) {
254 hres = exprval_to_value(ctx, exprval, ei, &val);
258 hres = to_boolean(&val, b);
263 return to_boolean(&exprval->u.var, b);
266 static void exprval_init(exprval_t *val)
268 val->type = EXPRVAL_VARIANT;
269 V_VT(&val->u.var) = VT_EMPTY;
272 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
274 val->type = EXPRVAL_IDREF;
275 val->u.idref.disp = disp;
276 val->u.idref.id = id;
279 IDispatch_AddRef(disp);
282 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
284 scope_chain_t *new_scope;
286 new_scope = heap_alloc(sizeof(scope_chain_t));
288 return E_OUTOFMEMORY;
293 new_scope->obj = obj;
297 new_scope->next = scope;
299 new_scope->next = NULL;
306 static void scope_pop(scope_chain_t **scope)
315 void scope_release(scope_chain_t *scope)
321 scope_release(scope->next);
323 jsdisp_release(scope->obj);
327 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
328 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
332 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
334 return E_OUTOFMEMORY;
337 ctx->is_global = is_global;
340 ctx->this_obj = this_obj;
341 else if(script_ctx->host_global)
342 ctx->this_obj = script_ctx->host_global;
344 ctx->this_obj = to_disp(script_ctx->global);
345 IDispatch_AddRef(ctx->this_obj);
347 jsdisp_addref(var_disp);
348 ctx->var_disp = var_disp;
352 ctx->scope_chain = scope;
359 void exec_release(exec_ctx_t *ctx)
365 scope_release(ctx->scope_chain);
367 jsdisp_release(ctx->var_disp);
369 IDispatch_Release(ctx->this_obj);
370 heap_free(ctx->stack);
374 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
379 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
381 TRACE("unsing IDispatch\n");
384 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
388 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
389 IDispatchEx_Release(dispex);
393 /* ECMA-262 3rd Edition 8.7.2 */
394 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
396 if(ref->type != EXPRVAL_IDREF)
397 return throw_reference_error(ctx, ei, JS_E_ILLEGAL_ASSIGN, NULL);
399 return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
402 static inline BOOL is_null(const VARIANT *v)
404 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
407 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
409 IObjectIdentity *identity;
410 IUnknown *unk1, *unk2;
418 if(!disp1 || !disp2) {
423 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
427 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
429 IUnknown_Release(unk1);
436 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
437 if(SUCCEEDED(hres)) {
438 hres = IObjectIdentity_IsEqualObject(identity, unk2);
439 IObjectIdentity_Release(identity);
446 IUnknown_Release(unk1);
447 IUnknown_Release(unk2);
451 /* ECMA-262 3rd Edition 11.9.6 */
452 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
456 if(V_VT(lval) != V_VT(rval)) {
457 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
458 *ret = num_val(lval) == num_val(rval);
459 else if(is_null(lval))
460 *ret = is_null(rval);
472 *ret = V_I4(lval) == V_I4(rval);
475 *ret = V_R8(lval) == V_R8(rval);
479 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
480 else if(!V_BSTR(rval))
481 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
483 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
486 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
488 *ret = !V_BOOL(lval) == !V_BOOL(rval);
491 FIXME("unimplemented vt %d\n", V_VT(lval));
498 static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
500 switch(literal->type) {
506 V_I4(v) = literal->u.lval;
510 V_R8(v) = literal->u.dval;
513 BSTR str = SysAllocString(literal->u.wstr);
515 return E_OUTOFMEMORY;
523 V_BOOL(v) = literal->u.bval;
529 hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
530 literal->u.regexp.flags, ®exp);
534 var_set_jsdisp(v, regexp);
541 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
547 for(item = ctx->named_items; item; item = item->next) {
548 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
549 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
550 if(SUCCEEDED(hres)) {
552 exprval_set_idref(ret, item->disp, id);
561 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, BOOL from_eval,
562 jsexcept_t *ei, VARIANT *retv)
564 script_ctx_t *script = parser->script;
565 function_declaration_t *func;
566 parser_ctx_t *prev_parser;
570 exec_ctx_t *prev_ctx;
574 for(func = source->functions; func; func = func->next) {
578 hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
579 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
583 var_set_jsdisp(&var, func_obj);
584 hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
585 jsdisp_release(func_obj);
590 for(var = source->variables; var; var = var->next) {
594 name = SysAllocString(var->identifier);
596 return E_OUTOFMEMORY;
598 if(!ctx->is_global || !lookup_global_members(parser->script, name, NULL))
599 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
605 prev_ctx = script->exec_ctx;
606 script->exec_ctx = ctx;
608 prev_parser = ctx->parser;
609 ctx->parser = parser;
611 V_VT(&val) = VT_EMPTY;
612 memset(&rt, 0, sizeof(rt));
615 for(stat = source->statement; stat; stat = stat->next) {
616 hres = stat_eval(script, stat, &rt, &tmp);
622 if(rt.type != RT_NORMAL)
626 script->exec_ctx = prev_ctx;
627 ctx->parser = prev_parser;
629 if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
630 FIXME("wrong rt %d\n", rt.type);
640 if(!retv || (!from_eval && rt.type != RT_RETURN))
647 /* ECMA-262 3rd Edition 10.1.4 */
648 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
650 scope_chain_t *scope;
655 TRACE("%s\n", debugstr_w(identifier));
657 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
658 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
659 if(SUCCEEDED(hres)) {
660 exprval_set_idref(ret, to_disp(scope->obj), id);
665 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
666 if(SUCCEEDED(hres)) {
667 exprval_set_idref(ret, to_disp(ctx->global), id);
671 for(item = ctx->named_items; item; item = item->next) {
672 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
679 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
680 SCRIPTINFO_IUNKNOWN, &unk, NULL);
682 WARN("GetItemInfo failed: %08x\n", hres);
686 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
687 IUnknown_Release(unk);
689 WARN("object does not implement IDispatch\n");
694 ret->type = EXPRVAL_VARIANT;
695 V_VT(&ret->u.var) = VT_DISPATCH;
696 V_DISPATCH(&ret->u.var) = item->disp;
697 IDispatch_AddRef(item->disp);
702 if(lookup_global_members(ctx, identifier, ret))
705 if(flags & EXPR_NEWREF) {
706 hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
710 exprval_set_idref(ret, to_disp(ctx->global), id);
714 ret->type = EXPRVAL_INVALID;
715 ret->u.identifier = SysAllocString(identifier);
716 if(!ret->u.identifier)
717 return E_OUTOFMEMORY;
722 /* ECMA-262 3rd Edition 12.1 */
723 HRESULT block_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
725 block_statement_t *stat = (block_statement_t*)_stat;
732 V_VT(&val) = VT_EMPTY;
733 for(iter = stat->stat_list; iter; iter = iter->next) {
734 hres = stat_eval(ctx, iter, rt, &tmp);
740 if(rt->type != RT_NORMAL)
753 /* ECMA-262 3rd Edition 12.2 */
754 static HRESULT variable_list_eval(script_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
756 variable_declaration_t *iter;
759 for(iter = var_list; iter; iter = iter->next) {
766 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
770 hres = exprval_to_value(ctx, &exprval, ei, &val);
771 exprval_release(&exprval);
775 hres = jsdisp_propput_name(ctx->exec_ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
784 /* ECMA-262 3rd Edition 12.2 */
785 HRESULT var_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
787 var_statement_t *stat = (var_statement_t*)_stat;
792 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
796 V_VT(ret) = VT_EMPTY;
800 /* ECMA-262 3rd Edition 12.3 */
801 HRESULT empty_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
805 V_VT(ret) = VT_EMPTY;
809 /* ECMA-262 3rd Edition 12.4 */
810 HRESULT expression_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
812 expression_statement_t *stat = (expression_statement_t*)_stat;
819 hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
823 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
824 exprval_release(&exprval);
829 TRACE("= %s\n", debugstr_variant(ret));
833 /* ECMA-262 3rd Edition 12.5 */
834 HRESULT if_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
836 if_statement_t *stat = (if_statement_t*)_stat;
843 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
847 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
848 exprval_release(&exprval);
853 hres = stat_eval(ctx, stat->if_stat, rt, ret);
854 else if(stat->else_stat)
855 hres = stat_eval(ctx, stat->else_stat, rt, ret);
857 V_VT(ret) = VT_EMPTY;
862 /* ECMA-262 3rd Edition 12.6.2 */
863 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
865 while_statement_t *stat = (while_statement_t*)_stat;
874 V_VT(&val) = VT_EMPTY;
875 test_expr = !stat->do_while;
879 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
883 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
884 exprval_release(&exprval);
885 if(FAILED(hres) || !b)
891 hres = stat_eval(ctx, stat->statement, rt, &tmp);
898 if(rt->type == RT_CONTINUE)
899 rt->type = RT_NORMAL;
900 if(rt->type != RT_NORMAL)
909 if(rt->type == RT_BREAK)
910 rt->type = RT_NORMAL;
916 /* ECMA-262 3rd Edition 12.6.3 */
917 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
919 for_statement_t *stat = (for_statement_t*)_stat;
920 VARIANT val, tmp, retv;
927 if(stat->variable_list) {
928 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
931 }else if(stat->begin_expr) {
932 hres = expr_eval(ctx, stat->begin_expr, EXPR_NEWREF, &rt->ei, &exprval);
936 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
937 exprval_release(&exprval);
944 V_VT(&retv) = VT_EMPTY;
948 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
952 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
953 exprval_release(&exprval);
954 if(FAILED(hres) || !b)
958 hres = stat_eval(ctx, stat->statement, rt, &tmp);
965 if(rt->type == RT_CONTINUE)
966 rt->type = RT_NORMAL;
967 else if(rt->type != RT_NORMAL)
971 hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
975 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
976 exprval_release(&exprval);
989 if(rt->type == RT_BREAK)
990 rt->type = RT_NORMAL;
996 /* ECMA-262 3rd Edition 12.6.4 */
997 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
999 forin_statement_t *stat = (forin_statement_t*)_stat;
1000 VARIANT val, name, retv, tmp;
1001 DISPID id = DISPID_STARTENUM;
1002 BSTR str, identifier = NULL;
1003 IDispatchEx *in_obj;
1009 if(stat->variable) {
1010 hres = variable_list_eval(ctx, stat->variable, &rt->ei);
1015 hres = expr_eval(ctx, stat->in_expr, EXPR_NEWREF, &rt->ei, &exprval);
1019 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1020 exprval_release(&exprval);
1024 if(V_VT(&val) != VT_DISPATCH) {
1025 TRACE("in vt %d\n", V_VT(&val));
1027 V_VT(ret) = VT_EMPTY;
1031 hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
1032 IDispatch_Release(V_DISPATCH(&val));
1034 TRACE("Object doesn't support IDispatchEx\n");
1035 V_VT(ret) = VT_EMPTY;
1039 V_VT(&retv) = VT_EMPTY;
1042 identifier = SysAllocString(stat->variable->identifier);
1045 hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
1046 if(FAILED(hres) || hres == S_FALSE)
1049 hres = IDispatchEx_GetMemberName(in_obj, id, &str);
1053 TRACE("iter %s\n", debugstr_w(str));
1056 hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
1058 hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
1059 if(SUCCEEDED(hres)) {
1060 V_VT(&name) = VT_BSTR;
1061 V_BSTR(&name) = str;
1062 hres = put_value(ctx, &exprval, &name, &rt->ei);
1063 exprval_release(&exprval);
1069 hres = stat_eval(ctx, stat->statement, rt, &tmp);
1073 VariantClear(&retv);
1076 if(rt->type == RT_CONTINUE)
1077 rt->type = RT_NORMAL;
1078 else if(rt->type != RT_NORMAL)
1082 SysFreeString(identifier);
1083 IDispatchEx_Release(in_obj);
1085 VariantClear(&retv);
1089 if(rt->type == RT_BREAK)
1090 rt->type = RT_NORMAL;
1096 /* ECMA-262 3rd Edition 12.7 */
1097 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1099 branch_statement_t *stat = (branch_statement_t*)_stat;
1103 if(stat->identifier) {
1104 FIXME("indentifier not implemented\n");
1108 rt->type = RT_CONTINUE;
1109 V_VT(ret) = VT_EMPTY;
1113 /* ECMA-262 3rd Edition 12.8 */
1114 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1116 branch_statement_t *stat = (branch_statement_t*)_stat;
1120 if(stat->identifier) {
1121 FIXME("indentifier not implemented\n");
1125 rt->type = RT_BREAK;
1126 V_VT(ret) = VT_EMPTY;
1130 /* ECMA-262 3rd Edition 12.9 */
1131 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1133 expression_statement_t *stat = (expression_statement_t*)_stat;
1141 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1145 hres = exprval_to_value(ctx, &exprval, &rt->ei, ret);
1146 exprval_release(&exprval);
1150 V_VT(ret) = VT_EMPTY;
1153 TRACE("= %s\n", debugstr_variant(ret));
1154 rt->type = RT_RETURN;
1158 /* ECMA-262 3rd Edition 12.10 */
1159 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1161 with_statement_t *stat = (with_statement_t*)_stat;
1170 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1174 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1175 exprval_release(&exprval);
1179 hres = to_object(ctx, &val, &disp);
1184 obj = iface_to_jsdisp((IUnknown*)disp);
1185 IDispatch_Release(disp);
1187 FIXME("disp id not jsdisp\n");
1191 hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1192 jsdisp_release(obj);
1196 hres = stat_eval(ctx, stat->statement, rt, ret);
1198 scope_pop(&ctx->exec_ctx->scope_chain);
1202 /* ECMA-262 3rd Edition 12.12 */
1203 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1209 /* ECMA-262 3rd Edition 12.13 */
1210 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1212 switch_statement_t *stat = (switch_statement_t*)_stat;
1213 case_clausule_t *iter, *default_clausule = NULL;
1214 statement_t *stat_iter;
1222 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1226 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1227 exprval_release(&exprval);
1231 for(iter = stat->case_list; iter; iter = iter->next) {
1233 default_clausule = iter;
1237 hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
1241 hres = exprval_to_value(ctx, &exprval, &rt->ei, &cval);
1242 exprval_release(&exprval);
1246 hres = equal2_values(&val, &cval, &b);
1247 VariantClear(&cval);
1248 if(FAILED(hres) || b)
1257 iter = default_clausule;
1259 V_VT(&val) = VT_EMPTY;
1263 for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1264 hres = stat_eval(ctx, stat_iter, rt, &tmp);
1271 if(rt->type != RT_NORMAL)
1281 if(rt->type == RT_BREAK)
1282 rt->type = RT_NORMAL;
1288 /* ECMA-262 3rd Edition 12.13 */
1289 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1291 expression_statement_t *stat = (expression_statement_t*)_stat;
1298 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1302 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1303 exprval_release(&exprval);
1308 return DISP_E_EXCEPTION;
1311 static HRESULT interp_throw(exec_ctx_t *ctx)
1313 const HRESULT arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1315 TRACE("%08x\n", arg);
1317 return throw_reference_error(ctx->parser->script, &ctx->ei, arg, NULL);
1320 /* ECMA-262 3rd Edition 12.14 */
1321 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1328 memset(&rt->ei, 0, sizeof(jsexcept_t));
1330 hres = create_dispex(ctx, NULL, NULL, &var_disp);
1331 if(SUCCEEDED(hres)) {
1332 hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1333 if(SUCCEEDED(hres)) {
1334 hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1335 if(SUCCEEDED(hres)) {
1336 hres = stat_eval(ctx, block->statement, rt, &val);
1337 scope_pop(&ctx->exec_ctx->scope_chain);
1341 jsdisp_release(var_disp);
1352 /* ECMA-262 3rd Edition 12.14 */
1353 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1355 try_statement_t *stat = (try_statement_t*)_stat;
1361 hres = stat_eval(ctx, stat->try_statement, rt, &val);
1363 TRACE("EXCEPTION\n");
1364 if(!stat->catch_block)
1367 hres = catch_eval(ctx, stat->catch_block, rt, &val);
1372 if(stat->finally_statement) {
1374 hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1383 static HRESULT return_bool(exprval_t *ret, DWORD b)
1385 ret->type = EXPRVAL_VARIANT;
1386 V_VT(&ret->u.var) = VT_BOOL;
1387 V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1392 static HRESULT get_binary_expr_values(script_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
1397 hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1401 hres = exprval_to_value(ctx, &exprval, ei, lval);
1402 exprval_release(&exprval);
1406 hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1407 if(SUCCEEDED(hres)) {
1408 hres = exprval_to_value(ctx, &exprval, ei, rval);
1409 exprval_release(&exprval);
1420 typedef HRESULT (*oper_t)(script_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
1422 static HRESULT binary_expr_eval(script_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
1425 VARIANT lval, rval, retv;
1428 hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1432 hres = oper(ctx, &lval, &rval, ei, &retv);
1433 VariantClear(&lval);
1434 VariantClear(&rval);
1438 ret->type = EXPRVAL_VARIANT;
1443 /* ECMA-262 3rd Edition 11.13.2 */
1444 static HRESULT assign_oper_eval(script_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1445 jsexcept_t *ei, exprval_t *ret)
1447 VARIANT retv, lval, rval;
1448 exprval_t exprval, exprvalr;
1451 hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1455 hres = exprval_value(ctx, &exprval, ei, &lval);
1456 if(SUCCEEDED(hres)) {
1457 hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1458 if(SUCCEEDED(hres)) {
1459 hres = exprval_value(ctx, &exprvalr, ei, &rval);
1460 exprval_release(&exprvalr);
1462 if(SUCCEEDED(hres)) {
1463 hres = oper(ctx, &lval, &rval, ei, &retv);
1464 VariantClear(&rval);
1466 VariantClear(&lval);
1469 if(SUCCEEDED(hres)) {
1470 hres = put_value(ctx, &exprval, &retv, ei);
1472 VariantClear(&retv);
1474 exprval_release(&exprval);
1479 ret->type = EXPRVAL_VARIANT;
1484 /* ECMA-262 3rd Edition 13 */
1485 HRESULT function_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1487 function_expression_t *expr = (function_expression_t*)_expr;
1493 if(expr->identifier) {
1494 hres = jsdisp_propget_name(ctx->exec_ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
1500 hres = create_source_function(ctx->exec_ctx->parser, expr->parameter_list, expr->source_elements, ctx->exec_ctx->scope_chain,
1501 expr->src_str, expr->src_len, &dispex);
1505 var_set_jsdisp(&var, dispex);
1508 ret->type = EXPRVAL_VARIANT;
1513 /* ECMA-262 3rd Edition 11.2.1 */
1514 HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1516 binary_expression_t *expr = (binary_expression_t*)_expr;
1518 VARIANT member, val;
1521 IDispatch *obj = NULL;
1526 hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1530 hres = exprval_to_value(ctx, &exprval, ei, &member);
1531 exprval_release(&exprval);
1535 hres = expr_eval(ctx, expr->expression2, EXPR_NEWREF, ei, &exprval);
1536 if(SUCCEEDED(hres)) {
1537 hres = exprval_to_value(ctx, &exprval, ei, &val);
1538 exprval_release(&exprval);
1541 if(SUCCEEDED(hres)) {
1542 hres = to_object(ctx, &member, &obj);
1546 VariantClear(&member);
1547 if(SUCCEEDED(hres)) {
1548 hres = to_string(ctx, &val, ei, &str);
1550 if(SUCCEEDED(hres)) {
1551 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1555 if(SUCCEEDED(hres)) {
1556 exprval_set_idref(ret, obj, id);
1557 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1562 IDispatch_Release(obj);
1568 /* ECMA-262 3rd Edition 11.2.1 */
1569 static HRESULT interp_array(exec_ctx_t *ctx)
1579 namev = stack_pop(ctx);
1581 hres = stack_pop_object(ctx, &obj);
1583 VariantClear(namev);
1587 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1588 VariantClear(namev);
1590 IDispatch_Release(obj);
1594 hres = disp_get_id(ctx->parser->script, obj, name, 0, &id);
1595 SysFreeString(name);
1596 if(SUCCEEDED(hres)) {
1597 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1598 }else if(hres == DISP_E_UNKNOWNNAME) {
1599 V_VT(&v) = VT_EMPTY;
1602 IDispatch_Release(obj);
1606 return stack_push(ctx, &v);
1609 /* ECMA-262 3rd Edition 11.2.1 */
1610 HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1612 member_expression_t *expr = (member_expression_t*)_expr;
1613 IDispatch *obj = NULL;
1622 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1626 hres = exprval_to_value(ctx, &exprval, ei, &member);
1627 exprval_release(&exprval);
1631 hres = to_object(ctx, &member, &obj);
1632 VariantClear(&member);
1636 str = SysAllocString(expr->identifier);
1638 IDispatch_Release(obj);
1639 return E_OUTOFMEMORY;
1642 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1644 if(SUCCEEDED(hres)) {
1645 exprval_set_idref(ret, obj, id);
1646 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1651 IDispatch_Release(obj);
1655 /* ECMA-262 3rd Edition 11.2.1 */
1656 static HRESULT interp_member(exec_ctx_t *ctx)
1658 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1666 hres = stack_pop_object(ctx, &obj);
1670 hres = disp_get_id(ctx->parser->script, obj, arg, 0, &id);
1671 if(SUCCEEDED(hres)) {
1672 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1673 }else if(hres == DISP_E_UNKNOWNNAME) {
1674 V_VT(&v) = VT_EMPTY;
1677 IDispatch_Release(obj);
1681 return stack_push(ctx, &v);
1684 /* ECMA-262 3rd Edition 11.2.1 */
1685 static HRESULT interp_memberid(exec_ctx_t *ctx)
1687 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1688 VARIANT *objv, *namev;
1696 namev = stack_pop(ctx);
1697 objv = stack_pop(ctx);
1699 hres = to_object(ctx->parser->script, objv, &obj);
1701 if(SUCCEEDED(hres)) {
1702 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1704 IDispatch_Release(obj);
1706 VariantClear(namev);
1710 hres = disp_get_id(ctx->parser->script, obj, name, arg, &id);
1711 SysFreeString(name);
1713 IDispatch_Release(obj);
1714 if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1716 id = JS_E_INVALID_PROPERTY;
1722 return stack_push_objid(ctx, obj, id);
1725 /* ECMA-262 3rd Edition 11.2.1 */
1726 static HRESULT interp_refval(exec_ctx_t *ctx)
1735 disp = stack_topn_objid(ctx, 0, &id);
1737 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1739 hres = disp_propget(ctx->parser->script, disp, id, &v, &ctx->ei, NULL/*FIXME*/);
1743 return stack_push(ctx, &v);
1746 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1751 dp->cArgs = arg_cnt;
1752 dp->rgdispidNamedArgs = NULL;
1755 assert(ctx->top >= arg_cnt);
1757 for(i=1; i*2 <= arg_cnt; i++) {
1758 tmp = ctx->stack[ctx->top-i];
1759 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1760 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1763 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1766 /* ECMA-262 3rd Edition 11.2.2 */
1767 static HRESULT interp_new(exec_ctx_t *ctx)
1769 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1776 constr = stack_topn(ctx, arg);
1778 /* NOTE: Should use to_object here */
1780 if(V_VT(constr) == VT_NULL)
1781 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1782 else if(V_VT(constr) != VT_DISPATCH)
1783 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1784 else if(!V_DISPATCH(constr))
1785 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1787 jsstack_to_dp(ctx, arg, &dp);
1788 hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1789 DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1793 stack_popn(ctx, arg+1);
1794 return stack_push(ctx, &v);
1797 /* ECMA-262 3rd Edition 11.2.3 */
1798 static HRESULT interp_call(exec_ctx_t *ctx)
1800 const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1801 const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1806 TRACE("%d %d\n", argn, do_ret);
1808 objv = stack_topn(ctx, argn);
1809 if(V_VT(objv) != VT_DISPATCH)
1810 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1812 jsstack_to_dp(ctx, argn, &dp);
1813 hres = disp_call(ctx->parser->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1814 do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1818 stack_popn(ctx, argn+1);
1819 return do_ret ? stack_push(ctx, &v) : S_OK;
1823 /* ECMA-262 3rd Edition 11.2.3 */
1824 static HRESULT interp_call_member(exec_ctx_t *ctx)
1826 const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1827 const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1834 TRACE("%d %d\n", argn, do_ret);
1836 obj = stack_topn_objid(ctx, argn, &id);
1838 return throw_type_error(ctx->parser->script, &ctx->ei, id, NULL);
1840 jsstack_to_dp(ctx, argn, &dp);
1841 hres = disp_call(ctx->parser->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1845 stack_popn(ctx, argn+2);
1846 return do_ret ? stack_push(ctx, &v) : S_OK;
1850 /* ECMA-262 3rd Edition 11.1.1 */
1851 static HRESULT interp_this(exec_ctx_t *ctx)
1857 V_VT(&v) = VT_DISPATCH;
1858 V_DISPATCH(&v) = ctx->this_obj;
1859 IDispatch_AddRef(ctx->this_obj);
1860 return stack_push(ctx, &v);
1863 /* ECMA-262 3rd Edition 10.1.4 */
1864 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1866 identifier_expression_t *expr = (identifier_expression_t*)_expr;
1872 identifier = SysAllocString(expr->identifier);
1874 return E_OUTOFMEMORY;
1876 hres = identifier_eval(ctx, identifier, flags, ei, ret);
1878 SysFreeString(identifier);
1882 /* ECMA-262 3rd Edition 10.1.4 */
1883 static HRESULT interp_ident(exec_ctx_t *ctx)
1885 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1890 TRACE("%s\n", debugstr_w(arg));
1892 hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1896 hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1897 exprval_release(&exprval);
1901 return stack_push(ctx, &v);
1904 /* ECMA-262 3rd Edition 10.1.4 */
1905 static HRESULT interp_identid(exec_ctx_t *ctx)
1907 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1908 const unsigned flags = ctx->parser->code->instrs[ctx->ip].arg2.uint;
1912 TRACE("%s %x\n", debugstr_w(arg), flags);
1914 hres = identifier_eval(ctx->parser->script, arg, (flags&fdexNameEnsure) ? EXPR_NEWREF : 0, &ctx->ei, &exprval);
1918 if(exprval.type != EXPRVAL_IDREF) {
1919 WARN("invalid ref\n");
1920 exprval_release(&exprval);
1921 return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1924 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1927 /* ECMA-262 3rd Edition 7.8.1 */
1928 static HRESULT interp_null(exec_ctx_t *ctx)
1935 return stack_push(ctx, &v);
1938 /* ECMA-262 3rd Edition 7.8.2 */
1939 static HRESULT interp_bool(exec_ctx_t *ctx)
1941 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1943 TRACE("%s\n", arg ? "true" : "false");
1945 return stack_push_bool(ctx, arg);
1948 /* ECMA-262 3rd Edition 7.8.3 */
1949 static HRESULT interp_int(exec_ctx_t *ctx)
1951 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1958 return stack_push(ctx, &v);
1961 /* ECMA-262 3rd Edition 7.8.3 */
1962 static HRESULT interp_double(exec_ctx_t *ctx)
1964 const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1967 TRACE("%lf\n", arg);
1971 return stack_push(ctx, &v);
1974 /* ECMA-262 3rd Edition 7.8.4 */
1975 static HRESULT interp_str(exec_ctx_t *ctx)
1977 const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1980 TRACE("%s\n", debugstr_w(str));
1983 V_BSTR(&v) = SysAllocString(str);
1985 return E_OUTOFMEMORY;
1987 return stack_push(ctx, &v);
1990 /* ECMA-262 3rd Edition 7.8 */
1991 static HRESULT interp_regexp(exec_ctx_t *ctx)
1993 const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1994 const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1999 TRACE("%s %x\n", debugstr_w(source), flags);
2001 hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, ®exp);
2005 var_set_jsdisp(&v, regexp);
2006 return stack_push(ctx, &v);
2009 /* ECMA-262 3rd Edition 11.1.4 */
2010 static HRESULT interp_carray(exec_ctx_t *ctx)
2012 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2020 hres = create_array(ctx->parser->script, arg, &array);
2027 hres = jsdisp_propput_idx(array, i, v, &ctx->ei, NULL/*FIXME*/);
2030 jsdisp_release(array);
2035 var_set_jsdisp(&r, array);
2036 return stack_push(ctx, &r);
2039 /* ECMA-262 3rd Edition 11.1.5 */
2040 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2042 property_value_expression_t *expr = (property_value_expression_t*)_expr;
2052 hres = create_object(ctx, NULL, &obj);
2056 for(iter = expr->property_list; iter; iter = iter->next) {
2057 hres = literal_to_var(ctx, iter->name, &tmp);
2061 hres = to_string(ctx, &tmp, ei, &name);
2066 hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
2067 if(SUCCEEDED(hres)) {
2068 hres = exprval_to_value(ctx, &exprval, ei, &val);
2069 exprval_release(&exprval);
2070 if(SUCCEEDED(hres)) {
2071 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
2076 SysFreeString(name);
2082 jsdisp_release(obj);
2086 ret->type = EXPRVAL_VARIANT;
2087 var_set_jsdisp(&ret->u.var, obj);
2091 /* ECMA-262 3rd Edition 11.11 */
2092 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2094 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2100 hres = to_boolean(stack_top(ctx), &b);
2113 /* ECMA-262 3rd Edition 11.11 */
2114 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2116 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2122 hres = to_boolean(stack_top(ctx), &b);
2135 /* ECMA-262 3rd Edition 11.10 */
2136 static HRESULT interp_or(exec_ctx_t *ctx)
2143 hres = stack_pop_int(ctx, &r);
2147 hres = stack_pop_int(ctx, &l);
2151 return stack_push_int(ctx, l|r);
2154 /* ECMA-262 3rd Edition 11.10 */
2155 static HRESULT interp_xor(exec_ctx_t *ctx)
2162 hres = stack_pop_int(ctx, &r);
2166 hres = stack_pop_int(ctx, &l);
2170 return stack_push_int(ctx, l^r);
2173 /* ECMA-262 3rd Edition 11.10 */
2174 static HRESULT interp_and(exec_ctx_t *ctx)
2181 hres = stack_pop_int(ctx, &r);
2185 hres = stack_pop_int(ctx, &l);
2189 return stack_push_int(ctx, l&r);
2192 /* ECMA-262 3rd Edition 11.8.6 */
2193 static HRESULT instanceof_eval(script_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
2195 jsdisp_t *obj, *iter, *tmp = NULL;
2196 VARIANT_BOOL ret = VARIANT_FALSE;
2201 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2203 if(V_VT(objv) != VT_DISPATCH || !V_DISPATCH(objv))
2204 return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2206 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
2208 FIXME("non-jsdisp objects not supported\n");
2212 if(is_class(obj, JSCLASS_FUNCTION)) {
2213 hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
2215 hres = throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2217 jsdisp_release(obj);
2221 if(V_VT(&var) == VT_DISPATCH) {
2222 if(V_VT(inst) == VT_DISPATCH)
2223 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
2224 for(iter = tmp; iter; iter = iter->prototype) {
2225 hres = disp_cmp(V_DISPATCH(&var), to_disp(iter), &b);
2235 jsdisp_release(tmp);
2237 FIXME("prototype is not an object\n");
2245 V_VT(retv) = VT_BOOL;
2250 /* ECMA-262 3rd Edition 11.8.6 */
2251 HRESULT instanceof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2253 binary_expression_t *expr = (binary_expression_t*)_expr;
2257 return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
2260 /* ECMA-262 3rd Edition 11.8.7 */
2261 static HRESULT interp_in(exec_ctx_t *ctx)
2271 obj = stack_pop(ctx);
2274 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2277 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2280 hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2283 IDispatch_Release(V_DISPATCH(obj));
2287 hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2288 IDispatch_Release(V_DISPATCH(obj));
2292 else if(hres == DISP_E_UNKNOWNNAME)
2297 return stack_push_bool(ctx, ret);
2300 /* ECMA-262 3rd Edition 11.6.1 */
2301 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2306 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2310 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2316 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2317 BSTR lstr = NULL, rstr = NULL;
2319 if(V_VT(&l) == VT_BSTR)
2322 hres = to_string(ctx, &l, ei, &lstr);
2324 if(SUCCEEDED(hres)) {
2325 if(V_VT(&r) == VT_BSTR)
2328 hres = to_string(ctx, &r, ei, &rstr);
2331 if(SUCCEEDED(hres)) {
2334 len1 = SysStringLen(lstr);
2335 len2 = SysStringLen(rstr);
2337 V_VT(retv) = VT_BSTR;
2338 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2339 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2340 memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2343 if(V_VT(&l) != VT_BSTR)
2344 SysFreeString(lstr);
2345 if(V_VT(&r) != VT_BSTR)
2346 SysFreeString(rstr);
2350 hres = to_number(ctx, &l, ei, &nl);
2351 if(SUCCEEDED(hres)) {
2352 hres = to_number(ctx, &r, ei, &nr);
2354 num_set_val(retv, num_val(&nl) + num_val(&nr));
2363 /* ECMA-262 3rd Edition 11.6.1 */
2364 static HRESULT interp_add(exec_ctx_t *ctx)
2366 VARIANT *l, *r, ret;
2372 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2374 hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2380 return stack_push(ctx, &ret);
2383 /* ECMA-262 3rd Edition 11.6.2 */
2384 static HRESULT interp_sub(exec_ctx_t *ctx)
2391 hres = stack_pop_number(ctx, &r);
2395 hres = stack_pop_number(ctx, &l);
2399 return stack_push_number(ctx, num_val(&l)-num_val(&r));
2402 /* ECMA-262 3rd Edition 11.5.1 */
2403 static HRESULT interp_mul(exec_ctx_t *ctx)
2410 hres = stack_pop_number(ctx, &r);
2414 hres = stack_pop_number(ctx, &l);
2418 return stack_push_number(ctx, num_val(&l)*num_val(&r));
2421 /* ECMA-262 3rd Edition 11.5.2 */
2422 static HRESULT interp_div(exec_ctx_t *ctx)
2429 hres = stack_pop_number(ctx, &r);
2433 hres = stack_pop_number(ctx, &l);
2437 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2440 /* ECMA-262 3rd Edition 11.5.3 */
2441 static HRESULT interp_mod(exec_ctx_t *ctx)
2448 hres = stack_pop_number(ctx, &r);
2452 hres = stack_pop_number(ctx, &l);
2456 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2459 /* ECMA-262 3rd Edition 11.4.2 */
2460 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2462 unary_expression_t *expr = (unary_expression_t*)_expr;
2463 VARIANT_BOOL b = VARIANT_FALSE;
2469 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2473 switch(exprval.type) {
2474 case EXPRVAL_IDREF: {
2475 IDispatchEx *dispex;
2477 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2478 if(SUCCEEDED(hres)) {
2479 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2481 IDispatchEx_Release(dispex);
2486 FIXME("unsupported type %d\n", exprval.type);
2490 exprval_release(&exprval);
2494 return return_bool(ret, b);
2497 /* ECMA-262 3rd Edition 11.4.2 */
2498 static HRESULT interp_delete(exec_ctx_t *ctx)
2500 VARIANT *obj_var, *name_var;
2501 IDispatchEx *dispex;
2509 name_var = stack_pop(ctx);
2510 obj_var = stack_pop(ctx);
2512 hres = to_object(ctx->parser->script, obj_var, &obj);
2513 VariantClear(obj_var);
2515 VariantClear(name_var);
2519 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2520 VariantClear(name_var);
2522 IDispatch_Release(obj);
2526 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2527 if(SUCCEEDED(hres)) {
2528 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2530 IDispatchEx_Release(dispex);
2536 IDispatch_Release(obj);
2537 SysFreeString(name);
2541 return stack_push_bool(ctx, ret);
2544 /* ECMA-262 3rd Edition 11.4.2 */
2545 static HRESULT interp_void(exec_ctx_t *ctx)
2553 V_VT(&v) = VT_EMPTY;
2554 return stack_push(ctx, &v);
2557 /* ECMA-262 3rd Edition 11.4.3 */
2558 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2563 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2564 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2565 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2566 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2567 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2568 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2569 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2571 if(exprval->type == EXPRVAL_INVALID) {
2576 hres = exprval_to_value(ctx, exprval, ei, &val);
2578 if(exprval->type == EXPRVAL_IDREF) {
2585 switch(V_VT(&val)) {
2605 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2606 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2607 jsdisp_release(dispex);
2614 FIXME("unhandled vt %d\n", V_VT(&val));
2622 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2624 unary_expression_t *expr = (unary_expression_t*)_expr;
2625 const WCHAR *str = NULL;
2631 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2635 hres = typeof_exprval(ctx, &exprval, ei, &str);
2636 exprval_release(&exprval);
2640 ret->type = EXPRVAL_VARIANT;
2641 V_VT(&ret->u.var) = VT_BSTR;
2642 V_BSTR(&ret->u.var) = SysAllocString(str);
2643 if(!V_BSTR(&ret->u.var))
2644 return E_OUTOFMEMORY;
2649 /* ECMA-262 3rd Edition 11.4.7 */
2650 static HRESULT interp_minus(exec_ctx_t *ctx)
2657 hres = stack_pop_number(ctx, &n);
2661 return stack_push_number(ctx, -num_val(&n));
2664 /* ECMA-262 3rd Edition 11.4.6 */
2665 static HRESULT interp_tonum(exec_ctx_t *ctx)
2673 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2678 return stack_push(ctx, &num);
2681 /* ECMA-262 3rd Edition 11.3.1 */
2682 static HRESULT interp_postinc(exec_ctx_t *ctx)
2684 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2692 obj = stack_pop_objid(ctx, &id);
2694 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2696 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2697 if(SUCCEEDED(hres)) {
2700 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2701 if(SUCCEEDED(hres)) {
2702 num_set_val(&inc, num_val(&n)+(double)arg);
2703 hres = disp_propput(ctx->parser->script, obj, id, &inc, &ctx->ei, NULL/*FIXME*/);
2708 IDispatch_Release(obj);
2712 return stack_push(ctx, &v);
2715 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
2716 static HRESULT interp_preinc(exec_ctx_t *ctx)
2718 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2726 obj = stack_pop_objid(ctx, &id);
2728 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2730 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2731 if(SUCCEEDED(hres)) {
2734 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2736 if(SUCCEEDED(hres)) {
2737 num_set_val(&v, num_val(&n)+(double)arg);
2738 hres = disp_propput(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2741 IDispatch_Release(obj);
2745 return stack_push(ctx, &v);
2748 /* ECMA-262 3rd Edition 11.9.3 */
2749 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2751 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2752 return equal2_values(lval, rval, ret);
2754 /* FIXME: NULL disps should be handled in more general way */
2755 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2758 return equal_values(ctx, &v, rval, ei, ret);
2761 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2764 return equal_values(ctx, lval, &v, ei, ret);
2767 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2768 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2773 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2777 hres = to_number(ctx, lval, ei, &v);
2781 return equal_values(ctx, &v, rval, ei, ret);
2784 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2788 hres = to_number(ctx, rval, ei, &v);
2792 return equal_values(ctx, lval, &v, ei, ret);
2795 if(V_VT(rval) == VT_BOOL) {
2799 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2800 return equal_values(ctx, lval, &v, ei, ret);
2803 if(V_VT(lval) == VT_BOOL) {
2807 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2808 return equal_values(ctx, &v, rval, ei, ret);
2812 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2816 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2820 hres = equal_values(ctx, lval, &v, ei, ret);
2827 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2831 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2835 hres = equal_values(ctx, &v, rval, ei, ret);
2846 /* ECMA-262 3rd Edition 11.9.1 */
2847 static HRESULT interp_eq(exec_ctx_t *ctx)
2856 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2858 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2864 return stack_push_bool(ctx, b);
2867 /* ECMA-262 3rd Edition 11.9.2 */
2868 static HRESULT interp_neq(exec_ctx_t *ctx)
2877 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2879 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2885 return stack_push_bool(ctx, !b);
2888 /* ECMA-262 3rd Edition 11.9.4 */
2889 static HRESULT interp_eq2(exec_ctx_t *ctx)
2900 hres = equal2_values(r, l, &b);
2906 return stack_push_bool(ctx, b);
2909 /* ECMA-262 3rd Edition 11.9.5 */
2910 static HRESULT interp_neq2(exec_ctx_t *ctx)
2921 hres = equal2_values(r, l, &b);
2927 return stack_push_bool(ctx, !b);
2930 /* ECMA-262 3rd Edition 11.8.5 */
2931 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2933 VARIANT l, r, ln, rn;
2936 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2940 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2946 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2947 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2948 SysFreeString(V_BSTR(&l));
2949 SysFreeString(V_BSTR(&r));
2953 hres = to_number(ctx, &l, ei, &ln);
2956 hres = to_number(ctx, &r, ei, &rn);
2961 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
2962 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
2964 DOUBLE ld = num_val(&ln);
2965 DOUBLE rd = num_val(&rn);
2967 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
2973 /* ECMA-262 3rd Edition 11.8.1 */
2974 static HRESULT interp_lt(exec_ctx_t *ctx)
2983 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2985 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
2991 return stack_push_bool(ctx, b);
2994 /* ECMA-262 3rd Edition 11.8.1 */
2995 static HRESULT interp_lteq(exec_ctx_t *ctx)
3004 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
3006 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
3012 return stack_push_bool(ctx, b);
3015 /* ECMA-262 3rd Edition 11.8.2 */
3016 static HRESULT interp_gt(exec_ctx_t *ctx)
3025 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
3027 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
3033 return stack_push_bool(ctx, b);
3036 /* ECMA-262 3rd Edition 11.8.4 */
3037 static HRESULT interp_gteq(exec_ctx_t *ctx)
3046 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
3048 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
3054 return stack_push_bool(ctx, b);
3057 /* ECMA-262 3rd Edition 11.4.8 */
3058 static HRESULT interp_bneg(exec_ctx_t *ctx)
3067 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3074 return stack_push(ctx, &r);
3077 /* ECMA-262 3rd Edition 11.4.9 */
3078 static HRESULT interp_neg(exec_ctx_t *ctx)
3087 hres = to_boolean(v, &b);
3092 return stack_push_bool(ctx, !b);
3095 /* ECMA-262 3rd Edition 11.7.1 */
3096 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3102 hres = to_int32(ctx, lval, ei, &li);
3106 hres = to_uint32(ctx, rval, ei, &ri);
3111 V_I4(retv) = li << (ri&0x1f);
3115 /* ECMA-262 3rd Edition 11.7.1 */
3116 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3118 binary_expression_t *expr = (binary_expression_t*)_expr;
3122 return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3125 /* ECMA-262 3rd Edition 11.7.2 */
3126 static HRESULT interp_rshift(exec_ctx_t *ctx)
3132 hres = stack_pop_uint(ctx, &r);
3136 hres = stack_pop_int(ctx, &l);
3140 return stack_push_int(ctx, l >> (r&0x1f));
3143 /* ECMA-262 3rd Edition 11.7.3 */
3144 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3149 hres = to_uint32(ctx, lval, ei, &li);
3153 hres = to_uint32(ctx, rval, ei, &ri);
3158 V_I4(retv) = li >> (ri&0x1f);
3162 /* ECMA-262 3rd Edition 11.7.3 */
3163 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3165 binary_expression_t *expr = (binary_expression_t*)_expr;
3169 return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3172 /* ECMA-262 3rd Edition 11.13.1 */
3173 static HRESULT interp_assign(exec_ctx_t *ctx)
3183 disp = stack_pop_objid(ctx, &id);
3186 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3188 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3189 IDispatch_Release(disp);
3195 return stack_push(ctx, v);
3198 /* ECMA-262 3rd Edition 11.13.2 */
3199 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3201 binary_expression_t *expr = (binary_expression_t*)_expr;
3205 return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3208 /* ECMA-262 3rd Edition 11.13.2 */
3209 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3211 binary_expression_t *expr = (binary_expression_t*)_expr;
3215 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3218 static HRESULT interp_undefined(exec_ctx_t *ctx)
3224 V_VT(&v) = VT_EMPTY;
3225 return stack_push(ctx, &v);
3228 static HRESULT interp_jmp(exec_ctx_t *ctx)
3230 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3238 static HRESULT interp_pop(exec_ctx_t *ctx)
3246 static HRESULT interp_ret(exec_ctx_t *ctx)
3254 static HRESULT interp_tree(exec_ctx_t *ctx)
3256 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3263 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3267 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3268 exprval_release(&val);
3272 return stack_push(ctx, &v);
3275 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3277 static const op_func_t op_funcs[] = {
3278 #define X(x,a,b,c) interp_##x,
3283 static const unsigned op_move[] = {
3284 #define X(a,x,b,c) x,
3289 static HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3291 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3292 unsigned prev_ip, prev_top;
3294 HRESULT hres = S_OK;
3298 prev_top = exec_ctx->top;
3299 prev_ip = exec_ctx->ip;
3300 exec_ctx->ip = expr->instr_off;
3302 while(exec_ctx->ip != -1) {
3303 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3304 hres = op_funcs[op](exec_ctx);
3307 exec_ctx->ip += op_move[op];
3310 exec_ctx->ip = prev_ip;
3313 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3315 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3319 assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3321 ret->type = EXPRVAL_VARIANT;
3322 if(exec_ctx->top == prev_top)
3323 V_VT(&ret->u.var) = VT_EMPTY;
3325 ret->u.var = *stack_pop(exec_ctx);
3329 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3335 hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
3339 if(expr->eval == compiled_expression_eval)
3340 expr->eval = interp_expression_eval;
3342 return expr->eval(ctx, expr, flags, ei, ret);