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 inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
158 return to_int32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
161 static inline IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
163 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
165 *id = V_INT(stack_pop(ctx));
166 return V_DISPATCH(stack_pop(ctx));
169 static inline IDispatch *stack_top_objid(exec_ctx_t *ctx, DISPID *id)
171 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
173 *id = V_INT(stack_top(ctx));
174 return V_DISPATCH(stack_topn(ctx, 1));
177 static void exprval_release(exprval_t *val)
180 case EXPRVAL_VARIANT:
181 if(V_VT(&val->u.var) != VT_EMPTY)
182 VariantClear(&val->u.var);
185 if(val->u.idref.disp)
186 IDispatch_Release(val->u.idref.disp);
188 case EXPRVAL_INVALID:
189 SysFreeString(val->u.identifier);
193 /* ECMA-262 3rd Edition 8.7.1 */
194 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
196 V_VT(ret) = VT_EMPTY;
199 case EXPRVAL_VARIANT:
200 return VariantCopy(ret, &val->u.var);
202 if(!val->u.idref.disp) {
203 FIXME("throw ReferenceError\n");
207 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
208 case EXPRVAL_INVALID:
209 return throw_type_error(ctx, ei, JS_E_UNDEFINED_VARIABLE, val->u.identifier);
212 ERR("type %d\n", val->type);
216 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
218 if(val->type == EXPRVAL_VARIANT) {
220 V_VT(&val->u.var) = VT_EMPTY;
224 return exprval_value(ctx, val, ei, ret);
227 static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
229 if(exprval->type != EXPRVAL_VARIANT) {
233 hres = exprval_to_value(ctx, exprval, ei, &val);
237 hres = to_boolean(&val, b);
242 return to_boolean(&exprval->u.var, b);
245 static void exprval_init(exprval_t *val)
247 val->type = EXPRVAL_VARIANT;
248 V_VT(&val->u.var) = VT_EMPTY;
251 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
253 val->type = EXPRVAL_IDREF;
254 val->u.idref.disp = disp;
255 val->u.idref.id = id;
258 IDispatch_AddRef(disp);
261 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
263 scope_chain_t *new_scope;
265 new_scope = heap_alloc(sizeof(scope_chain_t));
267 return E_OUTOFMEMORY;
272 new_scope->obj = obj;
276 new_scope->next = scope;
278 new_scope->next = NULL;
285 static void scope_pop(scope_chain_t **scope)
294 void scope_release(scope_chain_t *scope)
300 scope_release(scope->next);
302 jsdisp_release(scope->obj);
306 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
307 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
311 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
313 return E_OUTOFMEMORY;
316 ctx->is_global = is_global;
319 ctx->this_obj = this_obj;
320 else if(script_ctx->host_global)
321 ctx->this_obj = script_ctx->host_global;
323 ctx->this_obj = to_disp(script_ctx->global);
324 IDispatch_AddRef(ctx->this_obj);
326 jsdisp_addref(var_disp);
327 ctx->var_disp = var_disp;
331 ctx->scope_chain = scope;
338 void exec_release(exec_ctx_t *ctx)
344 scope_release(ctx->scope_chain);
346 jsdisp_release(ctx->var_disp);
348 IDispatch_Release(ctx->this_obj);
349 heap_free(ctx->stack);
353 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
358 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
360 TRACE("unsing IDispatch\n");
363 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
367 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
368 IDispatchEx_Release(dispex);
372 /* ECMA-262 3rd Edition 8.7.2 */
373 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
375 if(ref->type != EXPRVAL_IDREF)
376 return throw_reference_error(ctx, ei, JS_E_ILLEGAL_ASSIGN, NULL);
378 return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
381 static inline BOOL is_null(const VARIANT *v)
383 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
386 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
388 IObjectIdentity *identity;
389 IUnknown *unk1, *unk2;
397 if(!disp1 || !disp2) {
402 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
406 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
408 IUnknown_Release(unk1);
415 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
416 if(SUCCEEDED(hres)) {
417 hres = IObjectIdentity_IsEqualObject(identity, unk2);
418 IObjectIdentity_Release(identity);
425 IUnknown_Release(unk1);
426 IUnknown_Release(unk2);
430 /* ECMA-262 3rd Edition 11.9.6 */
431 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
435 if(V_VT(lval) != V_VT(rval)) {
436 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
437 *ret = num_val(lval) == num_val(rval);
438 else if(is_null(lval))
439 *ret = is_null(rval);
451 *ret = V_I4(lval) == V_I4(rval);
454 *ret = V_R8(lval) == V_R8(rval);
458 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
459 else if(!V_BSTR(rval))
460 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
462 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
465 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
467 *ret = !V_BOOL(lval) == !V_BOOL(rval);
470 FIXME("unimplemented vt %d\n", V_VT(lval));
477 static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
479 switch(literal->type) {
485 V_I4(v) = literal->u.lval;
489 V_R8(v) = literal->u.dval;
492 BSTR str = SysAllocString(literal->u.wstr);
494 return E_OUTOFMEMORY;
502 V_BOOL(v) = literal->u.bval;
508 hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
509 literal->u.regexp.flags, ®exp);
513 var_set_jsdisp(v, regexp);
520 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
526 for(item = ctx->named_items; item; item = item->next) {
527 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
528 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
529 if(SUCCEEDED(hres)) {
531 exprval_set_idref(ret, item->disp, id);
540 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, BOOL from_eval,
541 jsexcept_t *ei, VARIANT *retv)
543 script_ctx_t *script = parser->script;
544 function_declaration_t *func;
545 parser_ctx_t *prev_parser;
549 exec_ctx_t *prev_ctx;
553 for(func = source->functions; func; func = func->next) {
557 hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
558 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
562 var_set_jsdisp(&var, func_obj);
563 hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
564 jsdisp_release(func_obj);
569 for(var = source->variables; var; var = var->next) {
573 name = SysAllocString(var->identifier);
575 return E_OUTOFMEMORY;
577 if(!ctx->is_global || !lookup_global_members(parser->script, name, NULL))
578 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
584 prev_ctx = script->exec_ctx;
585 script->exec_ctx = ctx;
587 prev_parser = ctx->parser;
588 ctx->parser = parser;
590 V_VT(&val) = VT_EMPTY;
591 memset(&rt, 0, sizeof(rt));
594 for(stat = source->statement; stat; stat = stat->next) {
595 hres = stat_eval(script, stat, &rt, &tmp);
601 if(rt.type != RT_NORMAL)
605 script->exec_ctx = prev_ctx;
606 ctx->parser = prev_parser;
608 if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
609 FIXME("wrong rt %d\n", rt.type);
619 if(!retv || (!from_eval && rt.type != RT_RETURN))
626 /* ECMA-262 3rd Edition 10.1.4 */
627 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
629 scope_chain_t *scope;
634 TRACE("%s\n", debugstr_w(identifier));
636 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
637 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
638 if(SUCCEEDED(hres)) {
639 exprval_set_idref(ret, to_disp(scope->obj), id);
644 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
645 if(SUCCEEDED(hres)) {
646 exprval_set_idref(ret, to_disp(ctx->global), id);
650 for(item = ctx->named_items; item; item = item->next) {
651 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
658 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
659 SCRIPTINFO_IUNKNOWN, &unk, NULL);
661 WARN("GetItemInfo failed: %08x\n", hres);
665 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
666 IUnknown_Release(unk);
668 WARN("object does not implement IDispatch\n");
673 ret->type = EXPRVAL_VARIANT;
674 V_VT(&ret->u.var) = VT_DISPATCH;
675 V_DISPATCH(&ret->u.var) = item->disp;
676 IDispatch_AddRef(item->disp);
681 if(lookup_global_members(ctx, identifier, ret))
684 if(flags & EXPR_NEWREF) {
685 hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
689 exprval_set_idref(ret, to_disp(ctx->global), id);
693 ret->type = EXPRVAL_INVALID;
694 ret->u.identifier = SysAllocString(identifier);
695 if(!ret->u.identifier)
696 return E_OUTOFMEMORY;
701 /* ECMA-262 3rd Edition 12.1 */
702 HRESULT block_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
704 block_statement_t *stat = (block_statement_t*)_stat;
711 V_VT(&val) = VT_EMPTY;
712 for(iter = stat->stat_list; iter; iter = iter->next) {
713 hres = stat_eval(ctx, iter, rt, &tmp);
719 if(rt->type != RT_NORMAL)
732 /* ECMA-262 3rd Edition 12.2 */
733 static HRESULT variable_list_eval(script_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
735 variable_declaration_t *iter;
738 for(iter = var_list; iter; iter = iter->next) {
745 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
749 hres = exprval_to_value(ctx, &exprval, ei, &val);
750 exprval_release(&exprval);
754 hres = jsdisp_propput_name(ctx->exec_ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
763 /* ECMA-262 3rd Edition 12.2 */
764 HRESULT var_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
766 var_statement_t *stat = (var_statement_t*)_stat;
771 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
775 V_VT(ret) = VT_EMPTY;
779 /* ECMA-262 3rd Edition 12.3 */
780 HRESULT empty_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
784 V_VT(ret) = VT_EMPTY;
788 /* ECMA-262 3rd Edition 12.4 */
789 HRESULT expression_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
791 expression_statement_t *stat = (expression_statement_t*)_stat;
798 hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
802 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
803 exprval_release(&exprval);
808 TRACE("= %s\n", debugstr_variant(ret));
812 /* ECMA-262 3rd Edition 12.5 */
813 HRESULT if_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
815 if_statement_t *stat = (if_statement_t*)_stat;
822 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
826 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
827 exprval_release(&exprval);
832 hres = stat_eval(ctx, stat->if_stat, rt, ret);
833 else if(stat->else_stat)
834 hres = stat_eval(ctx, stat->else_stat, rt, ret);
836 V_VT(ret) = VT_EMPTY;
841 /* ECMA-262 3rd Edition 12.6.2 */
842 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
844 while_statement_t *stat = (while_statement_t*)_stat;
853 V_VT(&val) = VT_EMPTY;
854 test_expr = !stat->do_while;
858 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
862 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
863 exprval_release(&exprval);
864 if(FAILED(hres) || !b)
870 hres = stat_eval(ctx, stat->statement, rt, &tmp);
877 if(rt->type == RT_CONTINUE)
878 rt->type = RT_NORMAL;
879 if(rt->type != RT_NORMAL)
888 if(rt->type == RT_BREAK)
889 rt->type = RT_NORMAL;
895 /* ECMA-262 3rd Edition 12.6.3 */
896 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
898 for_statement_t *stat = (for_statement_t*)_stat;
899 VARIANT val, tmp, retv;
906 if(stat->variable_list) {
907 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
910 }else if(stat->begin_expr) {
911 hres = expr_eval(ctx, stat->begin_expr, EXPR_NEWREF, &rt->ei, &exprval);
915 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
916 exprval_release(&exprval);
923 V_VT(&retv) = VT_EMPTY;
927 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
931 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
932 exprval_release(&exprval);
933 if(FAILED(hres) || !b)
937 hres = stat_eval(ctx, stat->statement, rt, &tmp);
944 if(rt->type == RT_CONTINUE)
945 rt->type = RT_NORMAL;
946 else if(rt->type != RT_NORMAL)
950 hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
954 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
955 exprval_release(&exprval);
968 if(rt->type == RT_BREAK)
969 rt->type = RT_NORMAL;
975 /* ECMA-262 3rd Edition 12.6.4 */
976 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
978 forin_statement_t *stat = (forin_statement_t*)_stat;
979 VARIANT val, name, retv, tmp;
980 DISPID id = DISPID_STARTENUM;
981 BSTR str, identifier = NULL;
989 hres = variable_list_eval(ctx, stat->variable, &rt->ei);
994 hres = expr_eval(ctx, stat->in_expr, EXPR_NEWREF, &rt->ei, &exprval);
998 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
999 exprval_release(&exprval);
1003 if(V_VT(&val) != VT_DISPATCH) {
1004 TRACE("in vt %d\n", V_VT(&val));
1006 V_VT(ret) = VT_EMPTY;
1010 hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
1011 IDispatch_Release(V_DISPATCH(&val));
1013 TRACE("Object doesn't support IDispatchEx\n");
1014 V_VT(ret) = VT_EMPTY;
1018 V_VT(&retv) = VT_EMPTY;
1021 identifier = SysAllocString(stat->variable->identifier);
1024 hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
1025 if(FAILED(hres) || hres == S_FALSE)
1028 hres = IDispatchEx_GetMemberName(in_obj, id, &str);
1032 TRACE("iter %s\n", debugstr_w(str));
1035 hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
1037 hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
1038 if(SUCCEEDED(hres)) {
1039 V_VT(&name) = VT_BSTR;
1040 V_BSTR(&name) = str;
1041 hres = put_value(ctx, &exprval, &name, &rt->ei);
1042 exprval_release(&exprval);
1048 hres = stat_eval(ctx, stat->statement, rt, &tmp);
1052 VariantClear(&retv);
1055 if(rt->type == RT_CONTINUE)
1056 rt->type = RT_NORMAL;
1057 else if(rt->type != RT_NORMAL)
1061 SysFreeString(identifier);
1062 IDispatchEx_Release(in_obj);
1064 VariantClear(&retv);
1068 if(rt->type == RT_BREAK)
1069 rt->type = RT_NORMAL;
1075 /* ECMA-262 3rd Edition 12.7 */
1076 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1078 branch_statement_t *stat = (branch_statement_t*)_stat;
1082 if(stat->identifier) {
1083 FIXME("indentifier not implemented\n");
1087 rt->type = RT_CONTINUE;
1088 V_VT(ret) = VT_EMPTY;
1092 /* ECMA-262 3rd Edition 12.8 */
1093 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1095 branch_statement_t *stat = (branch_statement_t*)_stat;
1099 if(stat->identifier) {
1100 FIXME("indentifier not implemented\n");
1104 rt->type = RT_BREAK;
1105 V_VT(ret) = VT_EMPTY;
1109 /* ECMA-262 3rd Edition 12.9 */
1110 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1112 expression_statement_t *stat = (expression_statement_t*)_stat;
1120 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1124 hres = exprval_to_value(ctx, &exprval, &rt->ei, ret);
1125 exprval_release(&exprval);
1129 V_VT(ret) = VT_EMPTY;
1132 TRACE("= %s\n", debugstr_variant(ret));
1133 rt->type = RT_RETURN;
1137 /* ECMA-262 3rd Edition 12.10 */
1138 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1140 with_statement_t *stat = (with_statement_t*)_stat;
1149 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1153 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1154 exprval_release(&exprval);
1158 hres = to_object(ctx, &val, &disp);
1163 obj = iface_to_jsdisp((IUnknown*)disp);
1164 IDispatch_Release(disp);
1166 FIXME("disp id not jsdisp\n");
1170 hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1171 jsdisp_release(obj);
1175 hres = stat_eval(ctx, stat->statement, rt, ret);
1177 scope_pop(&ctx->exec_ctx->scope_chain);
1181 /* ECMA-262 3rd Edition 12.12 */
1182 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1188 /* ECMA-262 3rd Edition 12.13 */
1189 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1191 switch_statement_t *stat = (switch_statement_t*)_stat;
1192 case_clausule_t *iter, *default_clausule = NULL;
1193 statement_t *stat_iter;
1201 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1205 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1206 exprval_release(&exprval);
1210 for(iter = stat->case_list; iter; iter = iter->next) {
1212 default_clausule = iter;
1216 hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
1220 hres = exprval_to_value(ctx, &exprval, &rt->ei, &cval);
1221 exprval_release(&exprval);
1225 hres = equal2_values(&val, &cval, &b);
1226 VariantClear(&cval);
1227 if(FAILED(hres) || b)
1236 iter = default_clausule;
1238 V_VT(&val) = VT_EMPTY;
1242 for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1243 hres = stat_eval(ctx, stat_iter, rt, &tmp);
1250 if(rt->type != RT_NORMAL)
1260 if(rt->type == RT_BREAK)
1261 rt->type = RT_NORMAL;
1267 /* ECMA-262 3rd Edition 12.13 */
1268 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1270 expression_statement_t *stat = (expression_statement_t*)_stat;
1277 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1281 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1282 exprval_release(&exprval);
1287 return DISP_E_EXCEPTION;
1290 static HRESULT interp_throw(exec_ctx_t *ctx)
1292 const HRESULT arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1294 TRACE("%08x\n", arg);
1296 return throw_reference_error(ctx->parser->script, &ctx->ei, arg, NULL);
1299 /* ECMA-262 3rd Edition 12.14 */
1300 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1307 memset(&rt->ei, 0, sizeof(jsexcept_t));
1309 hres = create_dispex(ctx, NULL, NULL, &var_disp);
1310 if(SUCCEEDED(hres)) {
1311 hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1312 if(SUCCEEDED(hres)) {
1313 hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1314 if(SUCCEEDED(hres)) {
1315 hres = stat_eval(ctx, block->statement, rt, &val);
1316 scope_pop(&ctx->exec_ctx->scope_chain);
1320 jsdisp_release(var_disp);
1331 /* ECMA-262 3rd Edition 12.14 */
1332 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1334 try_statement_t *stat = (try_statement_t*)_stat;
1340 hres = stat_eval(ctx, stat->try_statement, rt, &val);
1342 TRACE("EXCEPTION\n");
1343 if(!stat->catch_block)
1346 hres = catch_eval(ctx, stat->catch_block, rt, &val);
1351 if(stat->finally_statement) {
1353 hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1362 static HRESULT return_bool(exprval_t *ret, DWORD b)
1364 ret->type = EXPRVAL_VARIANT;
1365 V_VT(&ret->u.var) = VT_BOOL;
1366 V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1371 static HRESULT get_binary_expr_values(script_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
1376 hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1380 hres = exprval_to_value(ctx, &exprval, ei, lval);
1381 exprval_release(&exprval);
1385 hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1386 if(SUCCEEDED(hres)) {
1387 hres = exprval_to_value(ctx, &exprval, ei, rval);
1388 exprval_release(&exprval);
1399 typedef HRESULT (*oper_t)(script_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
1401 static HRESULT binary_expr_eval(script_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
1404 VARIANT lval, rval, retv;
1407 hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1411 hres = oper(ctx, &lval, &rval, ei, &retv);
1412 VariantClear(&lval);
1413 VariantClear(&rval);
1417 ret->type = EXPRVAL_VARIANT;
1422 /* ECMA-262 3rd Edition 11.13.2 */
1423 static HRESULT assign_oper_eval(script_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1424 jsexcept_t *ei, exprval_t *ret)
1426 VARIANT retv, lval, rval;
1427 exprval_t exprval, exprvalr;
1430 hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1434 hres = exprval_value(ctx, &exprval, ei, &lval);
1435 if(SUCCEEDED(hres)) {
1436 hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1437 if(SUCCEEDED(hres)) {
1438 hres = exprval_value(ctx, &exprvalr, ei, &rval);
1439 exprval_release(&exprvalr);
1441 if(SUCCEEDED(hres)) {
1442 hres = oper(ctx, &lval, &rval, ei, &retv);
1443 VariantClear(&rval);
1445 VariantClear(&lval);
1448 if(SUCCEEDED(hres)) {
1449 hres = put_value(ctx, &exprval, &retv, ei);
1451 VariantClear(&retv);
1453 exprval_release(&exprval);
1458 ret->type = EXPRVAL_VARIANT;
1463 /* ECMA-262 3rd Edition 13 */
1464 HRESULT function_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1466 function_expression_t *expr = (function_expression_t*)_expr;
1472 if(expr->identifier) {
1473 hres = jsdisp_propget_name(ctx->exec_ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
1479 hres = create_source_function(ctx->exec_ctx->parser, expr->parameter_list, expr->source_elements, ctx->exec_ctx->scope_chain,
1480 expr->src_str, expr->src_len, &dispex);
1484 var_set_jsdisp(&var, dispex);
1487 ret->type = EXPRVAL_VARIANT;
1492 /* ECMA-262 3rd Edition 11.2.1 */
1493 HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1495 array_expression_t *expr = (array_expression_t*)_expr;
1497 VARIANT member, val;
1500 IDispatch *obj = NULL;
1505 hres = expr_eval(ctx, expr->member_expr, 0, ei, &exprval);
1509 hres = exprval_to_value(ctx, &exprval, ei, &member);
1510 exprval_release(&exprval);
1514 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1515 if(SUCCEEDED(hres)) {
1516 hres = exprval_to_value(ctx, &exprval, ei, &val);
1517 exprval_release(&exprval);
1520 if(SUCCEEDED(hres)) {
1521 hres = to_object(ctx, &member, &obj);
1525 VariantClear(&member);
1526 if(SUCCEEDED(hres)) {
1527 hres = to_string(ctx, &val, ei, &str);
1529 if(SUCCEEDED(hres)) {
1530 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1534 if(SUCCEEDED(hres)) {
1535 exprval_set_idref(ret, obj, id);
1536 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1541 IDispatch_Release(obj);
1547 /* ECMA-262 3rd Edition 11.2.1 */
1548 HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1550 member_expression_t *expr = (member_expression_t*)_expr;
1551 IDispatch *obj = NULL;
1560 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1564 hres = exprval_to_value(ctx, &exprval, ei, &member);
1565 exprval_release(&exprval);
1569 hres = to_object(ctx, &member, &obj);
1570 VariantClear(&member);
1574 str = SysAllocString(expr->identifier);
1576 IDispatch_Release(obj);
1577 return E_OUTOFMEMORY;
1580 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1582 if(SUCCEEDED(hres)) {
1583 exprval_set_idref(ret, obj, id);
1584 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1589 IDispatch_Release(obj);
1593 /* ECMA-262 3rd Edition 11.2.1 */
1594 static HRESULT interp_memberid(exec_ctx_t *ctx)
1596 VARIANT *objv, *namev;
1604 namev = stack_pop(ctx);
1605 objv = stack_pop(ctx);
1607 hres = to_object(ctx->parser->script, objv, &obj);
1609 if(SUCCEEDED(hres)) {
1610 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1612 IDispatch_Release(obj);
1614 VariantClear(namev);
1618 hres = disp_get_id(ctx->parser->script, obj, name, fdexNameEnsure, &id);
1619 SysFreeString(name);
1621 IDispatch_Release(obj);
1625 return stack_push_objid(ctx, obj, id);
1628 /* ECMA-262 3rd Edition 11.2.1 */
1629 static HRESULT interp_refval(exec_ctx_t *ctx)
1638 disp = stack_top_objid(ctx, &id);
1640 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1642 hres = disp_propget(ctx->parser->script, disp, id, &v, &ctx->ei, NULL/*FIXME*/);
1646 return stack_push(ctx, &v);
1649 static void free_dp(DISPPARAMS *dp)
1653 for(i=0; i < dp->cArgs; i++)
1654 VariantClear(dp->rgvarg+i);
1655 heap_free(dp->rgvarg);
1658 static HRESULT args_to_param(script_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1664 HRESULT hres = S_OK;
1666 memset(dp, 0, sizeof(*dp));
1670 for(iter = args; iter; iter = iter->next)
1673 vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1675 return E_OUTOFMEMORY;
1677 for(i = cnt, iter = args; iter; iter = iter->next) {
1678 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1682 hres = exprval_to_value(ctx, &exprval, ei, vargs + (--i));
1683 exprval_release(&exprval);
1698 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1703 dp->cArgs = arg_cnt;
1704 dp->rgdispidNamedArgs = NULL;
1707 assert(ctx->top >= arg_cnt);
1709 for(i=1; i*2 <= arg_cnt; i++) {
1710 tmp = ctx->stack[ctx->top-i];
1711 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1712 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1715 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1718 /* ECMA-262 3rd Edition 11.2.2 */
1719 static HRESULT interp_new(exec_ctx_t *ctx)
1721 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1728 constr = stack_topn(ctx, arg);
1730 /* NOTE: Should use to_object here */
1732 if(V_VT(constr) == VT_NULL)
1733 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1734 else if(V_VT(constr) != VT_DISPATCH)
1735 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1736 else if(!V_DISPATCH(constr))
1737 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1739 jsstack_to_dp(ctx, arg, &dp);
1740 hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1741 DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1745 stack_popn(ctx, arg+1);
1746 return stack_push(ctx, &v);
1749 /* ECMA-262 3rd Edition 11.2.3 */
1750 HRESULT call_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1752 call_expression_t *expr = (call_expression_t*)_expr;
1760 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1764 hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1765 if(SUCCEEDED(hres)) {
1766 switch(exprval.type) {
1767 case EXPRVAL_VARIANT:
1768 if(V_VT(&exprval.u.var) == VT_DISPATCH)
1769 hres = disp_call(ctx, V_DISPATCH(&exprval.u.var), DISPID_VALUE,
1770 DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1772 hres = throw_type_error(ctx, ei, JS_E_INVALID_PROPERTY, NULL);
1775 hres = disp_call(ctx, exprval.u.idref.disp, exprval.u.idref.id,
1776 DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1778 case EXPRVAL_INVALID:
1779 hres = throw_type_error(ctx, ei, JS_E_OBJECT_EXPECTED, NULL);
1782 FIXME("unimplemented type %d\n", exprval.type);
1789 exprval_release(&exprval);
1793 ret->type = EXPRVAL_VARIANT;
1794 if(flags & EXPR_NOVAL) {
1795 V_VT(&ret->u.var) = VT_EMPTY;
1797 TRACE("= %s\n", debugstr_variant(&var));
1803 /* ECMA-262 3rd Edition 11.1.1 */
1804 static HRESULT interp_this(exec_ctx_t *ctx)
1810 V_VT(&v) = VT_DISPATCH;
1811 V_DISPATCH(&v) = ctx->this_obj;
1812 IDispatch_AddRef(ctx->this_obj);
1813 return stack_push(ctx, &v);
1816 /* ECMA-262 3rd Edition 10.1.4 */
1817 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1819 identifier_expression_t *expr = (identifier_expression_t*)_expr;
1825 identifier = SysAllocString(expr->identifier);
1827 return E_OUTOFMEMORY;
1829 hres = identifier_eval(ctx, identifier, flags, ei, ret);
1831 SysFreeString(identifier);
1835 /* ECMA-262 3rd Edition 10.1.4 */
1836 static HRESULT interp_ident(exec_ctx_t *ctx)
1838 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1843 TRACE("%s\n", debugstr_w(arg));
1845 hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1849 hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1850 exprval_release(&exprval);
1854 return stack_push(ctx, &v);
1857 /* ECMA-262 3rd Edition 10.1.4 */
1858 static HRESULT interp_identid(exec_ctx_t *ctx)
1860 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1864 TRACE("%s\n", debugstr_w(arg));
1866 hres = identifier_eval(ctx->parser->script, arg, EXPR_NEWREF, &ctx->ei, &exprval);
1870 if(exprval.type != EXPRVAL_IDREF) {
1871 WARN("invalid ref\n");
1872 exprval_release(&exprval);
1873 return stack_push_objid(ctx, NULL, -1);
1876 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1879 /* ECMA-262 3rd Edition 7.8.1 */
1880 static HRESULT interp_null(exec_ctx_t *ctx)
1887 return stack_push(ctx, &v);
1890 /* ECMA-262 3rd Edition 7.8.2 */
1891 static HRESULT interp_bool(exec_ctx_t *ctx)
1893 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1895 TRACE("%s\n", arg ? "true" : "false");
1897 return stack_push_bool(ctx, arg);
1900 /* ECMA-262 3rd Edition 7.8.3 */
1901 static HRESULT interp_int(exec_ctx_t *ctx)
1903 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1910 return stack_push(ctx, &v);
1913 /* ECMA-262 3rd Edition 7.8.3 */
1914 static HRESULT interp_double(exec_ctx_t *ctx)
1916 const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1919 TRACE("%lf\n", arg);
1923 return stack_push(ctx, &v);
1926 /* ECMA-262 3rd Edition 7.8.4 */
1927 static HRESULT interp_str(exec_ctx_t *ctx)
1929 const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1932 TRACE("%s\n", debugstr_w(str));
1935 V_BSTR(&v) = SysAllocString(str);
1937 return E_OUTOFMEMORY;
1939 return stack_push(ctx, &v);
1942 /* ECMA-262 3rd Edition 7.8 */
1943 static HRESULT interp_regexp(exec_ctx_t *ctx)
1945 const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1946 const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1951 TRACE("%s %x\n", debugstr_w(source), flags);
1953 hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, ®exp);
1957 var_set_jsdisp(&v, regexp);
1958 return stack_push(ctx, &v);
1961 /* ECMA-262 3rd Edition 11.1.4 */
1962 HRESULT array_literal_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1964 array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
1965 DWORD length = 0, i = 0;
1966 array_element_t *elem;
1974 for(elem = expr->element_list; elem; elem = elem->next)
1975 length += elem->elision+1;
1976 length += expr->length;
1978 hres = create_array(ctx, length, &array);
1982 for(elem = expr->element_list; elem; elem = elem->next) {
1985 hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
1989 hres = exprval_to_value(ctx, &exprval, ei, &val);
1990 exprval_release(&exprval);
1994 hres = jsdisp_propput_idx(array, i, &val, ei, NULL/*FIXME*/);
2003 jsdisp_release(array);
2007 ret->type = EXPRVAL_VARIANT;
2008 var_set_jsdisp(&ret->u.var, array);
2012 /* ECMA-262 3rd Edition 11.1.5 */
2013 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2015 property_value_expression_t *expr = (property_value_expression_t*)_expr;
2025 hres = create_object(ctx, NULL, &obj);
2029 for(iter = expr->property_list; iter; iter = iter->next) {
2030 hres = literal_to_var(ctx, iter->name, &tmp);
2034 hres = to_string(ctx, &tmp, ei, &name);
2039 hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
2040 if(SUCCEEDED(hres)) {
2041 hres = exprval_to_value(ctx, &exprval, ei, &val);
2042 exprval_release(&exprval);
2043 if(SUCCEEDED(hres)) {
2044 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
2049 SysFreeString(name);
2055 jsdisp_release(obj);
2059 ret->type = EXPRVAL_VARIANT;
2060 var_set_jsdisp(&ret->u.var, obj);
2064 /* ECMA-262 3rd Edition 11.11 */
2065 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2067 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2073 hres = to_boolean(stack_top(ctx), &b);
2086 /* ECMA-262 3rd Edition 11.11 */
2087 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2089 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2095 hres = to_boolean(stack_top(ctx), &b);
2108 /* ECMA-262 3rd Edition 11.10 */
2109 static HRESULT bitor_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2114 hres = to_int32(ctx, lval, ei, &li);
2118 hres = to_int32(ctx, rval, ei, &ri);
2127 /* ECMA-262 3rd Edition 11.10 */
2128 static HRESULT interp_or(exec_ctx_t *ctx)
2135 hres = stack_pop_int(ctx, &r);
2139 hres = stack_pop_int(ctx, &l);
2143 return stack_push_int(ctx, l|r);
2146 /* ECMA-262 3rd Edition 11.10 */
2147 static HRESULT xor_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2152 hres = to_int32(ctx, lval, ei, &li);
2156 hres = to_int32(ctx, rval, ei, &ri);
2165 /* ECMA-262 3rd Edition 11.10 */
2166 static HRESULT interp_xor(exec_ctx_t *ctx)
2173 hres = stack_pop_int(ctx, &r);
2177 hres = stack_pop_int(ctx, &l);
2181 return stack_push_int(ctx, l^r);
2184 /* ECMA-262 3rd Edition 11.10 */
2185 static HRESULT bitand_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2190 hres = to_int32(ctx, lval, ei, &li);
2194 hres = to_int32(ctx, rval, ei, &ri);
2203 /* ECMA-262 3rd Edition 11.10 */
2204 HRESULT binary_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2206 binary_expression_t *expr = (binary_expression_t*)_expr;
2210 return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
2213 /* ECMA-262 3rd Edition 11.8.6 */
2214 static HRESULT instanceof_eval(script_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
2216 jsdisp_t *obj, *iter, *tmp = NULL;
2217 VARIANT_BOOL ret = VARIANT_FALSE;
2222 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2224 if(V_VT(objv) != VT_DISPATCH || !V_DISPATCH(objv))
2225 return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2227 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
2229 FIXME("non-jsdisp objects not supported\n");
2233 if(is_class(obj, JSCLASS_FUNCTION)) {
2234 hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
2236 hres = throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2238 jsdisp_release(obj);
2242 if(V_VT(&var) == VT_DISPATCH) {
2243 if(V_VT(inst) == VT_DISPATCH)
2244 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
2245 for(iter = tmp; iter; iter = iter->prototype) {
2246 hres = disp_cmp(V_DISPATCH(&var), to_disp(iter), &b);
2256 jsdisp_release(tmp);
2258 FIXME("prototype is not an object\n");
2266 V_VT(retv) = VT_BOOL;
2271 /* ECMA-262 3rd Edition 11.8.6 */
2272 HRESULT instanceof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2274 binary_expression_t *expr = (binary_expression_t*)_expr;
2278 return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
2281 /* ECMA-262 3rd Edition 11.8.7 */
2282 static HRESULT interp_in(exec_ctx_t *ctx)
2292 obj = stack_pop(ctx);
2295 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2298 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2301 hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2304 IDispatch_Release(V_DISPATCH(obj));
2308 hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2309 IDispatch_Release(V_DISPATCH(obj));
2313 else if(hres == DISP_E_UNKNOWNNAME)
2318 return stack_push_bool(ctx, ret);
2321 /* ECMA-262 3rd Edition 11.6.1 */
2322 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2327 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2331 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2337 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2338 BSTR lstr = NULL, rstr = NULL;
2340 if(V_VT(&l) == VT_BSTR)
2343 hres = to_string(ctx, &l, ei, &lstr);
2345 if(SUCCEEDED(hres)) {
2346 if(V_VT(&r) == VT_BSTR)
2349 hres = to_string(ctx, &r, ei, &rstr);
2352 if(SUCCEEDED(hres)) {
2355 len1 = SysStringLen(lstr);
2356 len2 = SysStringLen(rstr);
2358 V_VT(retv) = VT_BSTR;
2359 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2360 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2361 memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2364 if(V_VT(&l) != VT_BSTR)
2365 SysFreeString(lstr);
2366 if(V_VT(&r) != VT_BSTR)
2367 SysFreeString(rstr);
2371 hres = to_number(ctx, &l, ei, &nl);
2372 if(SUCCEEDED(hres)) {
2373 hres = to_number(ctx, &r, ei, &nr);
2375 num_set_val(retv, num_val(&nl) + num_val(&nr));
2384 /* ECMA-262 3rd Edition 11.6.1 */
2385 static HRESULT interp_add(exec_ctx_t *ctx)
2387 VARIANT *l, *r, ret;
2393 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2395 hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2401 return stack_push(ctx, &ret);
2404 /* ECMA-262 3rd Edition 11.6.2 */
2405 static HRESULT interp_sub(exec_ctx_t *ctx)
2412 hres = stack_pop_number(ctx, &r);
2416 hres = stack_pop_number(ctx, &l);
2420 return stack_push_number(ctx, num_val(&l)-num_val(&r));
2423 /* ECMA-262 3rd Edition 11.5.1 */
2424 static HRESULT interp_mul(exec_ctx_t *ctx)
2431 hres = stack_pop_number(ctx, &r);
2435 hres = stack_pop_number(ctx, &l);
2439 return stack_push_number(ctx, num_val(&l)*num_val(&r));
2442 /* ECMA-262 3rd Edition 11.5.2 */
2443 static HRESULT interp_div(exec_ctx_t *ctx)
2450 hres = stack_pop_number(ctx, &r);
2454 hres = stack_pop_number(ctx, &l);
2458 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2461 /* ECMA-262 3rd Edition 11.5.3 */
2462 static HRESULT mod_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2467 hres = to_number(ctx, lval, ei, &lnum);
2471 hres = to_number(ctx, rval, ei, &rnum);
2475 num_set_val(retv, fmod(num_val(&lnum), num_val(&rnum)));
2479 /* ECMA-262 3rd Edition 11.5.3 */
2480 static HRESULT interp_mod(exec_ctx_t *ctx)
2487 hres = stack_pop_number(ctx, &r);
2491 hres = stack_pop_number(ctx, &l);
2495 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2498 /* ECMA-262 3rd Edition 11.4.2 */
2499 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2501 unary_expression_t *expr = (unary_expression_t*)_expr;
2502 VARIANT_BOOL b = VARIANT_FALSE;
2508 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2512 switch(exprval.type) {
2513 case EXPRVAL_IDREF: {
2514 IDispatchEx *dispex;
2516 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2517 if(SUCCEEDED(hres)) {
2518 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2520 IDispatchEx_Release(dispex);
2525 FIXME("unsupported type %d\n", exprval.type);
2529 exprval_release(&exprval);
2533 return return_bool(ret, b);
2536 /* ECMA-262 3rd Edition 11.4.2 */
2537 static HRESULT interp_delete(exec_ctx_t *ctx)
2539 VARIANT *obj_var, *name_var;
2540 IDispatchEx *dispex;
2548 name_var = stack_pop(ctx);
2549 obj_var = stack_pop(ctx);
2551 hres = to_object(ctx->parser->script, obj_var, &obj);
2552 VariantClear(obj_var);
2554 VariantClear(name_var);
2558 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2559 VariantClear(name_var);
2561 IDispatch_Release(obj);
2565 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2566 if(SUCCEEDED(hres)) {
2567 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2569 IDispatchEx_Release(dispex);
2575 IDispatch_Release(obj);
2576 SysFreeString(name);
2580 return stack_push_bool(ctx, ret);
2583 /* ECMA-262 3rd Edition 11.4.2 */
2584 static HRESULT interp_void(exec_ctx_t *ctx)
2592 V_VT(&v) = VT_EMPTY;
2593 return stack_push(ctx, &v);
2596 /* ECMA-262 3rd Edition 11.4.3 */
2597 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2602 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2603 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2604 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2605 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2606 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2607 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2608 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2610 if(exprval->type == EXPRVAL_INVALID) {
2615 hres = exprval_to_value(ctx, exprval, ei, &val);
2617 if(exprval->type == EXPRVAL_IDREF) {
2624 switch(V_VT(&val)) {
2644 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2645 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2646 jsdisp_release(dispex);
2653 FIXME("unhandled vt %d\n", V_VT(&val));
2661 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2663 unary_expression_t *expr = (unary_expression_t*)_expr;
2664 const WCHAR *str = NULL;
2670 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2674 hres = typeof_exprval(ctx, &exprval, ei, &str);
2675 exprval_release(&exprval);
2679 ret->type = EXPRVAL_VARIANT;
2680 V_VT(&ret->u.var) = VT_BSTR;
2681 V_BSTR(&ret->u.var) = SysAllocString(str);
2682 if(!V_BSTR(&ret->u.var))
2683 return E_OUTOFMEMORY;
2688 /* ECMA-262 3rd Edition 11.4.7 */
2689 static HRESULT interp_minus(exec_ctx_t *ctx)
2696 hres = stack_pop_number(ctx, &n);
2700 return stack_push_number(ctx, -num_val(&n));
2703 /* ECMA-262 3rd Edition 11.4.6 */
2704 static HRESULT interp_tonum(exec_ctx_t *ctx)
2712 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2717 return stack_push(ctx, &num);
2720 /* ECMA-262 3rd Edition 11.3.1 */
2721 HRESULT post_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2723 unary_expression_t *expr = (unary_expression_t*)_expr;
2730 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2734 hres = exprval_value(ctx, &exprval, ei, &val);
2735 if(SUCCEEDED(hres)) {
2736 hres = to_number(ctx, &val, ei, &num);
2740 if(SUCCEEDED(hres)) {
2742 num_set_val(&inc, num_val(&num)+1.0);
2743 hres = put_value(ctx, &exprval, &inc, ei);
2746 exprval_release(&exprval);
2750 ret->type = EXPRVAL_VARIANT;
2755 /* ECMA-262 3rd Edition 11.3.2 */
2756 HRESULT post_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2758 unary_expression_t *expr = (unary_expression_t*)_expr;
2765 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2769 hres = exprval_value(ctx, &exprval, ei, &val);
2770 if(SUCCEEDED(hres)) {
2771 hres = to_number(ctx, &val, ei, &num);
2775 if(SUCCEEDED(hres)) {
2777 num_set_val(&dec, num_val(&num)-1.0);
2778 hres = put_value(ctx, &exprval, &dec, ei);
2781 exprval_release(&exprval);
2785 ret->type = EXPRVAL_VARIANT;
2790 /* ECMA-262 3rd Edition 11.4.4 */
2791 HRESULT pre_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2793 unary_expression_t *expr = (unary_expression_t*)_expr;
2800 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2804 hres = exprval_value(ctx, &exprval, ei, &val);
2805 if(SUCCEEDED(hres)) {
2806 hres = to_number(ctx, &val, ei, &num);
2810 if(SUCCEEDED(hres)) {
2811 num_set_val(&val, num_val(&num)+1.0);
2812 hres = put_value(ctx, &exprval, &val, ei);
2815 exprval_release(&exprval);
2819 ret->type = EXPRVAL_VARIANT;
2824 /* ECMA-262 3rd Edition 11.4.5 */
2825 HRESULT pre_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2827 unary_expression_t *expr = (unary_expression_t*)_expr;
2834 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2838 hres = exprval_value(ctx, &exprval, ei, &val);
2839 if(SUCCEEDED(hres)) {
2840 hres = to_number(ctx, &val, ei, &num);
2844 if(SUCCEEDED(hres)) {
2845 num_set_val(&val, num_val(&num)-1.0);
2846 hres = put_value(ctx, &exprval, &val, ei);
2849 exprval_release(&exprval);
2853 ret->type = EXPRVAL_VARIANT;
2858 /* ECMA-262 3rd Edition 11.9.3 */
2859 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2861 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2862 return equal2_values(lval, rval, ret);
2864 /* FIXME: NULL disps should be handled in more general way */
2865 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2868 return equal_values(ctx, &v, rval, ei, ret);
2871 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2874 return equal_values(ctx, lval, &v, ei, ret);
2877 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2878 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2883 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2887 hres = to_number(ctx, lval, ei, &v);
2891 return equal_values(ctx, &v, rval, ei, ret);
2894 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2898 hres = to_number(ctx, rval, ei, &v);
2902 return equal_values(ctx, lval, &v, ei, ret);
2905 if(V_VT(rval) == VT_BOOL) {
2909 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2910 return equal_values(ctx, lval, &v, ei, ret);
2913 if(V_VT(lval) == VT_BOOL) {
2917 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2918 return equal_values(ctx, &v, rval, ei, ret);
2922 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2926 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2930 hres = equal_values(ctx, lval, &v, ei, ret);
2937 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2941 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2945 hres = equal_values(ctx, &v, rval, ei, ret);
2956 /* ECMA-262 3rd Edition 11.9.1 */
2957 static HRESULT interp_eq(exec_ctx_t *ctx)
2966 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2968 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2974 return stack_push_bool(ctx, b);
2977 /* ECMA-262 3rd Edition 11.9.2 */
2978 static HRESULT interp_neq(exec_ctx_t *ctx)
2987 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2989 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2995 return stack_push_bool(ctx, !b);
2998 /* ECMA-262 3rd Edition 11.9.4 */
2999 static HRESULT interp_eq2(exec_ctx_t *ctx)
3010 hres = equal2_values(r, l, &b);
3016 return stack_push_bool(ctx, b);
3019 /* ECMA-262 3rd Edition 11.9.5 */
3020 static HRESULT interp_neq2(exec_ctx_t *ctx)
3031 hres = equal2_values(r, l, &b);
3037 return stack_push_bool(ctx, !b);
3040 /* ECMA-262 3rd Edition 11.8.5 */
3041 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
3043 VARIANT l, r, ln, rn;
3046 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
3050 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
3056 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
3057 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
3058 SysFreeString(V_BSTR(&l));
3059 SysFreeString(V_BSTR(&r));
3063 hres = to_number(ctx, &l, ei, &ln);
3066 hres = to_number(ctx, &r, ei, &rn);
3071 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
3072 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
3074 DOUBLE ld = num_val(&ln);
3075 DOUBLE rd = num_val(&rn);
3077 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
3083 /* ECMA-262 3rd Edition 11.8.1 */
3084 static HRESULT interp_lt(exec_ctx_t *ctx)
3093 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
3095 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
3101 return stack_push_bool(ctx, b);
3104 /* ECMA-262 3rd Edition 11.8.1 */
3105 static HRESULT interp_lteq(exec_ctx_t *ctx)
3114 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
3116 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
3122 return stack_push_bool(ctx, b);
3125 /* ECMA-262 3rd Edition 11.8.2 */
3126 static HRESULT interp_gt(exec_ctx_t *ctx)
3135 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
3137 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
3143 return stack_push_bool(ctx, b);
3146 /* ECMA-262 3rd Edition 11.8.4 */
3147 static HRESULT interp_gteq(exec_ctx_t *ctx)
3156 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
3158 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
3164 return stack_push_bool(ctx, b);
3167 /* ECMA-262 3rd Edition 11.4.8 */
3168 static HRESULT interp_bneg(exec_ctx_t *ctx)
3177 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3184 return stack_push(ctx, &r);
3187 /* ECMA-262 3rd Edition 11.4.9 */
3188 static HRESULT interp_neg(exec_ctx_t *ctx)
3197 hres = to_boolean(v, &b);
3202 return stack_push_bool(ctx, !b);
3205 /* ECMA-262 3rd Edition 11.7.1 */
3206 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3212 hres = to_int32(ctx, lval, ei, &li);
3216 hres = to_uint32(ctx, rval, ei, &ri);
3221 V_I4(retv) = li << (ri&0x1f);
3225 /* ECMA-262 3rd Edition 11.7.1 */
3226 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3228 binary_expression_t *expr = (binary_expression_t*)_expr;
3232 return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3235 /* ECMA-262 3rd Edition 11.7.2 */
3236 static HRESULT rshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3242 hres = to_int32(ctx, lval, ei, &li);
3246 hres = to_uint32(ctx, rval, ei, &ri);
3251 V_I4(retv) = li >> (ri&0x1f);
3255 /* ECMA-262 3rd Edition 11.7.2 */
3256 HRESULT right_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3258 binary_expression_t *expr = (binary_expression_t*)_expr;
3262 return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
3265 /* ECMA-262 3rd Edition 11.7.3 */
3266 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3271 hres = to_uint32(ctx, lval, ei, &li);
3275 hres = to_uint32(ctx, rval, ei, &ri);
3280 V_I4(retv) = li >> (ri&0x1f);
3284 /* ECMA-262 3rd Edition 11.7.3 */
3285 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3287 binary_expression_t *expr = (binary_expression_t*)_expr;
3291 return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3294 /* ECMA-262 3rd Edition 11.13.1 */
3295 static HRESULT interp_assign(exec_ctx_t *ctx)
3305 disp = stack_pop_objid(ctx, &id);
3308 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3310 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3311 IDispatch_Release(disp);
3317 return stack_push(ctx, v);
3320 /* ECMA-262 3rd Edition 11.13.2 */
3321 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3323 binary_expression_t *expr = (binary_expression_t*)_expr;
3327 return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3330 /* ECMA-262 3rd Edition 11.13.2 */
3331 HRESULT assign_rshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3333 binary_expression_t *expr = (binary_expression_t*)_expr;
3337 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
3340 /* ECMA-262 3rd Edition 11.13.2 */
3341 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3343 binary_expression_t *expr = (binary_expression_t*)_expr;
3347 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3350 /* ECMA-262 3rd Edition 11.13.2 */
3351 HRESULT assign_mod_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3353 binary_expression_t *expr = (binary_expression_t*)_expr;
3357 return assign_oper_eval(ctx, expr->expression1, expr->expression2, mod_eval, ei, ret);
3360 /* ECMA-262 3rd Edition 11.13.2 */
3361 HRESULT assign_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3363 binary_expression_t *expr = (binary_expression_t*)_expr;
3367 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
3370 /* ECMA-262 3rd Edition 11.13.2 */
3371 HRESULT assign_or_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3373 binary_expression_t *expr = (binary_expression_t*)_expr;
3377 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
3380 /* ECMA-262 3rd Edition 11.13.2 */
3381 HRESULT assign_xor_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3383 binary_expression_t *expr = (binary_expression_t*)_expr;
3387 return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
3390 static HRESULT interp_jmp(exec_ctx_t *ctx)
3392 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3400 static HRESULT interp_pop(exec_ctx_t *ctx)
3408 static HRESULT interp_ret(exec_ctx_t *ctx)
3416 static HRESULT interp_tree(exec_ctx_t *ctx)
3418 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3425 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3429 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3430 exprval_release(&val);
3434 return stack_push(ctx, &v);
3437 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3439 static const op_func_t op_funcs[] = {
3440 #define X(x,a,b,c) interp_##x,
3445 static const unsigned op_move[] = {
3446 #define X(a,x,b,c) x,
3451 HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3453 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3454 unsigned prev_ip, prev_top;
3456 HRESULT hres = S_OK;
3460 prev_top = exec_ctx->top;
3461 prev_ip = exec_ctx->ip;
3462 exec_ctx->ip = expr->instr_off;
3464 while(exec_ctx->ip != -1) {
3465 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3466 hres = op_funcs[op](exec_ctx);
3469 exec_ctx->ip += op_move[op];
3472 exec_ctx->ip = prev_ip;
3475 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3477 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3481 assert(exec_ctx->top == prev_top+1);
3483 ret->type = EXPRVAL_VARIANT;
3484 ret->u.var = *stack_pop(exec_ctx);
3488 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3494 hres = compile_subscript(ctx->exec_ctx->parser, expr, &expr->instr_off);
3498 if(expr->eval == compiled_expression_eval)
3499 expr->eval = interp_expression_eval;
3501 return expr->eval(ctx, expr, flags, ei, ret);