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 IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
179 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
181 *id = V_INT(stack_pop(ctx));
182 return V_DISPATCH(stack_pop(ctx));
185 static inline IDispatch *stack_topn_objid(exec_ctx_t *ctx, unsigned n, DISPID *id)
187 assert(V_VT(stack_topn(ctx, n)) == VT_INT && V_VT(stack_topn(ctx, n+1)) == VT_DISPATCH);
189 *id = V_INT(stack_topn(ctx, n));
190 return V_DISPATCH(stack_topn(ctx, n+1));
193 static void exprval_release(exprval_t *val)
196 case EXPRVAL_VARIANT:
197 if(V_VT(&val->u.var) != VT_EMPTY)
198 VariantClear(&val->u.var);
201 if(val->u.idref.disp)
202 IDispatch_Release(val->u.idref.disp);
204 case EXPRVAL_INVALID:
205 SysFreeString(val->u.identifier);
209 /* ECMA-262 3rd Edition 8.7.1 */
210 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
212 V_VT(ret) = VT_EMPTY;
215 case EXPRVAL_VARIANT:
216 return VariantCopy(ret, &val->u.var);
218 if(!val->u.idref.disp) {
219 FIXME("throw ReferenceError\n");
223 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
224 case EXPRVAL_INVALID:
225 return throw_type_error(ctx, ei, JS_E_UNDEFINED_VARIABLE, val->u.identifier);
228 ERR("type %d\n", val->type);
232 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
234 if(val->type == EXPRVAL_VARIANT) {
236 V_VT(&val->u.var) = VT_EMPTY;
240 return exprval_value(ctx, val, ei, ret);
243 static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
245 if(exprval->type != EXPRVAL_VARIANT) {
249 hres = exprval_to_value(ctx, exprval, ei, &val);
253 hres = to_boolean(&val, b);
258 return to_boolean(&exprval->u.var, b);
261 static void exprval_init(exprval_t *val)
263 val->type = EXPRVAL_VARIANT;
264 V_VT(&val->u.var) = VT_EMPTY;
267 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
269 val->type = EXPRVAL_IDREF;
270 val->u.idref.disp = disp;
271 val->u.idref.id = id;
274 IDispatch_AddRef(disp);
277 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
279 scope_chain_t *new_scope;
281 new_scope = heap_alloc(sizeof(scope_chain_t));
283 return E_OUTOFMEMORY;
288 new_scope->obj = obj;
292 new_scope->next = scope;
294 new_scope->next = NULL;
301 static void scope_pop(scope_chain_t **scope)
310 void scope_release(scope_chain_t *scope)
316 scope_release(scope->next);
318 jsdisp_release(scope->obj);
322 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
323 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
327 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
329 return E_OUTOFMEMORY;
332 ctx->is_global = is_global;
335 ctx->this_obj = this_obj;
336 else if(script_ctx->host_global)
337 ctx->this_obj = script_ctx->host_global;
339 ctx->this_obj = to_disp(script_ctx->global);
340 IDispatch_AddRef(ctx->this_obj);
342 jsdisp_addref(var_disp);
343 ctx->var_disp = var_disp;
347 ctx->scope_chain = scope;
354 void exec_release(exec_ctx_t *ctx)
360 scope_release(ctx->scope_chain);
362 jsdisp_release(ctx->var_disp);
364 IDispatch_Release(ctx->this_obj);
365 heap_free(ctx->stack);
369 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
374 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
376 TRACE("unsing IDispatch\n");
379 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
383 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
384 IDispatchEx_Release(dispex);
388 /* ECMA-262 3rd Edition 8.7.2 */
389 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
391 if(ref->type != EXPRVAL_IDREF)
392 return throw_reference_error(ctx, ei, JS_E_ILLEGAL_ASSIGN, NULL);
394 return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
397 static inline BOOL is_null(const VARIANT *v)
399 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
402 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
404 IObjectIdentity *identity;
405 IUnknown *unk1, *unk2;
413 if(!disp1 || !disp2) {
418 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
422 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
424 IUnknown_Release(unk1);
431 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
432 if(SUCCEEDED(hres)) {
433 hres = IObjectIdentity_IsEqualObject(identity, unk2);
434 IObjectIdentity_Release(identity);
441 IUnknown_Release(unk1);
442 IUnknown_Release(unk2);
446 /* ECMA-262 3rd Edition 11.9.6 */
447 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
451 if(V_VT(lval) != V_VT(rval)) {
452 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
453 *ret = num_val(lval) == num_val(rval);
454 else if(is_null(lval))
455 *ret = is_null(rval);
467 *ret = V_I4(lval) == V_I4(rval);
470 *ret = V_R8(lval) == V_R8(rval);
474 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
475 else if(!V_BSTR(rval))
476 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
478 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
481 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
483 *ret = !V_BOOL(lval) == !V_BOOL(rval);
486 FIXME("unimplemented vt %d\n", V_VT(lval));
493 static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
495 switch(literal->type) {
501 V_I4(v) = literal->u.lval;
505 V_R8(v) = literal->u.dval;
508 BSTR str = SysAllocString(literal->u.wstr);
510 return E_OUTOFMEMORY;
518 V_BOOL(v) = literal->u.bval;
524 hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
525 literal->u.regexp.flags, ®exp);
529 var_set_jsdisp(v, regexp);
536 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
542 for(item = ctx->named_items; item; item = item->next) {
543 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
544 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
545 if(SUCCEEDED(hres)) {
547 exprval_set_idref(ret, item->disp, id);
556 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, BOOL from_eval,
557 jsexcept_t *ei, VARIANT *retv)
559 script_ctx_t *script = parser->script;
560 function_declaration_t *func;
561 parser_ctx_t *prev_parser;
565 exec_ctx_t *prev_ctx;
569 for(func = source->functions; func; func = func->next) {
573 hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
574 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
578 var_set_jsdisp(&var, func_obj);
579 hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
580 jsdisp_release(func_obj);
585 for(var = source->variables; var; var = var->next) {
589 name = SysAllocString(var->identifier);
591 return E_OUTOFMEMORY;
593 if(!ctx->is_global || !lookup_global_members(parser->script, name, NULL))
594 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
600 prev_ctx = script->exec_ctx;
601 script->exec_ctx = ctx;
603 prev_parser = ctx->parser;
604 ctx->parser = parser;
606 V_VT(&val) = VT_EMPTY;
607 memset(&rt, 0, sizeof(rt));
610 for(stat = source->statement; stat; stat = stat->next) {
611 hres = stat_eval(script, stat, &rt, &tmp);
617 if(rt.type != RT_NORMAL)
621 script->exec_ctx = prev_ctx;
622 ctx->parser = prev_parser;
624 if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
625 FIXME("wrong rt %d\n", rt.type);
635 if(!retv || (!from_eval && rt.type != RT_RETURN))
642 /* ECMA-262 3rd Edition 10.1.4 */
643 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
645 scope_chain_t *scope;
650 TRACE("%s\n", debugstr_w(identifier));
652 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
653 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
654 if(SUCCEEDED(hres)) {
655 exprval_set_idref(ret, to_disp(scope->obj), id);
660 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
661 if(SUCCEEDED(hres)) {
662 exprval_set_idref(ret, to_disp(ctx->global), id);
666 for(item = ctx->named_items; item; item = item->next) {
667 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
674 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
675 SCRIPTINFO_IUNKNOWN, &unk, NULL);
677 WARN("GetItemInfo failed: %08x\n", hres);
681 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
682 IUnknown_Release(unk);
684 WARN("object does not implement IDispatch\n");
689 ret->type = EXPRVAL_VARIANT;
690 V_VT(&ret->u.var) = VT_DISPATCH;
691 V_DISPATCH(&ret->u.var) = item->disp;
692 IDispatch_AddRef(item->disp);
697 if(lookup_global_members(ctx, identifier, ret))
700 if(flags & EXPR_NEWREF) {
701 hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
705 exprval_set_idref(ret, to_disp(ctx->global), id);
709 ret->type = EXPRVAL_INVALID;
710 ret->u.identifier = SysAllocString(identifier);
711 if(!ret->u.identifier)
712 return E_OUTOFMEMORY;
717 /* ECMA-262 3rd Edition 12.1 */
718 HRESULT block_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
720 block_statement_t *stat = (block_statement_t*)_stat;
727 V_VT(&val) = VT_EMPTY;
728 for(iter = stat->stat_list; iter; iter = iter->next) {
729 hres = stat_eval(ctx, iter, rt, &tmp);
735 if(rt->type != RT_NORMAL)
748 /* ECMA-262 3rd Edition 12.2 */
749 static HRESULT variable_list_eval(script_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
751 variable_declaration_t *iter;
754 for(iter = var_list; iter; iter = iter->next) {
761 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
765 hres = exprval_to_value(ctx, &exprval, ei, &val);
766 exprval_release(&exprval);
770 hres = jsdisp_propput_name(ctx->exec_ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
779 /* ECMA-262 3rd Edition 12.2 */
780 HRESULT var_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
782 var_statement_t *stat = (var_statement_t*)_stat;
787 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
791 V_VT(ret) = VT_EMPTY;
795 /* ECMA-262 3rd Edition 12.3 */
796 HRESULT empty_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
800 V_VT(ret) = VT_EMPTY;
804 /* ECMA-262 3rd Edition 12.4 */
805 HRESULT expression_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
807 expression_statement_t *stat = (expression_statement_t*)_stat;
814 hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
818 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
819 exprval_release(&exprval);
824 TRACE("= %s\n", debugstr_variant(ret));
828 /* ECMA-262 3rd Edition 12.5 */
829 HRESULT if_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
831 if_statement_t *stat = (if_statement_t*)_stat;
838 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
842 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
843 exprval_release(&exprval);
848 hres = stat_eval(ctx, stat->if_stat, rt, ret);
849 else if(stat->else_stat)
850 hres = stat_eval(ctx, stat->else_stat, rt, ret);
852 V_VT(ret) = VT_EMPTY;
857 /* ECMA-262 3rd Edition 12.6.2 */
858 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
860 while_statement_t *stat = (while_statement_t*)_stat;
869 V_VT(&val) = VT_EMPTY;
870 test_expr = !stat->do_while;
874 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
878 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
879 exprval_release(&exprval);
880 if(FAILED(hres) || !b)
886 hres = stat_eval(ctx, stat->statement, rt, &tmp);
893 if(rt->type == RT_CONTINUE)
894 rt->type = RT_NORMAL;
895 if(rt->type != RT_NORMAL)
904 if(rt->type == RT_BREAK)
905 rt->type = RT_NORMAL;
911 /* ECMA-262 3rd Edition 12.6.3 */
912 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
914 for_statement_t *stat = (for_statement_t*)_stat;
915 VARIANT val, tmp, retv;
922 if(stat->variable_list) {
923 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
926 }else if(stat->begin_expr) {
927 hres = expr_eval(ctx, stat->begin_expr, EXPR_NEWREF, &rt->ei, &exprval);
931 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
932 exprval_release(&exprval);
939 V_VT(&retv) = VT_EMPTY;
943 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
947 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
948 exprval_release(&exprval);
949 if(FAILED(hres) || !b)
953 hres = stat_eval(ctx, stat->statement, rt, &tmp);
960 if(rt->type == RT_CONTINUE)
961 rt->type = RT_NORMAL;
962 else if(rt->type != RT_NORMAL)
966 hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
970 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
971 exprval_release(&exprval);
984 if(rt->type == RT_BREAK)
985 rt->type = RT_NORMAL;
991 /* ECMA-262 3rd Edition 12.6.4 */
992 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
994 forin_statement_t *stat = (forin_statement_t*)_stat;
995 VARIANT val, name, retv, tmp;
996 DISPID id = DISPID_STARTENUM;
997 BSTR str, identifier = NULL;
1004 if(stat->variable) {
1005 hres = variable_list_eval(ctx, stat->variable, &rt->ei);
1010 hres = expr_eval(ctx, stat->in_expr, EXPR_NEWREF, &rt->ei, &exprval);
1014 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1015 exprval_release(&exprval);
1019 if(V_VT(&val) != VT_DISPATCH) {
1020 TRACE("in vt %d\n", V_VT(&val));
1022 V_VT(ret) = VT_EMPTY;
1026 hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
1027 IDispatch_Release(V_DISPATCH(&val));
1029 TRACE("Object doesn't support IDispatchEx\n");
1030 V_VT(ret) = VT_EMPTY;
1034 V_VT(&retv) = VT_EMPTY;
1037 identifier = SysAllocString(stat->variable->identifier);
1040 hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
1041 if(FAILED(hres) || hres == S_FALSE)
1044 hres = IDispatchEx_GetMemberName(in_obj, id, &str);
1048 TRACE("iter %s\n", debugstr_w(str));
1051 hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
1053 hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
1054 if(SUCCEEDED(hres)) {
1055 V_VT(&name) = VT_BSTR;
1056 V_BSTR(&name) = str;
1057 hres = put_value(ctx, &exprval, &name, &rt->ei);
1058 exprval_release(&exprval);
1064 hres = stat_eval(ctx, stat->statement, rt, &tmp);
1068 VariantClear(&retv);
1071 if(rt->type == RT_CONTINUE)
1072 rt->type = RT_NORMAL;
1073 else if(rt->type != RT_NORMAL)
1077 SysFreeString(identifier);
1078 IDispatchEx_Release(in_obj);
1080 VariantClear(&retv);
1084 if(rt->type == RT_BREAK)
1085 rt->type = RT_NORMAL;
1091 /* ECMA-262 3rd Edition 12.7 */
1092 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1094 branch_statement_t *stat = (branch_statement_t*)_stat;
1098 if(stat->identifier) {
1099 FIXME("indentifier not implemented\n");
1103 rt->type = RT_CONTINUE;
1104 V_VT(ret) = VT_EMPTY;
1108 /* ECMA-262 3rd Edition 12.8 */
1109 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1111 branch_statement_t *stat = (branch_statement_t*)_stat;
1115 if(stat->identifier) {
1116 FIXME("indentifier not implemented\n");
1120 rt->type = RT_BREAK;
1121 V_VT(ret) = VT_EMPTY;
1125 /* ECMA-262 3rd Edition 12.9 */
1126 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1128 expression_statement_t *stat = (expression_statement_t*)_stat;
1136 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1140 hres = exprval_to_value(ctx, &exprval, &rt->ei, ret);
1141 exprval_release(&exprval);
1145 V_VT(ret) = VT_EMPTY;
1148 TRACE("= %s\n", debugstr_variant(ret));
1149 rt->type = RT_RETURN;
1153 /* ECMA-262 3rd Edition 12.10 */
1154 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1156 with_statement_t *stat = (with_statement_t*)_stat;
1165 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1169 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1170 exprval_release(&exprval);
1174 hres = to_object(ctx, &val, &disp);
1179 obj = iface_to_jsdisp((IUnknown*)disp);
1180 IDispatch_Release(disp);
1182 FIXME("disp id not jsdisp\n");
1186 hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1187 jsdisp_release(obj);
1191 hres = stat_eval(ctx, stat->statement, rt, ret);
1193 scope_pop(&ctx->exec_ctx->scope_chain);
1197 /* ECMA-262 3rd Edition 12.12 */
1198 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1204 /* ECMA-262 3rd Edition 12.13 */
1205 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1207 switch_statement_t *stat = (switch_statement_t*)_stat;
1208 case_clausule_t *iter, *default_clausule = NULL;
1209 statement_t *stat_iter;
1217 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1221 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1222 exprval_release(&exprval);
1226 for(iter = stat->case_list; iter; iter = iter->next) {
1228 default_clausule = iter;
1232 hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
1236 hres = exprval_to_value(ctx, &exprval, &rt->ei, &cval);
1237 exprval_release(&exprval);
1241 hres = equal2_values(&val, &cval, &b);
1242 VariantClear(&cval);
1243 if(FAILED(hres) || b)
1252 iter = default_clausule;
1254 V_VT(&val) = VT_EMPTY;
1258 for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1259 hres = stat_eval(ctx, stat_iter, rt, &tmp);
1266 if(rt->type != RT_NORMAL)
1276 if(rt->type == RT_BREAK)
1277 rt->type = RT_NORMAL;
1283 /* ECMA-262 3rd Edition 12.13 */
1284 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1286 expression_statement_t *stat = (expression_statement_t*)_stat;
1293 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1297 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1298 exprval_release(&exprval);
1303 return DISP_E_EXCEPTION;
1306 static HRESULT interp_throw(exec_ctx_t *ctx)
1308 const HRESULT arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1310 TRACE("%08x\n", arg);
1312 return throw_reference_error(ctx->parser->script, &ctx->ei, arg, NULL);
1315 /* ECMA-262 3rd Edition 12.14 */
1316 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1323 memset(&rt->ei, 0, sizeof(jsexcept_t));
1325 hres = create_dispex(ctx, NULL, NULL, &var_disp);
1326 if(SUCCEEDED(hres)) {
1327 hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1328 if(SUCCEEDED(hres)) {
1329 hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1330 if(SUCCEEDED(hres)) {
1331 hres = stat_eval(ctx, block->statement, rt, &val);
1332 scope_pop(&ctx->exec_ctx->scope_chain);
1336 jsdisp_release(var_disp);
1347 /* ECMA-262 3rd Edition 12.14 */
1348 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1350 try_statement_t *stat = (try_statement_t*)_stat;
1356 hres = stat_eval(ctx, stat->try_statement, rt, &val);
1358 TRACE("EXCEPTION\n");
1359 if(!stat->catch_block)
1362 hres = catch_eval(ctx, stat->catch_block, rt, &val);
1367 if(stat->finally_statement) {
1369 hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1378 static HRESULT return_bool(exprval_t *ret, DWORD b)
1380 ret->type = EXPRVAL_VARIANT;
1381 V_VT(&ret->u.var) = VT_BOOL;
1382 V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1387 static HRESULT get_binary_expr_values(script_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
1392 hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1396 hres = exprval_to_value(ctx, &exprval, ei, lval);
1397 exprval_release(&exprval);
1401 hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1402 if(SUCCEEDED(hres)) {
1403 hres = exprval_to_value(ctx, &exprval, ei, rval);
1404 exprval_release(&exprval);
1415 typedef HRESULT (*oper_t)(script_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
1417 static HRESULT binary_expr_eval(script_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
1420 VARIANT lval, rval, retv;
1423 hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1427 hres = oper(ctx, &lval, &rval, ei, &retv);
1428 VariantClear(&lval);
1429 VariantClear(&rval);
1433 ret->type = EXPRVAL_VARIANT;
1438 /* ECMA-262 3rd Edition 11.13.2 */
1439 static HRESULT assign_oper_eval(script_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1440 jsexcept_t *ei, exprval_t *ret)
1442 VARIANT retv, lval, rval;
1443 exprval_t exprval, exprvalr;
1446 hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1450 hres = exprval_value(ctx, &exprval, ei, &lval);
1451 if(SUCCEEDED(hres)) {
1452 hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1453 if(SUCCEEDED(hres)) {
1454 hres = exprval_value(ctx, &exprvalr, ei, &rval);
1455 exprval_release(&exprvalr);
1457 if(SUCCEEDED(hres)) {
1458 hres = oper(ctx, &lval, &rval, ei, &retv);
1459 VariantClear(&rval);
1461 VariantClear(&lval);
1464 if(SUCCEEDED(hres)) {
1465 hres = put_value(ctx, &exprval, &retv, ei);
1467 VariantClear(&retv);
1469 exprval_release(&exprval);
1474 ret->type = EXPRVAL_VARIANT;
1479 /* ECMA-262 3rd Edition 13 */
1480 HRESULT function_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1482 function_expression_t *expr = (function_expression_t*)_expr;
1488 if(expr->identifier) {
1489 hres = jsdisp_propget_name(ctx->exec_ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
1495 hres = create_source_function(ctx->exec_ctx->parser, expr->parameter_list, expr->source_elements, ctx->exec_ctx->scope_chain,
1496 expr->src_str, expr->src_len, &dispex);
1500 var_set_jsdisp(&var, dispex);
1503 ret->type = EXPRVAL_VARIANT;
1508 /* ECMA-262 3rd Edition 11.2.1 */
1509 HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1511 array_expression_t *expr = (array_expression_t*)_expr;
1513 VARIANT member, val;
1516 IDispatch *obj = NULL;
1521 hres = expr_eval(ctx, expr->member_expr, 0, ei, &exprval);
1525 hres = exprval_to_value(ctx, &exprval, ei, &member);
1526 exprval_release(&exprval);
1530 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1531 if(SUCCEEDED(hres)) {
1532 hres = exprval_to_value(ctx, &exprval, ei, &val);
1533 exprval_release(&exprval);
1536 if(SUCCEEDED(hres)) {
1537 hres = to_object(ctx, &member, &obj);
1541 VariantClear(&member);
1542 if(SUCCEEDED(hres)) {
1543 hres = to_string(ctx, &val, ei, &str);
1545 if(SUCCEEDED(hres)) {
1546 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1550 if(SUCCEEDED(hres)) {
1551 exprval_set_idref(ret, obj, id);
1552 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1557 IDispatch_Release(obj);
1563 /* ECMA-262 3rd Edition 11.2.1 */
1564 HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1566 member_expression_t *expr = (member_expression_t*)_expr;
1567 IDispatch *obj = NULL;
1576 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1580 hres = exprval_to_value(ctx, &exprval, ei, &member);
1581 exprval_release(&exprval);
1585 hres = to_object(ctx, &member, &obj);
1586 VariantClear(&member);
1590 str = SysAllocString(expr->identifier);
1592 IDispatch_Release(obj);
1593 return E_OUTOFMEMORY;
1596 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1598 if(SUCCEEDED(hres)) {
1599 exprval_set_idref(ret, obj, id);
1600 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1605 IDispatch_Release(obj);
1609 /* ECMA-262 3rd Edition 11.2.1 */
1610 static HRESULT interp_member(exec_ctx_t *ctx)
1612 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1620 hres = stack_pop_object(ctx, &obj);
1624 hres = disp_get_id(ctx->parser->script, obj, arg, 0, &id);
1625 if(SUCCEEDED(hres)) {
1626 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1627 }else if(hres == DISP_E_UNKNOWNNAME) {
1628 V_VT(&v) = VT_EMPTY;
1631 IDispatch_Release(obj);
1635 return stack_push(ctx, &v);
1638 /* ECMA-262 3rd Edition 11.2.1 */
1639 static HRESULT interp_memberid(exec_ctx_t *ctx)
1641 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1642 VARIANT *objv, *namev;
1650 namev = stack_pop(ctx);
1651 objv = stack_pop(ctx);
1653 hres = to_object(ctx->parser->script, objv, &obj);
1655 if(SUCCEEDED(hres)) {
1656 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1658 IDispatch_Release(obj);
1660 VariantClear(namev);
1664 hres = disp_get_id(ctx->parser->script, obj, name, arg, &id);
1665 SysFreeString(name);
1667 IDispatch_Release(obj);
1668 if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1670 id = JS_E_INVALID_PROPERTY;
1676 return stack_push_objid(ctx, obj, id);
1679 /* ECMA-262 3rd Edition 11.2.1 */
1680 static HRESULT interp_refval(exec_ctx_t *ctx)
1689 disp = stack_topn_objid(ctx, 0, &id);
1691 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1693 hres = disp_propget(ctx->parser->script, disp, id, &v, &ctx->ei, NULL/*FIXME*/);
1697 return stack_push(ctx, &v);
1700 static void free_dp(DISPPARAMS *dp)
1704 for(i=0; i < dp->cArgs; i++)
1705 VariantClear(dp->rgvarg+i);
1706 heap_free(dp->rgvarg);
1709 static HRESULT args_to_param(script_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1715 HRESULT hres = S_OK;
1717 memset(dp, 0, sizeof(*dp));
1721 for(iter = args; iter; iter = iter->next)
1724 vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1726 return E_OUTOFMEMORY;
1728 for(i = cnt, iter = args; iter; iter = iter->next) {
1729 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1733 hres = exprval_to_value(ctx, &exprval, ei, vargs + (--i));
1734 exprval_release(&exprval);
1749 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1754 dp->cArgs = arg_cnt;
1755 dp->rgdispidNamedArgs = NULL;
1758 assert(ctx->top >= arg_cnt);
1760 for(i=1; i*2 <= arg_cnt; i++) {
1761 tmp = ctx->stack[ctx->top-i];
1762 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1763 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1766 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1769 /* ECMA-262 3rd Edition 11.2.2 */
1770 static HRESULT interp_new(exec_ctx_t *ctx)
1772 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1779 constr = stack_topn(ctx, arg);
1781 /* NOTE: Should use to_object here */
1783 if(V_VT(constr) == VT_NULL)
1784 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1785 else if(V_VT(constr) != VT_DISPATCH)
1786 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1787 else if(!V_DISPATCH(constr))
1788 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1790 jsstack_to_dp(ctx, arg, &dp);
1791 hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1792 DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1796 stack_popn(ctx, arg+1);
1797 return stack_push(ctx, &v);
1800 /* ECMA-262 3rd Edition 11.2.3 */
1801 HRESULT call_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1803 call_expression_t *expr = (call_expression_t*)_expr;
1811 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1815 hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1816 if(SUCCEEDED(hres)) {
1817 switch(exprval.type) {
1818 case EXPRVAL_VARIANT:
1819 if(V_VT(&exprval.u.var) == VT_DISPATCH)
1820 hres = disp_call(ctx, V_DISPATCH(&exprval.u.var), DISPID_VALUE,
1821 DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1823 hres = throw_type_error(ctx, ei, JS_E_INVALID_PROPERTY, NULL);
1827 case EXPRVAL_INVALID:
1828 hres = throw_type_error(ctx, ei, JS_E_OBJECT_EXPECTED, NULL);
1831 FIXME("unimplemented type %d\n", exprval.type);
1838 exprval_release(&exprval);
1842 ret->type = EXPRVAL_VARIANT;
1843 if(flags & EXPR_NOVAL) {
1844 V_VT(&ret->u.var) = VT_EMPTY;
1846 TRACE("= %s\n", debugstr_variant(&var));
1852 /* ECMA-262 3rd Edition 11.2.3 */
1853 static HRESULT interp_call_member(exec_ctx_t *ctx)
1855 const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1856 const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1863 TRACE("%d %d\n", argn, do_ret);
1865 obj = stack_topn_objid(ctx, argn, &id);
1867 return throw_type_error(ctx->parser->script, &ctx->ei, id, NULL);
1869 jsstack_to_dp(ctx, argn, &dp);
1870 hres = disp_call(ctx->parser->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1874 stack_popn(ctx, argn+2);
1875 return do_ret ? stack_push(ctx, &v) : S_OK;
1879 /* ECMA-262 3rd Edition 11.1.1 */
1880 static HRESULT interp_this(exec_ctx_t *ctx)
1886 V_VT(&v) = VT_DISPATCH;
1887 V_DISPATCH(&v) = ctx->this_obj;
1888 IDispatch_AddRef(ctx->this_obj);
1889 return stack_push(ctx, &v);
1892 /* ECMA-262 3rd Edition 10.1.4 */
1893 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1895 identifier_expression_t *expr = (identifier_expression_t*)_expr;
1901 identifier = SysAllocString(expr->identifier);
1903 return E_OUTOFMEMORY;
1905 hres = identifier_eval(ctx, identifier, flags, ei, ret);
1907 SysFreeString(identifier);
1911 /* ECMA-262 3rd Edition 10.1.4 */
1912 static HRESULT interp_ident(exec_ctx_t *ctx)
1914 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1919 TRACE("%s\n", debugstr_w(arg));
1921 hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1925 hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1926 exprval_release(&exprval);
1930 return stack_push(ctx, &v);
1933 /* ECMA-262 3rd Edition 10.1.4 */
1934 static HRESULT interp_identid(exec_ctx_t *ctx)
1936 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1937 const unsigned flags = ctx->parser->code->instrs[ctx->ip].arg2.uint;
1941 TRACE("%s %x\n", debugstr_w(arg), flags);
1943 hres = identifier_eval(ctx->parser->script, arg, (flags&fdexNameEnsure) ? EXPR_NEWREF : 0, &ctx->ei, &exprval);
1947 if(exprval.type != EXPRVAL_IDREF) {
1948 WARN("invalid ref\n");
1949 exprval_release(&exprval);
1950 return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1953 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1956 /* ECMA-262 3rd Edition 7.8.1 */
1957 static HRESULT interp_null(exec_ctx_t *ctx)
1964 return stack_push(ctx, &v);
1967 /* ECMA-262 3rd Edition 7.8.2 */
1968 static HRESULT interp_bool(exec_ctx_t *ctx)
1970 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1972 TRACE("%s\n", arg ? "true" : "false");
1974 return stack_push_bool(ctx, arg);
1977 /* ECMA-262 3rd Edition 7.8.3 */
1978 static HRESULT interp_int(exec_ctx_t *ctx)
1980 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1987 return stack_push(ctx, &v);
1990 /* ECMA-262 3rd Edition 7.8.3 */
1991 static HRESULT interp_double(exec_ctx_t *ctx)
1993 const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1996 TRACE("%lf\n", arg);
2000 return stack_push(ctx, &v);
2003 /* ECMA-262 3rd Edition 7.8.4 */
2004 static HRESULT interp_str(exec_ctx_t *ctx)
2006 const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
2009 TRACE("%s\n", debugstr_w(str));
2012 V_BSTR(&v) = SysAllocString(str);
2014 return E_OUTOFMEMORY;
2016 return stack_push(ctx, &v);
2019 /* ECMA-262 3rd Edition 7.8 */
2020 static HRESULT interp_regexp(exec_ctx_t *ctx)
2022 const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
2023 const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
2028 TRACE("%s %x\n", debugstr_w(source), flags);
2030 hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, ®exp);
2034 var_set_jsdisp(&v, regexp);
2035 return stack_push(ctx, &v);
2038 /* ECMA-262 3rd Edition 11.1.4 */
2039 HRESULT array_literal_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2041 array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
2042 DWORD length = 0, i = 0;
2043 array_element_t *elem;
2051 for(elem = expr->element_list; elem; elem = elem->next)
2052 length += elem->elision+1;
2053 length += expr->length;
2055 hres = create_array(ctx, length, &array);
2059 for(elem = expr->element_list; elem; elem = elem->next) {
2062 hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
2066 hres = exprval_to_value(ctx, &exprval, ei, &val);
2067 exprval_release(&exprval);
2071 hres = jsdisp_propput_idx(array, i, &val, ei, NULL/*FIXME*/);
2080 jsdisp_release(array);
2084 ret->type = EXPRVAL_VARIANT;
2085 var_set_jsdisp(&ret->u.var, array);
2089 /* ECMA-262 3rd Edition 11.1.5 */
2090 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2092 property_value_expression_t *expr = (property_value_expression_t*)_expr;
2102 hres = create_object(ctx, NULL, &obj);
2106 for(iter = expr->property_list; iter; iter = iter->next) {
2107 hres = literal_to_var(ctx, iter->name, &tmp);
2111 hres = to_string(ctx, &tmp, ei, &name);
2116 hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
2117 if(SUCCEEDED(hres)) {
2118 hres = exprval_to_value(ctx, &exprval, ei, &val);
2119 exprval_release(&exprval);
2120 if(SUCCEEDED(hres)) {
2121 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
2126 SysFreeString(name);
2132 jsdisp_release(obj);
2136 ret->type = EXPRVAL_VARIANT;
2137 var_set_jsdisp(&ret->u.var, obj);
2141 /* ECMA-262 3rd Edition 11.11 */
2142 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2144 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2150 hres = to_boolean(stack_top(ctx), &b);
2163 /* ECMA-262 3rd Edition 11.11 */
2164 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2166 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2172 hres = to_boolean(stack_top(ctx), &b);
2185 /* ECMA-262 3rd Edition 11.10 */
2186 static HRESULT interp_or(exec_ctx_t *ctx)
2193 hres = stack_pop_int(ctx, &r);
2197 hres = stack_pop_int(ctx, &l);
2201 return stack_push_int(ctx, l|r);
2204 /* ECMA-262 3rd Edition 11.10 */
2205 static HRESULT interp_xor(exec_ctx_t *ctx)
2212 hres = stack_pop_int(ctx, &r);
2216 hres = stack_pop_int(ctx, &l);
2220 return stack_push_int(ctx, l^r);
2223 /* ECMA-262 3rd Edition 11.10 */
2224 static HRESULT bitand_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2229 hres = to_int32(ctx, lval, ei, &li);
2233 hres = to_int32(ctx, rval, ei, &ri);
2242 /* ECMA-262 3rd Edition 11.10 */
2243 HRESULT binary_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2245 binary_expression_t *expr = (binary_expression_t*)_expr;
2249 return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
2252 /* ECMA-262 3rd Edition 11.8.6 */
2253 static HRESULT instanceof_eval(script_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
2255 jsdisp_t *obj, *iter, *tmp = NULL;
2256 VARIANT_BOOL ret = VARIANT_FALSE;
2261 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2263 if(V_VT(objv) != VT_DISPATCH || !V_DISPATCH(objv))
2264 return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2266 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
2268 FIXME("non-jsdisp objects not supported\n");
2272 if(is_class(obj, JSCLASS_FUNCTION)) {
2273 hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
2275 hres = throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2277 jsdisp_release(obj);
2281 if(V_VT(&var) == VT_DISPATCH) {
2282 if(V_VT(inst) == VT_DISPATCH)
2283 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
2284 for(iter = tmp; iter; iter = iter->prototype) {
2285 hres = disp_cmp(V_DISPATCH(&var), to_disp(iter), &b);
2295 jsdisp_release(tmp);
2297 FIXME("prototype is not an object\n");
2305 V_VT(retv) = VT_BOOL;
2310 /* ECMA-262 3rd Edition 11.8.6 */
2311 HRESULT instanceof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2313 binary_expression_t *expr = (binary_expression_t*)_expr;
2317 return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
2320 /* ECMA-262 3rd Edition 11.8.7 */
2321 static HRESULT interp_in(exec_ctx_t *ctx)
2331 obj = stack_pop(ctx);
2334 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2337 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2340 hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2343 IDispatch_Release(V_DISPATCH(obj));
2347 hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2348 IDispatch_Release(V_DISPATCH(obj));
2352 else if(hres == DISP_E_UNKNOWNNAME)
2357 return stack_push_bool(ctx, ret);
2360 /* ECMA-262 3rd Edition 11.6.1 */
2361 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2366 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2370 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2376 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2377 BSTR lstr = NULL, rstr = NULL;
2379 if(V_VT(&l) == VT_BSTR)
2382 hres = to_string(ctx, &l, ei, &lstr);
2384 if(SUCCEEDED(hres)) {
2385 if(V_VT(&r) == VT_BSTR)
2388 hres = to_string(ctx, &r, ei, &rstr);
2391 if(SUCCEEDED(hres)) {
2394 len1 = SysStringLen(lstr);
2395 len2 = SysStringLen(rstr);
2397 V_VT(retv) = VT_BSTR;
2398 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2399 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2400 memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2403 if(V_VT(&l) != VT_BSTR)
2404 SysFreeString(lstr);
2405 if(V_VT(&r) != VT_BSTR)
2406 SysFreeString(rstr);
2410 hres = to_number(ctx, &l, ei, &nl);
2411 if(SUCCEEDED(hres)) {
2412 hres = to_number(ctx, &r, ei, &nr);
2414 num_set_val(retv, num_val(&nl) + num_val(&nr));
2423 /* ECMA-262 3rd Edition 11.6.1 */
2424 static HRESULT interp_add(exec_ctx_t *ctx)
2426 VARIANT *l, *r, ret;
2432 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2434 hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2440 return stack_push(ctx, &ret);
2443 /* ECMA-262 3rd Edition 11.6.2 */
2444 static HRESULT interp_sub(exec_ctx_t *ctx)
2451 hres = stack_pop_number(ctx, &r);
2455 hres = stack_pop_number(ctx, &l);
2459 return stack_push_number(ctx, num_val(&l)-num_val(&r));
2462 /* ECMA-262 3rd Edition 11.5.1 */
2463 static HRESULT interp_mul(exec_ctx_t *ctx)
2470 hres = stack_pop_number(ctx, &r);
2474 hres = stack_pop_number(ctx, &l);
2478 return stack_push_number(ctx, num_val(&l)*num_val(&r));
2481 /* ECMA-262 3rd Edition 11.5.2 */
2482 static HRESULT interp_div(exec_ctx_t *ctx)
2489 hres = stack_pop_number(ctx, &r);
2493 hres = stack_pop_number(ctx, &l);
2497 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2500 /* ECMA-262 3rd Edition 11.5.3 */
2501 static HRESULT interp_mod(exec_ctx_t *ctx)
2508 hres = stack_pop_number(ctx, &r);
2512 hres = stack_pop_number(ctx, &l);
2516 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2519 /* ECMA-262 3rd Edition 11.4.2 */
2520 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2522 unary_expression_t *expr = (unary_expression_t*)_expr;
2523 VARIANT_BOOL b = VARIANT_FALSE;
2529 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2533 switch(exprval.type) {
2534 case EXPRVAL_IDREF: {
2535 IDispatchEx *dispex;
2537 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2538 if(SUCCEEDED(hres)) {
2539 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2541 IDispatchEx_Release(dispex);
2546 FIXME("unsupported type %d\n", exprval.type);
2550 exprval_release(&exprval);
2554 return return_bool(ret, b);
2557 /* ECMA-262 3rd Edition 11.4.2 */
2558 static HRESULT interp_delete(exec_ctx_t *ctx)
2560 VARIANT *obj_var, *name_var;
2561 IDispatchEx *dispex;
2569 name_var = stack_pop(ctx);
2570 obj_var = stack_pop(ctx);
2572 hres = to_object(ctx->parser->script, obj_var, &obj);
2573 VariantClear(obj_var);
2575 VariantClear(name_var);
2579 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2580 VariantClear(name_var);
2582 IDispatch_Release(obj);
2586 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2587 if(SUCCEEDED(hres)) {
2588 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2590 IDispatchEx_Release(dispex);
2596 IDispatch_Release(obj);
2597 SysFreeString(name);
2601 return stack_push_bool(ctx, ret);
2604 /* ECMA-262 3rd Edition 11.4.2 */
2605 static HRESULT interp_void(exec_ctx_t *ctx)
2613 V_VT(&v) = VT_EMPTY;
2614 return stack_push(ctx, &v);
2617 /* ECMA-262 3rd Edition 11.4.3 */
2618 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2623 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2624 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2625 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2626 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2627 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2628 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2629 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2631 if(exprval->type == EXPRVAL_INVALID) {
2636 hres = exprval_to_value(ctx, exprval, ei, &val);
2638 if(exprval->type == EXPRVAL_IDREF) {
2645 switch(V_VT(&val)) {
2665 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2666 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2667 jsdisp_release(dispex);
2674 FIXME("unhandled vt %d\n", V_VT(&val));
2682 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2684 unary_expression_t *expr = (unary_expression_t*)_expr;
2685 const WCHAR *str = NULL;
2691 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2695 hres = typeof_exprval(ctx, &exprval, ei, &str);
2696 exprval_release(&exprval);
2700 ret->type = EXPRVAL_VARIANT;
2701 V_VT(&ret->u.var) = VT_BSTR;
2702 V_BSTR(&ret->u.var) = SysAllocString(str);
2703 if(!V_BSTR(&ret->u.var))
2704 return E_OUTOFMEMORY;
2709 /* ECMA-262 3rd Edition 11.4.7 */
2710 static HRESULT interp_minus(exec_ctx_t *ctx)
2717 hres = stack_pop_number(ctx, &n);
2721 return stack_push_number(ctx, -num_val(&n));
2724 /* ECMA-262 3rd Edition 11.4.6 */
2725 static HRESULT interp_tonum(exec_ctx_t *ctx)
2733 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2738 return stack_push(ctx, &num);
2741 /* ECMA-262 3rd Edition 11.3.1 */
2742 HRESULT post_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2744 unary_expression_t *expr = (unary_expression_t*)_expr;
2751 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2755 hres = exprval_value(ctx, &exprval, ei, &val);
2756 if(SUCCEEDED(hres)) {
2757 hres = to_number(ctx, &val, ei, &num);
2761 if(SUCCEEDED(hres)) {
2763 num_set_val(&inc, num_val(&num)+1.0);
2764 hres = put_value(ctx, &exprval, &inc, ei);
2767 exprval_release(&exprval);
2771 ret->type = EXPRVAL_VARIANT;
2776 /* ECMA-262 3rd Edition 11.3.2 */
2777 HRESULT post_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2779 unary_expression_t *expr = (unary_expression_t*)_expr;
2786 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2790 hres = exprval_value(ctx, &exprval, ei, &val);
2791 if(SUCCEEDED(hres)) {
2792 hres = to_number(ctx, &val, ei, &num);
2796 if(SUCCEEDED(hres)) {
2798 num_set_val(&dec, num_val(&num)-1.0);
2799 hres = put_value(ctx, &exprval, &dec, ei);
2802 exprval_release(&exprval);
2806 ret->type = EXPRVAL_VARIANT;
2811 /* ECMA-262 3rd Edition 11.4.4 */
2812 HRESULT pre_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2814 unary_expression_t *expr = (unary_expression_t*)_expr;
2821 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2825 hres = exprval_value(ctx, &exprval, ei, &val);
2826 if(SUCCEEDED(hres)) {
2827 hres = to_number(ctx, &val, ei, &num);
2831 if(SUCCEEDED(hres)) {
2832 num_set_val(&val, num_val(&num)+1.0);
2833 hres = put_value(ctx, &exprval, &val, ei);
2836 exprval_release(&exprval);
2840 ret->type = EXPRVAL_VARIANT;
2845 /* ECMA-262 3rd Edition 11.4.5 */
2846 HRESULT pre_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2848 unary_expression_t *expr = (unary_expression_t*)_expr;
2855 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2859 hres = exprval_value(ctx, &exprval, ei, &val);
2860 if(SUCCEEDED(hres)) {
2861 hres = to_number(ctx, &val, ei, &num);
2865 if(SUCCEEDED(hres)) {
2866 num_set_val(&val, num_val(&num)-1.0);
2867 hres = put_value(ctx, &exprval, &val, ei);
2870 exprval_release(&exprval);
2874 ret->type = EXPRVAL_VARIANT;
2879 /* ECMA-262 3rd Edition 11.9.3 */
2880 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2882 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2883 return equal2_values(lval, rval, ret);
2885 /* FIXME: NULL disps should be handled in more general way */
2886 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2889 return equal_values(ctx, &v, rval, ei, ret);
2892 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2895 return equal_values(ctx, lval, &v, ei, ret);
2898 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2899 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2904 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2908 hres = to_number(ctx, lval, ei, &v);
2912 return equal_values(ctx, &v, rval, ei, ret);
2915 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2919 hres = to_number(ctx, rval, ei, &v);
2923 return equal_values(ctx, lval, &v, ei, ret);
2926 if(V_VT(rval) == VT_BOOL) {
2930 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2931 return equal_values(ctx, lval, &v, ei, ret);
2934 if(V_VT(lval) == VT_BOOL) {
2938 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2939 return equal_values(ctx, &v, rval, ei, ret);
2943 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2947 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2951 hres = equal_values(ctx, lval, &v, ei, ret);
2958 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2962 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2966 hres = equal_values(ctx, &v, rval, ei, ret);
2977 /* ECMA-262 3rd Edition 11.9.1 */
2978 static HRESULT interp_eq(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.2 */
2999 static HRESULT interp_neq(exec_ctx_t *ctx)
3008 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
3010 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
3016 return stack_push_bool(ctx, !b);
3019 /* ECMA-262 3rd Edition 11.9.4 */
3020 static HRESULT interp_eq2(exec_ctx_t *ctx)
3031 hres = equal2_values(r, l, &b);
3037 return stack_push_bool(ctx, b);
3040 /* ECMA-262 3rd Edition 11.9.5 */
3041 static HRESULT interp_neq2(exec_ctx_t *ctx)
3052 hres = equal2_values(r, l, &b);
3058 return stack_push_bool(ctx, !b);
3061 /* ECMA-262 3rd Edition 11.8.5 */
3062 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
3064 VARIANT l, r, ln, rn;
3067 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
3071 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
3077 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
3078 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
3079 SysFreeString(V_BSTR(&l));
3080 SysFreeString(V_BSTR(&r));
3084 hres = to_number(ctx, &l, ei, &ln);
3087 hres = to_number(ctx, &r, ei, &rn);
3092 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
3093 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
3095 DOUBLE ld = num_val(&ln);
3096 DOUBLE rd = num_val(&rn);
3098 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
3104 /* ECMA-262 3rd Edition 11.8.1 */
3105 static HRESULT interp_lt(exec_ctx_t *ctx)
3114 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
3116 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
3122 return stack_push_bool(ctx, b);
3125 /* ECMA-262 3rd Edition 11.8.1 */
3126 static HRESULT interp_lteq(exec_ctx_t *ctx)
3135 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
3137 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
3143 return stack_push_bool(ctx, b);
3146 /* ECMA-262 3rd Edition 11.8.2 */
3147 static HRESULT interp_gt(exec_ctx_t *ctx)
3156 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
3158 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
3164 return stack_push_bool(ctx, b);
3167 /* ECMA-262 3rd Edition 11.8.4 */
3168 static HRESULT interp_gteq(exec_ctx_t *ctx)
3177 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
3179 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
3185 return stack_push_bool(ctx, b);
3188 /* ECMA-262 3rd Edition 11.4.8 */
3189 static HRESULT interp_bneg(exec_ctx_t *ctx)
3198 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3205 return stack_push(ctx, &r);
3208 /* ECMA-262 3rd Edition 11.4.9 */
3209 static HRESULT interp_neg(exec_ctx_t *ctx)
3218 hres = to_boolean(v, &b);
3223 return stack_push_bool(ctx, !b);
3226 /* ECMA-262 3rd Edition 11.7.1 */
3227 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3233 hres = to_int32(ctx, lval, ei, &li);
3237 hres = to_uint32(ctx, rval, ei, &ri);
3242 V_I4(retv) = li << (ri&0x1f);
3246 /* ECMA-262 3rd Edition 11.7.1 */
3247 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3249 binary_expression_t *expr = (binary_expression_t*)_expr;
3253 return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3256 /* ECMA-262 3rd Edition 11.7.2 */
3257 static HRESULT rshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3263 hres = to_int32(ctx, lval, ei, &li);
3267 hres = to_uint32(ctx, rval, ei, &ri);
3272 V_I4(retv) = li >> (ri&0x1f);
3276 /* ECMA-262 3rd Edition 11.7.2 */
3277 HRESULT right_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3279 binary_expression_t *expr = (binary_expression_t*)_expr;
3283 return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
3286 /* ECMA-262 3rd Edition 11.7.3 */
3287 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3292 hres = to_uint32(ctx, lval, ei, &li);
3296 hres = to_uint32(ctx, rval, ei, &ri);
3301 V_I4(retv) = li >> (ri&0x1f);
3305 /* ECMA-262 3rd Edition 11.7.3 */
3306 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3308 binary_expression_t *expr = (binary_expression_t*)_expr;
3312 return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3315 /* ECMA-262 3rd Edition 11.13.1 */
3316 static HRESULT interp_assign(exec_ctx_t *ctx)
3326 disp = stack_pop_objid(ctx, &id);
3329 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3331 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3332 IDispatch_Release(disp);
3338 return stack_push(ctx, v);
3341 /* ECMA-262 3rd Edition 11.13.2 */
3342 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3344 binary_expression_t *expr = (binary_expression_t*)_expr;
3348 return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3351 /* ECMA-262 3rd Edition 11.13.2 */
3352 HRESULT assign_rshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3354 binary_expression_t *expr = (binary_expression_t*)_expr;
3358 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
3361 /* ECMA-262 3rd Edition 11.13.2 */
3362 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3364 binary_expression_t *expr = (binary_expression_t*)_expr;
3368 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3371 /* ECMA-262 3rd Edition 11.13.2 */
3372 HRESULT assign_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3374 binary_expression_t *expr = (binary_expression_t*)_expr;
3378 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
3381 static HRESULT interp_jmp(exec_ctx_t *ctx)
3383 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3391 static HRESULT interp_pop(exec_ctx_t *ctx)
3399 static HRESULT interp_ret(exec_ctx_t *ctx)
3407 static HRESULT interp_tree(exec_ctx_t *ctx)
3409 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3416 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3420 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3421 exprval_release(&val);
3425 return stack_push(ctx, &v);
3428 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3430 static const op_func_t op_funcs[] = {
3431 #define X(x,a,b,c) interp_##x,
3436 static const unsigned op_move[] = {
3437 #define X(a,x,b,c) x,
3442 static HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3444 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3445 unsigned prev_ip, prev_top;
3447 HRESULT hres = S_OK;
3451 prev_top = exec_ctx->top;
3452 prev_ip = exec_ctx->ip;
3453 exec_ctx->ip = expr->instr_off;
3455 while(exec_ctx->ip != -1) {
3456 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3457 hres = op_funcs[op](exec_ctx);
3460 exec_ctx->ip += op_move[op];
3463 exec_ctx->ip = prev_ip;
3466 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3468 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3472 assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3474 ret->type = EXPRVAL_VARIANT;
3475 if(exec_ctx->top == prev_top)
3476 V_VT(&ret->u.var) = VT_EMPTY;
3478 ret->u.var = *stack_pop(exec_ctx);
3482 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3488 hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
3492 if(expr->eval == compiled_expression_eval)
3493 expr->eval = interp_expression_eval;
3495 return expr->eval(ctx, expr, flags, ei, ret);