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) {
164 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_REQUIRED, NULL);
169 hres = to_object(ctx->parser->script, v, r);
174 static inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
176 return to_int32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
179 static inline HRESULT stack_pop_uint(exec_ctx_t *ctx, DWORD *r)
181 return to_uint32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
184 static inline IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
186 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
188 *id = V_INT(stack_pop(ctx));
189 return V_DISPATCH(stack_pop(ctx));
192 static inline IDispatch *stack_topn_objid(exec_ctx_t *ctx, unsigned n, DISPID *id)
194 assert(V_VT(stack_topn(ctx, n)) == VT_INT && V_VT(stack_topn(ctx, n+1)) == VT_DISPATCH);
196 *id = V_INT(stack_topn(ctx, n));
197 return V_DISPATCH(stack_topn(ctx, n+1));
200 static void exprval_release(exprval_t *val)
203 case EXPRVAL_VARIANT:
204 if(V_VT(&val->u.var) != VT_EMPTY)
205 VariantClear(&val->u.var);
208 if(val->u.idref.disp)
209 IDispatch_Release(val->u.idref.disp);
211 case EXPRVAL_INVALID:
212 SysFreeString(val->u.identifier);
216 /* ECMA-262 3rd Edition 8.7.1 */
217 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
219 V_VT(ret) = VT_EMPTY;
222 case EXPRVAL_VARIANT:
223 return VariantCopy(ret, &val->u.var);
225 if(!val->u.idref.disp) {
226 FIXME("throw ReferenceError\n");
230 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
231 case EXPRVAL_INVALID:
232 return throw_type_error(ctx, ei, JS_E_UNDEFINED_VARIABLE, val->u.identifier);
235 ERR("type %d\n", val->type);
239 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
241 if(val->type == EXPRVAL_VARIANT) {
243 V_VT(&val->u.var) = VT_EMPTY;
247 return exprval_value(ctx, val, ei, ret);
250 static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
252 if(exprval->type != EXPRVAL_VARIANT) {
256 hres = exprval_to_value(ctx, exprval, ei, &val);
260 hres = to_boolean(&val, b);
265 return to_boolean(&exprval->u.var, b);
268 static void exprval_init(exprval_t *val)
270 val->type = EXPRVAL_VARIANT;
271 V_VT(&val->u.var) = VT_EMPTY;
274 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
276 val->type = EXPRVAL_IDREF;
277 val->u.idref.disp = disp;
278 val->u.idref.id = id;
281 IDispatch_AddRef(disp);
284 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
286 scope_chain_t *new_scope;
288 new_scope = heap_alloc(sizeof(scope_chain_t));
290 return E_OUTOFMEMORY;
295 new_scope->obj = obj;
299 new_scope->next = scope;
301 new_scope->next = NULL;
308 static void scope_pop(scope_chain_t **scope)
317 void scope_release(scope_chain_t *scope)
323 scope_release(scope->next);
325 jsdisp_release(scope->obj);
329 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
330 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
334 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
336 return E_OUTOFMEMORY;
339 ctx->is_global = is_global;
342 ctx->this_obj = this_obj;
343 else if(script_ctx->host_global)
344 ctx->this_obj = script_ctx->host_global;
346 ctx->this_obj = to_disp(script_ctx->global);
347 IDispatch_AddRef(ctx->this_obj);
349 jsdisp_addref(var_disp);
350 ctx->var_disp = var_disp;
354 ctx->scope_chain = scope;
361 void exec_release(exec_ctx_t *ctx)
367 scope_release(ctx->scope_chain);
369 jsdisp_release(ctx->var_disp);
371 IDispatch_Release(ctx->this_obj);
372 heap_free(ctx->stack);
376 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
381 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
383 TRACE("unsing IDispatch\n");
386 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
390 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
391 IDispatchEx_Release(dispex);
395 /* ECMA-262 3rd Edition 8.7.2 */
396 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
398 if(ref->type != EXPRVAL_IDREF)
399 return throw_reference_error(ctx, ei, JS_E_ILLEGAL_ASSIGN, NULL);
401 return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
404 static inline BOOL is_null(const VARIANT *v)
406 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
409 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
411 IObjectIdentity *identity;
412 IUnknown *unk1, *unk2;
420 if(!disp1 || !disp2) {
425 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
429 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
431 IUnknown_Release(unk1);
438 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
439 if(SUCCEEDED(hres)) {
440 hres = IObjectIdentity_IsEqualObject(identity, unk2);
441 IObjectIdentity_Release(identity);
448 IUnknown_Release(unk1);
449 IUnknown_Release(unk2);
453 /* ECMA-262 3rd Edition 11.9.6 */
454 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
458 if(V_VT(lval) != V_VT(rval)) {
459 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
460 *ret = num_val(lval) == num_val(rval);
461 else if(is_null(lval))
462 *ret = is_null(rval);
474 *ret = V_I4(lval) == V_I4(rval);
477 *ret = V_R8(lval) == V_R8(rval);
481 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
482 else if(!V_BSTR(rval))
483 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
485 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
488 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
490 *ret = !V_BOOL(lval) == !V_BOOL(rval);
493 FIXME("unimplemented vt %d\n", V_VT(lval));
500 static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
502 switch(literal->type) {
508 V_I4(v) = literal->u.lval;
512 V_R8(v) = literal->u.dval;
515 BSTR str = SysAllocString(literal->u.wstr);
517 return E_OUTOFMEMORY;
525 V_BOOL(v) = literal->u.bval;
531 hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
532 literal->u.regexp.flags, ®exp);
536 var_set_jsdisp(v, regexp);
543 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
549 for(item = ctx->named_items; item; item = item->next) {
550 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
551 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
552 if(SUCCEEDED(hres)) {
554 exprval_set_idref(ret, item->disp, id);
563 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, BOOL from_eval,
564 jsexcept_t *ei, VARIANT *retv)
566 script_ctx_t *script = parser->script;
567 function_declaration_t *func;
568 parser_ctx_t *prev_parser;
572 exec_ctx_t *prev_ctx;
576 for(func = source->functions; func; func = func->next) {
580 hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
581 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
585 var_set_jsdisp(&var, func_obj);
586 hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
587 jsdisp_release(func_obj);
592 for(var = source->variables; var; var = var->next) {
596 name = SysAllocString(var->identifier);
598 return E_OUTOFMEMORY;
600 if(!ctx->is_global || !lookup_global_members(parser->script, name, NULL))
601 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
607 prev_ctx = script->exec_ctx;
608 script->exec_ctx = ctx;
610 prev_parser = ctx->parser;
611 ctx->parser = parser;
613 V_VT(&val) = VT_EMPTY;
614 memset(&rt, 0, sizeof(rt));
617 for(stat = source->statement; stat; stat = stat->next) {
618 hres = stat_eval(script, stat, &rt, &tmp);
624 if(rt.type != RT_NORMAL)
628 script->exec_ctx = prev_ctx;
629 ctx->parser = prev_parser;
631 if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
632 FIXME("wrong rt %d\n", rt.type);
642 if(!retv || (!from_eval && rt.type != RT_RETURN))
649 /* ECMA-262 3rd Edition 10.1.4 */
650 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
652 scope_chain_t *scope;
657 TRACE("%s\n", debugstr_w(identifier));
659 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
660 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
661 if(SUCCEEDED(hres)) {
662 exprval_set_idref(ret, to_disp(scope->obj), id);
667 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
668 if(SUCCEEDED(hres)) {
669 exprval_set_idref(ret, to_disp(ctx->global), id);
673 for(item = ctx->named_items; item; item = item->next) {
674 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
681 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
682 SCRIPTINFO_IUNKNOWN, &unk, NULL);
684 WARN("GetItemInfo failed: %08x\n", hres);
688 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
689 IUnknown_Release(unk);
691 WARN("object does not implement IDispatch\n");
696 ret->type = EXPRVAL_VARIANT;
697 V_VT(&ret->u.var) = VT_DISPATCH;
698 V_DISPATCH(&ret->u.var) = item->disp;
699 IDispatch_AddRef(item->disp);
704 if(lookup_global_members(ctx, identifier, ret))
707 if(flags & EXPR_NEWREF) {
708 hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
712 exprval_set_idref(ret, to_disp(ctx->global), id);
716 ret->type = EXPRVAL_INVALID;
717 ret->u.identifier = SysAllocString(identifier);
718 if(!ret->u.identifier)
719 return E_OUTOFMEMORY;
724 /* ECMA-262 3rd Edition 12.1 */
725 HRESULT block_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
727 block_statement_t *stat = (block_statement_t*)_stat;
734 V_VT(&val) = VT_EMPTY;
735 for(iter = stat->stat_list; iter; iter = iter->next) {
736 hres = stat_eval(ctx, iter, rt, &tmp);
742 if(rt->type != RT_NORMAL)
755 /* ECMA-262 3rd Edition 12.2 */
756 static HRESULT variable_list_eval(script_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
758 variable_declaration_t *iter;
761 for(iter = var_list; iter; iter = iter->next) {
768 hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
772 hres = exprval_to_value(ctx, &exprval, ei, &val);
773 exprval_release(&exprval);
777 hres = jsdisp_propput_name(ctx->exec_ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
786 /* ECMA-262 3rd Edition 12.2 */
787 HRESULT var_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
789 var_statement_t *stat = (var_statement_t*)_stat;
794 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
798 V_VT(ret) = VT_EMPTY;
802 /* ECMA-262 3rd Edition 12.3 */
803 HRESULT empty_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
807 V_VT(ret) = VT_EMPTY;
811 /* ECMA-262 3rd Edition 12.4 */
812 HRESULT expression_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
814 expression_statement_t *stat = (expression_statement_t*)_stat;
821 hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
825 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
826 exprval_release(&exprval);
831 TRACE("= %s\n", debugstr_variant(ret));
835 /* ECMA-262 3rd Edition 12.5 */
836 HRESULT if_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
838 if_statement_t *stat = (if_statement_t*)_stat;
845 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
849 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
850 exprval_release(&exprval);
855 hres = stat_eval(ctx, stat->if_stat, rt, ret);
856 else if(stat->else_stat)
857 hres = stat_eval(ctx, stat->else_stat, rt, ret);
859 V_VT(ret) = VT_EMPTY;
864 /* ECMA-262 3rd Edition 12.6.2 */
865 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
867 while_statement_t *stat = (while_statement_t*)_stat;
876 V_VT(&val) = VT_EMPTY;
877 test_expr = !stat->do_while;
881 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
885 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
886 exprval_release(&exprval);
887 if(FAILED(hres) || !b)
893 hres = stat_eval(ctx, stat->statement, rt, &tmp);
900 if(rt->type == RT_CONTINUE)
901 rt->type = RT_NORMAL;
902 if(rt->type != RT_NORMAL)
911 if(rt->type == RT_BREAK)
912 rt->type = RT_NORMAL;
918 /* ECMA-262 3rd Edition 12.6.3 */
919 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
921 for_statement_t *stat = (for_statement_t*)_stat;
922 VARIANT val, tmp, retv;
929 if(stat->variable_list) {
930 hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
933 }else if(stat->begin_expr) {
934 hres = expr_eval(ctx, stat->begin_expr, 0, &rt->ei, &exprval);
938 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
939 exprval_release(&exprval);
946 V_VT(&retv) = VT_EMPTY;
950 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
954 hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
955 exprval_release(&exprval);
956 if(FAILED(hres) || !b)
960 hres = stat_eval(ctx, stat->statement, rt, &tmp);
967 if(rt->type == RT_CONTINUE)
968 rt->type = RT_NORMAL;
969 else if(rt->type != RT_NORMAL)
973 hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
977 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
978 exprval_release(&exprval);
991 if(rt->type == RT_BREAK)
992 rt->type = RT_NORMAL;
998 /* ECMA-262 3rd Edition 12.6.4 */
999 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1001 forin_statement_t *stat = (forin_statement_t*)_stat;
1002 VARIANT val, name, retv, tmp;
1003 DISPID id = DISPID_STARTENUM;
1004 BSTR str, identifier = NULL;
1005 IDispatchEx *in_obj;
1011 if(stat->variable) {
1012 hres = variable_list_eval(ctx, stat->variable, &rt->ei);
1017 hres = expr_eval(ctx, stat->in_expr, 0, &rt->ei, &exprval);
1021 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1022 exprval_release(&exprval);
1026 if(V_VT(&val) != VT_DISPATCH) {
1027 TRACE("in vt %d\n", V_VT(&val));
1029 V_VT(ret) = VT_EMPTY;
1033 hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
1034 IDispatch_Release(V_DISPATCH(&val));
1036 TRACE("Object doesn't support IDispatchEx\n");
1037 V_VT(ret) = VT_EMPTY;
1041 V_VT(&retv) = VT_EMPTY;
1044 identifier = SysAllocString(stat->variable->identifier);
1047 hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
1048 if(FAILED(hres) || hres == S_FALSE)
1051 hres = IDispatchEx_GetMemberName(in_obj, id, &str);
1055 TRACE("iter %s\n", debugstr_w(str));
1058 hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
1060 hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
1061 if(SUCCEEDED(hres)) {
1062 V_VT(&name) = VT_BSTR;
1063 V_BSTR(&name) = str;
1064 hres = put_value(ctx, &exprval, &name, &rt->ei);
1065 exprval_release(&exprval);
1071 hres = stat_eval(ctx, stat->statement, rt, &tmp);
1075 VariantClear(&retv);
1078 if(rt->type == RT_CONTINUE)
1079 rt->type = RT_NORMAL;
1080 else if(rt->type != RT_NORMAL)
1084 SysFreeString(identifier);
1085 IDispatchEx_Release(in_obj);
1087 VariantClear(&retv);
1091 if(rt->type == RT_BREAK)
1092 rt->type = RT_NORMAL;
1098 /* ECMA-262 3rd Edition 12.7 */
1099 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1101 branch_statement_t *stat = (branch_statement_t*)_stat;
1105 if(stat->identifier) {
1106 FIXME("indentifier not implemented\n");
1110 rt->type = RT_CONTINUE;
1111 V_VT(ret) = VT_EMPTY;
1115 /* ECMA-262 3rd Edition 12.8 */
1116 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1118 branch_statement_t *stat = (branch_statement_t*)_stat;
1122 if(stat->identifier) {
1123 FIXME("indentifier not implemented\n");
1127 rt->type = RT_BREAK;
1128 V_VT(ret) = VT_EMPTY;
1132 /* ECMA-262 3rd Edition 12.9 */
1133 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1135 expression_statement_t *stat = (expression_statement_t*)_stat;
1143 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1147 hres = exprval_to_value(ctx, &exprval, &rt->ei, ret);
1148 exprval_release(&exprval);
1152 V_VT(ret) = VT_EMPTY;
1155 TRACE("= %s\n", debugstr_variant(ret));
1156 rt->type = RT_RETURN;
1160 /* ECMA-262 3rd Edition 12.10 */
1161 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1163 with_statement_t *stat = (with_statement_t*)_stat;
1172 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1176 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1177 exprval_release(&exprval);
1181 hres = to_object(ctx, &val, &disp);
1186 obj = iface_to_jsdisp((IUnknown*)disp);
1187 IDispatch_Release(disp);
1189 FIXME("disp id not jsdisp\n");
1193 hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1194 jsdisp_release(obj);
1198 hres = stat_eval(ctx, stat->statement, rt, ret);
1200 scope_pop(&ctx->exec_ctx->scope_chain);
1204 /* ECMA-262 3rd Edition 12.12 */
1205 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1211 /* ECMA-262 3rd Edition 12.13 */
1212 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1214 switch_statement_t *stat = (switch_statement_t*)_stat;
1215 case_clausule_t *iter, *default_clausule = NULL;
1216 statement_t *stat_iter;
1224 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1228 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1229 exprval_release(&exprval);
1233 for(iter = stat->case_list; iter; iter = iter->next) {
1235 default_clausule = iter;
1239 hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
1243 hres = exprval_to_value(ctx, &exprval, &rt->ei, &cval);
1244 exprval_release(&exprval);
1248 hres = equal2_values(&val, &cval, &b);
1249 VariantClear(&cval);
1250 if(FAILED(hres) || b)
1259 iter = default_clausule;
1261 V_VT(&val) = VT_EMPTY;
1265 for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1266 hres = stat_eval(ctx, stat_iter, rt, &tmp);
1273 if(rt->type != RT_NORMAL)
1283 if(rt->type == RT_BREAK)
1284 rt->type = RT_NORMAL;
1290 /* ECMA-262 3rd Edition 12.13 */
1291 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1293 expression_statement_t *stat = (expression_statement_t*)_stat;
1300 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1304 hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1305 exprval_release(&exprval);
1310 return DISP_E_EXCEPTION;
1313 static HRESULT interp_throw(exec_ctx_t *ctx)
1315 const HRESULT arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1317 TRACE("%08x\n", arg);
1319 return throw_reference_error(ctx->parser->script, &ctx->ei, arg, NULL);
1322 /* ECMA-262 3rd Edition 12.14 */
1323 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1330 memset(&rt->ei, 0, sizeof(jsexcept_t));
1332 hres = create_dispex(ctx, NULL, NULL, &var_disp);
1333 if(SUCCEEDED(hres)) {
1334 hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1335 if(SUCCEEDED(hres)) {
1336 hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1337 if(SUCCEEDED(hres)) {
1338 hres = stat_eval(ctx, block->statement, rt, &val);
1339 scope_pop(&ctx->exec_ctx->scope_chain);
1343 jsdisp_release(var_disp);
1354 /* ECMA-262 3rd Edition 12.14 */
1355 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1357 try_statement_t *stat = (try_statement_t*)_stat;
1363 hres = stat_eval(ctx, stat->try_statement, rt, &val);
1365 TRACE("EXCEPTION\n");
1366 if(!stat->catch_block)
1369 hres = catch_eval(ctx, stat->catch_block, rt, &val);
1374 if(stat->finally_statement) {
1376 hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1385 static HRESULT return_bool(exprval_t *ret, DWORD b)
1387 ret->type = EXPRVAL_VARIANT;
1388 V_VT(&ret->u.var) = VT_BOOL;
1389 V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1394 /* ECMA-262 3rd Edition 13 */
1395 HRESULT function_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1397 function_expression_t *expr = (function_expression_t*)_expr;
1403 if(expr->identifier) {
1404 hres = jsdisp_propget_name(ctx->exec_ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
1410 hres = create_source_function(ctx->exec_ctx->parser, expr->parameter_list, expr->source_elements, ctx->exec_ctx->scope_chain,
1411 expr->src_str, expr->src_len, &dispex);
1415 var_set_jsdisp(&var, dispex);
1418 ret->type = EXPRVAL_VARIANT;
1423 /* ECMA-262 3rd Edition 11.2.1 */
1424 HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1426 binary_expression_t *expr = (binary_expression_t*)_expr;
1428 VARIANT member, val;
1431 IDispatch *obj = NULL;
1436 hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1440 hres = exprval_to_value(ctx, &exprval, ei, &member);
1441 exprval_release(&exprval);
1445 hres = expr_eval(ctx, expr->expression2, EXPR_NEWREF, ei, &exprval);
1446 if(SUCCEEDED(hres)) {
1447 hres = exprval_to_value(ctx, &exprval, ei, &val);
1448 exprval_release(&exprval);
1451 if(SUCCEEDED(hres)) {
1452 hres = to_object(ctx, &member, &obj);
1456 VariantClear(&member);
1457 if(SUCCEEDED(hres)) {
1458 hres = to_string(ctx, &val, ei, &str);
1460 if(SUCCEEDED(hres)) {
1461 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1465 if(SUCCEEDED(hres)) {
1466 exprval_set_idref(ret, obj, id);
1467 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1472 IDispatch_Release(obj);
1478 /* ECMA-262 3rd Edition 11.2.1 */
1479 static HRESULT interp_array(exec_ctx_t *ctx)
1489 namev = stack_pop(ctx);
1491 hres = stack_pop_object(ctx, &obj);
1493 VariantClear(namev);
1497 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1498 VariantClear(namev);
1500 IDispatch_Release(obj);
1504 hres = disp_get_id(ctx->parser->script, obj, name, 0, &id);
1505 SysFreeString(name);
1506 if(SUCCEEDED(hres)) {
1507 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1508 }else if(hres == DISP_E_UNKNOWNNAME) {
1509 V_VT(&v) = VT_EMPTY;
1512 IDispatch_Release(obj);
1516 return stack_push(ctx, &v);
1519 /* ECMA-262 3rd Edition 11.2.1 */
1520 HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1522 member_expression_t *expr = (member_expression_t*)_expr;
1523 IDispatch *obj = NULL;
1532 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1536 hres = exprval_to_value(ctx, &exprval, ei, &member);
1537 exprval_release(&exprval);
1541 hres = to_object(ctx, &member, &obj);
1542 VariantClear(&member);
1546 str = SysAllocString(expr->identifier);
1548 IDispatch_Release(obj);
1549 return E_OUTOFMEMORY;
1552 hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1554 if(SUCCEEDED(hres)) {
1555 exprval_set_idref(ret, obj, id);
1556 }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1561 IDispatch_Release(obj);
1565 /* ECMA-262 3rd Edition 11.2.1 */
1566 static HRESULT interp_member(exec_ctx_t *ctx)
1568 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1576 hres = stack_pop_object(ctx, &obj);
1580 hres = disp_get_id(ctx->parser->script, obj, arg, 0, &id);
1581 if(SUCCEEDED(hres)) {
1582 V_VT(&v) = VT_EMPTY;
1583 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1584 }else if(hres == DISP_E_UNKNOWNNAME) {
1585 V_VT(&v) = VT_EMPTY;
1588 IDispatch_Release(obj);
1592 return stack_push(ctx, &v);
1595 /* ECMA-262 3rd Edition 11.2.1 */
1596 static HRESULT interp_memberid(exec_ctx_t *ctx)
1598 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1599 VARIANT *objv, *namev;
1607 namev = stack_pop(ctx);
1608 objv = stack_pop(ctx);
1610 hres = to_object(ctx->parser->script, objv, &obj);
1612 if(SUCCEEDED(hres)) {
1613 hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1615 IDispatch_Release(obj);
1617 VariantClear(namev);
1621 hres = disp_get_id(ctx->parser->script, obj, name, arg, &id);
1622 SysFreeString(name);
1624 IDispatch_Release(obj);
1625 if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1627 id = JS_E_INVALID_PROPERTY;
1633 return stack_push_objid(ctx, obj, id);
1636 /* ECMA-262 3rd Edition 11.2.1 */
1637 static HRESULT interp_refval(exec_ctx_t *ctx)
1646 disp = stack_topn_objid(ctx, 0, &id);
1648 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1650 hres = disp_propget(ctx->parser->script, disp, id, &v, &ctx->ei, NULL/*FIXME*/);
1654 return stack_push(ctx, &v);
1657 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1662 dp->cArgs = arg_cnt;
1663 dp->rgdispidNamedArgs = NULL;
1666 assert(ctx->top >= arg_cnt);
1668 for(i=1; i*2 <= arg_cnt; i++) {
1669 tmp = ctx->stack[ctx->top-i];
1670 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1671 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1674 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1677 /* ECMA-262 3rd Edition 11.2.2 */
1678 static HRESULT interp_new(exec_ctx_t *ctx)
1680 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1687 constr = stack_topn(ctx, arg);
1689 /* NOTE: Should use to_object here */
1691 if(V_VT(constr) == VT_NULL)
1692 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1693 else if(V_VT(constr) != VT_DISPATCH)
1694 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1695 else if(!V_DISPATCH(constr))
1696 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1698 jsstack_to_dp(ctx, arg, &dp);
1699 hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1700 DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1704 stack_popn(ctx, arg+1);
1705 return stack_push(ctx, &v);
1708 /* ECMA-262 3rd Edition 11.2.3 */
1709 static HRESULT interp_call(exec_ctx_t *ctx)
1711 const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1712 const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1717 TRACE("%d %d\n", argn, do_ret);
1719 objv = stack_topn(ctx, argn);
1720 if(V_VT(objv) != VT_DISPATCH)
1721 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1723 jsstack_to_dp(ctx, argn, &dp);
1724 hres = disp_call(ctx->parser->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1725 do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1729 stack_popn(ctx, argn+1);
1730 return do_ret ? stack_push(ctx, &v) : S_OK;
1734 /* ECMA-262 3rd Edition 11.2.3 */
1735 static HRESULT interp_call_member(exec_ctx_t *ctx)
1737 const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1738 const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1745 TRACE("%d %d\n", argn, do_ret);
1747 obj = stack_topn_objid(ctx, argn, &id);
1749 return throw_type_error(ctx->parser->script, &ctx->ei, id, NULL);
1751 jsstack_to_dp(ctx, argn, &dp);
1752 hres = disp_call(ctx->parser->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1756 stack_popn(ctx, argn+2);
1757 return do_ret ? stack_push(ctx, &v) : S_OK;
1761 /* ECMA-262 3rd Edition 11.1.1 */
1762 static HRESULT interp_this(exec_ctx_t *ctx)
1768 V_VT(&v) = VT_DISPATCH;
1769 V_DISPATCH(&v) = ctx->this_obj;
1770 IDispatch_AddRef(ctx->this_obj);
1771 return stack_push(ctx, &v);
1774 /* ECMA-262 3rd Edition 10.1.4 */
1775 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1777 identifier_expression_t *expr = (identifier_expression_t*)_expr;
1783 identifier = SysAllocString(expr->identifier);
1785 return E_OUTOFMEMORY;
1787 hres = identifier_eval(ctx, identifier, flags, ei, ret);
1789 SysFreeString(identifier);
1793 /* ECMA-262 3rd Edition 10.1.4 */
1794 static HRESULT interp_ident(exec_ctx_t *ctx)
1796 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1801 TRACE("%s\n", debugstr_w(arg));
1803 hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1807 hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1808 exprval_release(&exprval);
1812 return stack_push(ctx, &v);
1815 /* ECMA-262 3rd Edition 10.1.4 */
1816 static HRESULT interp_identid(exec_ctx_t *ctx)
1818 const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1819 const unsigned flags = ctx->parser->code->instrs[ctx->ip].arg2.uint;
1823 TRACE("%s %x\n", debugstr_w(arg), flags);
1825 hres = identifier_eval(ctx->parser->script, arg, (flags&fdexNameEnsure) ? EXPR_NEWREF : 0, &ctx->ei, &exprval);
1829 if(exprval.type != EXPRVAL_IDREF) {
1830 WARN("invalid ref\n");
1831 exprval_release(&exprval);
1832 return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1835 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1838 /* ECMA-262 3rd Edition 7.8.1 */
1839 static HRESULT interp_null(exec_ctx_t *ctx)
1846 return stack_push(ctx, &v);
1849 /* ECMA-262 3rd Edition 7.8.2 */
1850 static HRESULT interp_bool(exec_ctx_t *ctx)
1852 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1854 TRACE("%s\n", arg ? "true" : "false");
1856 return stack_push_bool(ctx, arg);
1859 /* ECMA-262 3rd Edition 7.8.3 */
1860 static HRESULT interp_int(exec_ctx_t *ctx)
1862 const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1869 return stack_push(ctx, &v);
1872 /* ECMA-262 3rd Edition 7.8.3 */
1873 static HRESULT interp_double(exec_ctx_t *ctx)
1875 const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1878 TRACE("%lf\n", arg);
1882 return stack_push(ctx, &v);
1885 /* ECMA-262 3rd Edition 7.8.4 */
1886 static HRESULT interp_str(exec_ctx_t *ctx)
1888 const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1891 TRACE("%s\n", debugstr_w(str));
1894 V_BSTR(&v) = SysAllocString(str);
1896 return E_OUTOFMEMORY;
1898 return stack_push(ctx, &v);
1901 /* ECMA-262 3rd Edition 7.8 */
1902 static HRESULT interp_regexp(exec_ctx_t *ctx)
1904 const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1905 const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1910 TRACE("%s %x\n", debugstr_w(source), flags);
1912 hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, ®exp);
1916 var_set_jsdisp(&v, regexp);
1917 return stack_push(ctx, &v);
1920 /* ECMA-262 3rd Edition 11.1.4 */
1921 static HRESULT interp_carray(exec_ctx_t *ctx)
1923 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1931 hres = create_array(ctx->parser->script, arg, &array);
1938 hres = jsdisp_propput_idx(array, i, v, &ctx->ei, NULL/*FIXME*/);
1941 jsdisp_release(array);
1946 var_set_jsdisp(&r, array);
1947 return stack_push(ctx, &r);
1950 /* ECMA-262 3rd Edition 11.1.5 */
1951 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1953 property_value_expression_t *expr = (property_value_expression_t*)_expr;
1963 hres = create_object(ctx, NULL, &obj);
1967 for(iter = expr->property_list; iter; iter = iter->next) {
1968 hres = literal_to_var(ctx, iter->name, &tmp);
1972 hres = to_string(ctx, &tmp, ei, &name);
1977 hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1978 if(SUCCEEDED(hres)) {
1979 hres = exprval_to_value(ctx, &exprval, ei, &val);
1980 exprval_release(&exprval);
1981 if(SUCCEEDED(hres)) {
1982 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
1987 SysFreeString(name);
1993 jsdisp_release(obj);
1997 ret->type = EXPRVAL_VARIANT;
1998 var_set_jsdisp(&ret->u.var, obj);
2002 /* ECMA-262 3rd Edition 11.11 */
2003 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2005 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2011 hres = to_boolean(stack_top(ctx), &b);
2024 /* ECMA-262 3rd Edition 11.11 */
2025 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2027 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2033 hres = to_boolean(stack_top(ctx), &b);
2046 /* ECMA-262 3rd Edition 11.10 */
2047 static HRESULT interp_or(exec_ctx_t *ctx)
2054 hres = stack_pop_int(ctx, &r);
2058 hres = stack_pop_int(ctx, &l);
2062 return stack_push_int(ctx, l|r);
2065 /* ECMA-262 3rd Edition 11.10 */
2066 static HRESULT interp_xor(exec_ctx_t *ctx)
2073 hres = stack_pop_int(ctx, &r);
2077 hres = stack_pop_int(ctx, &l);
2081 return stack_push_int(ctx, l^r);
2084 /* ECMA-262 3rd Edition 11.10 */
2085 static HRESULT interp_and(exec_ctx_t *ctx)
2092 hres = stack_pop_int(ctx, &r);
2096 hres = stack_pop_int(ctx, &l);
2100 return stack_push_int(ctx, l&r);
2103 /* ECMA-262 3rd Edition 11.8.6 */
2104 static HRESULT interp_instanceof(exec_ctx_t *ctx)
2106 jsdisp_t *obj, *iter, *tmp = NULL;
2111 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2114 if(V_VT(v) != VT_DISPATCH || !V_DISPATCH(v)) {
2116 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
2119 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
2120 IDispatch_Release(V_DISPATCH(v));
2122 FIXME("non-jsdisp objects not supported\n");
2126 if(is_class(obj, JSCLASS_FUNCTION)) {
2127 hres = jsdisp_propget_name(obj, prototypeW, &prot, &ctx->ei, NULL/*FIXME*/);
2129 hres = throw_type_error(ctx->parser->script, &ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
2131 jsdisp_release(obj);
2137 if(V_VT(&prot) == VT_DISPATCH) {
2138 if(V_VT(v) == VT_DISPATCH)
2139 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
2140 for(iter = tmp; !ret && iter; iter = iter->prototype) {
2141 hres = disp_cmp(V_DISPATCH(&prot), to_disp(iter), &ret);
2147 jsdisp_release(tmp);
2149 FIXME("prototype is not an object\n");
2153 VariantClear(&prot);
2158 return stack_push_bool(ctx, ret);
2161 /* ECMA-262 3rd Edition 11.8.7 */
2162 static HRESULT interp_in(exec_ctx_t *ctx)
2172 obj = stack_pop(ctx);
2175 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2178 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2181 hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2184 IDispatch_Release(V_DISPATCH(obj));
2188 hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2189 IDispatch_Release(V_DISPATCH(obj));
2193 else if(hres == DISP_E_UNKNOWNNAME)
2198 return stack_push_bool(ctx, ret);
2201 /* ECMA-262 3rd Edition 11.6.1 */
2202 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2207 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2211 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2217 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2218 BSTR lstr = NULL, rstr = NULL;
2220 if(V_VT(&l) == VT_BSTR)
2223 hres = to_string(ctx, &l, ei, &lstr);
2225 if(SUCCEEDED(hres)) {
2226 if(V_VT(&r) == VT_BSTR)
2229 hres = to_string(ctx, &r, ei, &rstr);
2232 if(SUCCEEDED(hres)) {
2235 len1 = SysStringLen(lstr);
2236 len2 = SysStringLen(rstr);
2238 V_VT(retv) = VT_BSTR;
2239 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2240 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2241 memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2244 if(V_VT(&l) != VT_BSTR)
2245 SysFreeString(lstr);
2246 if(V_VT(&r) != VT_BSTR)
2247 SysFreeString(rstr);
2251 hres = to_number(ctx, &l, ei, &nl);
2252 if(SUCCEEDED(hres)) {
2253 hres = to_number(ctx, &r, ei, &nr);
2255 num_set_val(retv, num_val(&nl) + num_val(&nr));
2264 /* ECMA-262 3rd Edition 11.6.1 */
2265 static HRESULT interp_add(exec_ctx_t *ctx)
2267 VARIANT *l, *r, ret;
2273 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2275 hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2281 return stack_push(ctx, &ret);
2284 /* ECMA-262 3rd Edition 11.6.2 */
2285 static HRESULT interp_sub(exec_ctx_t *ctx)
2292 hres = stack_pop_number(ctx, &r);
2296 hres = stack_pop_number(ctx, &l);
2300 return stack_push_number(ctx, num_val(&l)-num_val(&r));
2303 /* ECMA-262 3rd Edition 11.5.1 */
2304 static HRESULT interp_mul(exec_ctx_t *ctx)
2311 hres = stack_pop_number(ctx, &r);
2315 hres = stack_pop_number(ctx, &l);
2319 return stack_push_number(ctx, num_val(&l)*num_val(&r));
2322 /* ECMA-262 3rd Edition 11.5.2 */
2323 static HRESULT interp_div(exec_ctx_t *ctx)
2330 hres = stack_pop_number(ctx, &r);
2334 hres = stack_pop_number(ctx, &l);
2338 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2341 /* ECMA-262 3rd Edition 11.5.3 */
2342 static HRESULT interp_mod(exec_ctx_t *ctx)
2349 hres = stack_pop_number(ctx, &r);
2353 hres = stack_pop_number(ctx, &l);
2357 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2360 /* ECMA-262 3rd Edition 11.4.2 */
2361 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2363 unary_expression_t *expr = (unary_expression_t*)_expr;
2364 VARIANT_BOOL b = VARIANT_FALSE;
2370 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2374 switch(exprval.type) {
2375 case EXPRVAL_IDREF: {
2376 IDispatchEx *dispex;
2378 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2379 if(SUCCEEDED(hres)) {
2380 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2382 IDispatchEx_Release(dispex);
2387 FIXME("unsupported type %d\n", exprval.type);
2391 exprval_release(&exprval);
2395 return return_bool(ret, b);
2398 /* ECMA-262 3rd Edition 11.4.2 */
2399 static HRESULT interp_delete(exec_ctx_t *ctx)
2401 VARIANT *obj_var, *name_var;
2402 IDispatchEx *dispex;
2410 name_var = stack_pop(ctx);
2411 obj_var = stack_pop(ctx);
2413 hres = to_object(ctx->parser->script, obj_var, &obj);
2414 VariantClear(obj_var);
2416 VariantClear(name_var);
2420 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2421 VariantClear(name_var);
2423 IDispatch_Release(obj);
2427 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2428 if(SUCCEEDED(hres)) {
2429 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2431 IDispatchEx_Release(dispex);
2437 IDispatch_Release(obj);
2438 SysFreeString(name);
2442 return stack_push_bool(ctx, ret);
2445 /* ECMA-262 3rd Edition 11.4.2 */
2446 static HRESULT interp_void(exec_ctx_t *ctx)
2454 V_VT(&v) = VT_EMPTY;
2455 return stack_push(ctx, &v);
2458 /* ECMA-262 3rd Edition 11.4.3 */
2459 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2464 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2465 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2466 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2467 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2468 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2469 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2470 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2472 if(exprval->type == EXPRVAL_INVALID) {
2477 hres = exprval_to_value(ctx, exprval, ei, &val);
2479 if(exprval->type == EXPRVAL_IDREF) {
2486 switch(V_VT(&val)) {
2506 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2507 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2508 jsdisp_release(dispex);
2515 FIXME("unhandled vt %d\n", V_VT(&val));
2523 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2525 unary_expression_t *expr = (unary_expression_t*)_expr;
2526 const WCHAR *str = NULL;
2532 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2536 hres = typeof_exprval(ctx, &exprval, ei, &str);
2537 exprval_release(&exprval);
2541 ret->type = EXPRVAL_VARIANT;
2542 V_VT(&ret->u.var) = VT_BSTR;
2543 V_BSTR(&ret->u.var) = SysAllocString(str);
2544 if(!V_BSTR(&ret->u.var))
2545 return E_OUTOFMEMORY;
2550 /* ECMA-262 3rd Edition 11.4.7 */
2551 static HRESULT interp_minus(exec_ctx_t *ctx)
2558 hres = stack_pop_number(ctx, &n);
2562 return stack_push_number(ctx, -num_val(&n));
2565 /* ECMA-262 3rd Edition 11.4.6 */
2566 static HRESULT interp_tonum(exec_ctx_t *ctx)
2574 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2579 return stack_push(ctx, &num);
2582 /* ECMA-262 3rd Edition 11.3.1 */
2583 static HRESULT interp_postinc(exec_ctx_t *ctx)
2585 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2593 obj = stack_pop_objid(ctx, &id);
2595 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2597 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2598 if(SUCCEEDED(hres)) {
2601 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2602 if(SUCCEEDED(hres)) {
2603 num_set_val(&inc, num_val(&n)+(double)arg);
2604 hres = disp_propput(ctx->parser->script, obj, id, &inc, &ctx->ei, NULL/*FIXME*/);
2609 IDispatch_Release(obj);
2613 return stack_push(ctx, &v);
2616 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
2617 static HRESULT interp_preinc(exec_ctx_t *ctx)
2619 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2627 obj = stack_pop_objid(ctx, &id);
2629 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2631 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2632 if(SUCCEEDED(hres)) {
2635 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2637 if(SUCCEEDED(hres)) {
2638 num_set_val(&v, num_val(&n)+(double)arg);
2639 hres = disp_propput(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2642 IDispatch_Release(obj);
2646 return stack_push(ctx, &v);
2649 /* ECMA-262 3rd Edition 11.9.3 */
2650 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2652 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2653 return equal2_values(lval, rval, ret);
2655 /* FIXME: NULL disps should be handled in more general way */
2656 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2659 return equal_values(ctx, &v, rval, ei, ret);
2662 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2665 return equal_values(ctx, lval, &v, ei, ret);
2668 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2669 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2674 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2678 hres = to_number(ctx, lval, ei, &v);
2682 return equal_values(ctx, &v, rval, ei, ret);
2685 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2689 hres = to_number(ctx, rval, ei, &v);
2693 return equal_values(ctx, lval, &v, ei, ret);
2696 if(V_VT(rval) == VT_BOOL) {
2700 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2701 return equal_values(ctx, lval, &v, ei, ret);
2704 if(V_VT(lval) == VT_BOOL) {
2708 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2709 return equal_values(ctx, &v, rval, ei, ret);
2713 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2717 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2721 hres = equal_values(ctx, lval, &v, ei, ret);
2728 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2732 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2736 hres = equal_values(ctx, &v, rval, ei, ret);
2747 /* ECMA-262 3rd Edition 11.9.1 */
2748 static HRESULT interp_eq(exec_ctx_t *ctx)
2757 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2759 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2765 return stack_push_bool(ctx, b);
2768 /* ECMA-262 3rd Edition 11.9.2 */
2769 static HRESULT interp_neq(exec_ctx_t *ctx)
2778 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2780 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2786 return stack_push_bool(ctx, !b);
2789 /* ECMA-262 3rd Edition 11.9.4 */
2790 static HRESULT interp_eq2(exec_ctx_t *ctx)
2801 hres = equal2_values(r, l, &b);
2807 return stack_push_bool(ctx, b);
2810 /* ECMA-262 3rd Edition 11.9.5 */
2811 static HRESULT interp_neq2(exec_ctx_t *ctx)
2822 hres = equal2_values(r, l, &b);
2828 return stack_push_bool(ctx, !b);
2831 /* ECMA-262 3rd Edition 11.8.5 */
2832 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2834 VARIANT l, r, ln, rn;
2837 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2841 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2847 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2848 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2849 SysFreeString(V_BSTR(&l));
2850 SysFreeString(V_BSTR(&r));
2854 hres = to_number(ctx, &l, ei, &ln);
2857 hres = to_number(ctx, &r, ei, &rn);
2862 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
2863 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
2865 DOUBLE ld = num_val(&ln);
2866 DOUBLE rd = num_val(&rn);
2868 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
2874 /* ECMA-262 3rd Edition 11.8.1 */
2875 static HRESULT interp_lt(exec_ctx_t *ctx)
2884 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2886 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
2892 return stack_push_bool(ctx, b);
2895 /* ECMA-262 3rd Edition 11.8.1 */
2896 static HRESULT interp_lteq(exec_ctx_t *ctx)
2905 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
2907 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
2913 return stack_push_bool(ctx, b);
2916 /* ECMA-262 3rd Edition 11.8.2 */
2917 static HRESULT interp_gt(exec_ctx_t *ctx)
2926 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
2928 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
2934 return stack_push_bool(ctx, b);
2937 /* ECMA-262 3rd Edition 11.8.4 */
2938 static HRESULT interp_gteq(exec_ctx_t *ctx)
2947 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
2949 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
2955 return stack_push_bool(ctx, b);
2958 /* ECMA-262 3rd Edition 11.4.8 */
2959 static HRESULT interp_bneg(exec_ctx_t *ctx)
2968 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
2975 return stack_push(ctx, &r);
2978 /* ECMA-262 3rd Edition 11.4.9 */
2979 static HRESULT interp_neg(exec_ctx_t *ctx)
2988 hres = to_boolean(v, &b);
2993 return stack_push_bool(ctx, !b);
2996 /* ECMA-262 3rd Edition 11.7.1 */
2997 static HRESULT interp_lshift(exec_ctx_t *ctx)
3003 hres = stack_pop_uint(ctx, &r);
3007 hres = stack_pop_int(ctx, &l);
3011 return stack_push_int(ctx, l << (r&0x1f));
3014 /* ECMA-262 3rd Edition 11.7.2 */
3015 static HRESULT interp_rshift(exec_ctx_t *ctx)
3021 hres = stack_pop_uint(ctx, &r);
3025 hres = stack_pop_int(ctx, &l);
3029 return stack_push_int(ctx, l >> (r&0x1f));
3032 /* ECMA-262 3rd Edition 11.7.3 */
3033 static HRESULT interp_rshift2(exec_ctx_t *ctx)
3038 hres = stack_pop_uint(ctx, &r);
3042 hres = stack_pop_uint(ctx, &l);
3046 return stack_push_int(ctx, l >> (r&0x1f));
3049 /* ECMA-262 3rd Edition 11.13.1 */
3050 static HRESULT interp_assign(exec_ctx_t *ctx)
3060 disp = stack_pop_objid(ctx, &id);
3063 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3065 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3066 IDispatch_Release(disp);
3072 return stack_push(ctx, v);
3075 static HRESULT interp_undefined(exec_ctx_t *ctx)
3081 V_VT(&v) = VT_EMPTY;
3082 return stack_push(ctx, &v);
3085 static HRESULT interp_jmp(exec_ctx_t *ctx)
3087 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3095 static HRESULT interp_pop(exec_ctx_t *ctx)
3103 static HRESULT interp_ret(exec_ctx_t *ctx)
3111 static HRESULT interp_tree(exec_ctx_t *ctx)
3113 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3120 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3124 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3125 exprval_release(&val);
3129 return stack_push(ctx, &v);
3132 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3134 static const op_func_t op_funcs[] = {
3135 #define X(x,a,b,c) interp_##x,
3140 static const unsigned op_move[] = {
3141 #define X(a,x,b,c) x,
3146 static HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3148 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3149 unsigned prev_ip, prev_top;
3151 HRESULT hres = S_OK;
3155 prev_top = exec_ctx->top;
3156 prev_ip = exec_ctx->ip;
3157 exec_ctx->ip = expr->instr_off;
3159 while(exec_ctx->ip != -1) {
3160 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3161 hres = op_funcs[op](exec_ctx);
3164 exec_ctx->ip += op_move[op];
3167 exec_ctx->ip = prev_ip;
3170 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3172 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3176 assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3178 ret->type = EXPRVAL_VARIANT;
3179 if(exec_ctx->top == prev_top)
3180 V_VT(&ret->u.var) = VT_EMPTY;
3182 ret->u.var = *stack_pop(exec_ctx);
3186 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3192 hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
3196 if(expr->eval == compiled_expression_eval)
3197 expr->eval = interp_expression_eval;
3199 return expr->eval(ctx, expr, flags, ei, ret);