include/wine/test.h: Fix tests compilation with a PSDK compiler.
[wine/multimedia.git] / dlls / jscript / engine.c
blob29425e536b3f9bc4f51a165778975e944bd95598
1 /*
2 * Copyright 2008,2011 Jacek Caban for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #include "config.h"
20 #include "wine/port.h"
22 #include <math.h>
23 #include <assert.h>
25 #include "jscript.h"
26 #include "engine.h"
28 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
32 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
33 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
34 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
35 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
36 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
37 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
38 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
40 struct _except_frame_t {
41 unsigned stack_top;
42 scope_chain_t *scope;
43 unsigned catch_off;
44 BSTR ident;
46 except_frame_t *next;
49 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
51 if(!ctx->stack_size) {
52 ctx->stack = heap_alloc(16*sizeof(VARIANT));
53 if(!ctx->stack)
54 return E_OUTOFMEMORY;
55 ctx->stack_size = 16;
56 }else if(ctx->stack_size == ctx->top) {
57 VARIANT *new_stack;
59 new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(VARIANT));
60 if(!new_stack) {
61 VariantClear(v);
62 return E_OUTOFMEMORY;
65 ctx->stack = new_stack;
66 ctx->stack_size *= 2;
69 ctx->stack[ctx->top++] = *v;
70 return S_OK;
73 static HRESULT stack_push_bool(exec_ctx_t *ctx, BOOL b)
75 VARIANT v;
77 V_VT(&v) = VT_BOOL;
78 V_BOOL(&v) = b ? VARIANT_TRUE : VARIANT_FALSE;
79 return stack_push(ctx, &v);
82 static inline HRESULT stack_push_number(exec_ctx_t *ctx, double number)
84 VARIANT v;
86 num_set_val(&v, number);
87 return stack_push(ctx, &v);
90 static inline HRESULT stack_push_int(exec_ctx_t *ctx, INT n)
92 VARIANT v;
94 V_VT(&v) = VT_I4;
95 V_I4(&v) = n;
96 return stack_push(ctx, &v);
99 static inline HRESULT stack_push_string(exec_ctx_t *ctx, const WCHAR *str)
101 VARIANT v;
103 V_VT(&v) = VT_BSTR;
104 V_BSTR(&v) = SysAllocString(str);
105 return V_BSTR(&v) ? stack_push(ctx, &v) : E_OUTOFMEMORY;
108 static HRESULT stack_push_objid(exec_ctx_t *ctx, IDispatch *disp, DISPID id)
110 VARIANT v;
111 HRESULT hres;
113 V_VT(&v) = VT_DISPATCH;
114 V_DISPATCH(&v) = disp;
115 hres = stack_push(ctx, &v);
116 if(FAILED(hres))
117 return hres;
119 V_VT(&v) = VT_INT;
120 V_INT(&v) = id;
121 return stack_push(ctx, &v);
124 static inline VARIANT *stack_top(exec_ctx_t *ctx)
126 assert(ctx->top);
127 return ctx->stack + ctx->top-1;
130 static inline VARIANT *stack_topn(exec_ctx_t *ctx, unsigned n)
132 assert(ctx->top > n);
133 return ctx->stack + ctx->top-1-n;
136 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
138 assert(ctx->top);
139 return ctx->stack + --ctx->top;
142 static void stack_popn(exec_ctx_t *ctx, unsigned n)
144 while(n--)
145 VariantClear(stack_pop(ctx));
148 static HRESULT stack_pop_number(exec_ctx_t *ctx, double *r)
150 VARIANT *v;
151 HRESULT hres;
153 v = stack_pop(ctx);
154 hres = to_number(ctx->script, v, ctx->ei, r);
155 VariantClear(v);
156 return hres;
159 static HRESULT stack_pop_object(exec_ctx_t *ctx, IDispatch **r)
161 VARIANT *v;
162 HRESULT hres;
164 v = stack_pop(ctx);
165 if(V_VT(v) == VT_DISPATCH) {
166 if(!V_DISPATCH(v))
167 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_REQUIRED, NULL);
168 *r = V_DISPATCH(v);
169 return S_OK;
172 hres = to_object(ctx->script, v, r);
173 VariantClear(v);
174 return hres;
177 static inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
179 return to_int32(ctx->script, stack_pop(ctx), ctx->ei, r);
182 static inline HRESULT stack_pop_uint(exec_ctx_t *ctx, DWORD *r)
184 return to_uint32(ctx->script, stack_pop(ctx), ctx->ei, r);
187 static inline IDispatch *stack_pop_objid(exec_ctx_t *ctx, DISPID *id)
189 assert(V_VT(stack_top(ctx)) == VT_INT && V_VT(stack_topn(ctx, 1)) == VT_DISPATCH);
191 *id = V_INT(stack_pop(ctx));
192 return V_DISPATCH(stack_pop(ctx));
195 static inline IDispatch *stack_topn_objid(exec_ctx_t *ctx, unsigned n, DISPID *id)
197 assert(V_VT(stack_topn(ctx, n)) == VT_INT && V_VT(stack_topn(ctx, n+1)) == VT_DISPATCH);
199 *id = V_INT(stack_topn(ctx, n));
200 return V_DISPATCH(stack_topn(ctx, n+1));
203 static void exprval_release(exprval_t *val)
205 switch(val->type) {
206 case EXPRVAL_VARIANT:
207 if(V_VT(&val->u.var) != VT_EMPTY)
208 VariantClear(&val->u.var);
209 return;
210 case EXPRVAL_IDREF:
211 if(val->u.idref.disp)
212 IDispatch_Release(val->u.idref.disp);
213 return;
214 case EXPRVAL_INVALID:
215 return;
219 /* ECMA-262 3rd Edition 8.7.1 */
220 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
222 V_VT(ret) = VT_EMPTY;
224 switch(val->type) {
225 case EXPRVAL_VARIANT:
226 return VariantCopy(ret, &val->u.var);
227 case EXPRVAL_IDREF:
228 if(!val->u.idref.disp) {
229 FIXME("throw ReferenceError\n");
230 return E_FAIL;
233 return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei);
234 case EXPRVAL_INVALID:
235 assert(0);
238 ERR("type %d\n", val->type);
239 return E_FAIL;
242 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
244 if(val->type == EXPRVAL_VARIANT) {
245 *ret = val->u.var;
246 V_VT(&val->u.var) = VT_EMPTY;
247 return S_OK;
250 return exprval_value(ctx, val, ei, ret);
253 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
255 val->type = EXPRVAL_IDREF;
256 val->u.idref.disp = disp;
257 val->u.idref.id = id;
259 if(disp)
260 IDispatch_AddRef(disp);
263 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
265 scope_chain_t *new_scope;
267 new_scope = heap_alloc(sizeof(scope_chain_t));
268 if(!new_scope)
269 return E_OUTOFMEMORY;
271 new_scope->ref = 1;
273 jsdisp_addref(obj);
274 new_scope->obj = obj;
276 if(scope) {
277 scope_addref(scope);
278 new_scope->next = scope;
279 }else {
280 new_scope->next = NULL;
283 *ret = new_scope;
284 return S_OK;
287 static void scope_pop(scope_chain_t **scope)
289 scope_chain_t *tmp;
291 tmp = *scope;
292 *scope = tmp->next;
293 scope_release(tmp);
296 void scope_release(scope_chain_t *scope)
298 if(--scope->ref)
299 return;
301 if(scope->next)
302 scope_release(scope->next);
304 jsdisp_release(scope->obj);
305 heap_free(scope);
308 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
309 scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
311 exec_ctx_t *ctx;
313 ctx = heap_alloc_zero(sizeof(exec_ctx_t));
314 if(!ctx)
315 return E_OUTOFMEMORY;
317 ctx->ref = 1;
318 ctx->is_global = is_global;
320 if(this_obj)
321 ctx->this_obj = this_obj;
322 else if(script_ctx->host_global)
323 ctx->this_obj = script_ctx->host_global;
324 else
325 ctx->this_obj = to_disp(script_ctx->global);
326 IDispatch_AddRef(ctx->this_obj);
328 jsdisp_addref(var_disp);
329 ctx->var_disp = var_disp;
331 script_addref(script_ctx);
332 ctx->script = script_ctx;
334 if(scope) {
335 scope_addref(scope);
336 ctx->scope_chain = scope;
339 *ret = ctx;
340 return S_OK;
343 void exec_release(exec_ctx_t *ctx)
345 if(--ctx->ref)
346 return;
348 if(ctx->scope_chain)
349 scope_release(ctx->scope_chain);
350 if(ctx->var_disp)
351 jsdisp_release(ctx->var_disp);
352 if(ctx->this_obj)
353 IDispatch_Release(ctx->this_obj);
354 if(ctx->script)
355 script_release(ctx->script);
356 heap_free(ctx->stack);
357 heap_free(ctx);
360 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
362 IDispatchEx *dispex;
363 HRESULT hres;
365 hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
366 if(FAILED(hres)) {
367 TRACE("using IDispatch\n");
369 *id = 0;
370 return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
373 *id = 0;
374 hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
375 IDispatchEx_Release(dispex);
376 return hres;
379 static inline BOOL is_null(const VARIANT *v)
381 return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
384 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
386 IObjectIdentity *identity;
387 IUnknown *unk1, *unk2;
388 HRESULT hres;
390 if(disp1 == disp2) {
391 *ret = TRUE;
392 return S_OK;
395 if(!disp1 || !disp2) {
396 *ret = FALSE;
397 return S_OK;
400 hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
401 if(FAILED(hres))
402 return hres;
404 hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
405 if(FAILED(hres)) {
406 IUnknown_Release(unk1);
407 return hres;
410 if(unk1 == unk2) {
411 *ret = TRUE;
412 }else {
413 hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
414 if(SUCCEEDED(hres)) {
415 hres = IObjectIdentity_IsEqualObject(identity, unk2);
416 IObjectIdentity_Release(identity);
417 *ret = hres == S_OK;
418 }else {
419 *ret = FALSE;
423 IUnknown_Release(unk1);
424 IUnknown_Release(unk2);
425 return S_OK;
428 /* ECMA-262 3rd Edition 11.9.6 */
429 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
431 TRACE("\n");
433 if(V_VT(lval) != V_VT(rval)) {
434 if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
435 *ret = num_val(lval) == num_val(rval);
436 else if(is_null(lval))
437 *ret = is_null(rval);
438 else
439 *ret = FALSE;
440 return S_OK;
443 switch(V_VT(lval)) {
444 case VT_EMPTY:
445 case VT_NULL:
446 *ret = VARIANT_TRUE;
447 break;
448 case VT_I4:
449 *ret = V_I4(lval) == V_I4(rval);
450 break;
451 case VT_R8:
452 *ret = V_R8(lval) == V_R8(rval);
453 break;
454 case VT_BSTR:
455 if(!V_BSTR(lval))
456 *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
457 else if(!V_BSTR(rval))
458 *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
459 else
460 *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
461 break;
462 case VT_DISPATCH:
463 return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
464 case VT_BOOL:
465 *ret = !V_BOOL(lval) == !V_BOOL(rval);
466 break;
467 default:
468 FIXME("unimplemented vt %d\n", V_VT(lval));
469 return E_NOTIMPL;
472 return S_OK;
475 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
477 named_item_t *item;
478 DISPID id;
479 HRESULT hres;
481 for(item = ctx->named_items; item; item = item->next) {
482 if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
483 hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
484 if(SUCCEEDED(hres)) {
485 if(ret)
486 exprval_set_idref(ret, item->disp, id);
487 return TRUE;
492 return FALSE;
495 /* ECMA-262 3rd Edition 10.1.4 */
496 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
498 scope_chain_t *scope;
499 named_item_t *item;
500 DISPID id = 0;
501 HRESULT hres;
503 TRACE("%s\n", debugstr_w(identifier));
505 for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
506 hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
507 if(SUCCEEDED(hres)) {
508 exprval_set_idref(ret, to_disp(scope->obj), id);
509 return S_OK;
513 hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
514 if(SUCCEEDED(hres)) {
515 exprval_set_idref(ret, to_disp(ctx->global), id);
516 return S_OK;
519 for(item = ctx->named_items; item; item = item->next) {
520 if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
521 if(!item->disp) {
522 IUnknown *unk;
524 if(!ctx->site)
525 break;
527 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
528 SCRIPTINFO_IUNKNOWN, &unk, NULL);
529 if(FAILED(hres)) {
530 WARN("GetItemInfo failed: %08x\n", hres);
531 break;
534 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
535 IUnknown_Release(unk);
536 if(FAILED(hres)) {
537 WARN("object does not implement IDispatch\n");
538 break;
542 ret->type = EXPRVAL_VARIANT;
543 V_VT(&ret->u.var) = VT_DISPATCH;
544 V_DISPATCH(&ret->u.var) = item->disp;
545 IDispatch_AddRef(item->disp);
546 return S_OK;
550 if(lookup_global_members(ctx, identifier, ret))
551 return S_OK;
553 ret->type = EXPRVAL_INVALID;
554 return S_OK;
557 /* ECMA-262 3rd Edition 12.2 */
558 static HRESULT interp_var_set(exec_ctx_t *ctx)
560 const BSTR name = ctx->code->instrs[ctx->ip].arg1.bstr;
561 VARIANT *v;
562 HRESULT hres;
564 TRACE("%s\n", debugstr_w(name));
566 v = stack_pop(ctx);
567 hres = jsdisp_propput_name(ctx->var_disp, name, v, ctx->ei);
568 VariantClear(v);
569 return hres;
572 /* ECMA-262 3rd Edition 12.6.4 */
573 static HRESULT interp_forin(exec_ctx_t *ctx)
575 const HRESULT arg = ctx->code->instrs[ctx->ip].arg1.uint;
576 IDispatch *var_obj, *obj = NULL;
577 IDispatchEx *dispex;
578 DISPID id, var_id;
579 BSTR name = NULL;
580 VARIANT *val;
581 HRESULT hres;
583 TRACE("\n");
585 val = stack_pop(ctx);
587 assert(V_VT(stack_top(ctx)) == VT_I4);
588 id = V_I4(stack_top(ctx));
590 var_obj = stack_topn_objid(ctx, 1, &var_id);
591 if(!var_obj) {
592 FIXME("invalid ref\n");
593 VariantClear(val);
594 return E_FAIL;
597 if(V_VT(stack_topn(ctx, 3)) == VT_DISPATCH)
598 obj = V_DISPATCH(stack_topn(ctx, 3));
600 if(obj) {
601 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
602 if(SUCCEEDED(hres)) {
603 hres = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, id, &id);
604 if(hres == S_OK)
605 hres = IDispatchEx_GetMemberName(dispex, id, &name);
606 IDispatchEx_Release(dispex);
607 if(FAILED(hres)) {
608 VariantClear(val);
609 return hres;
611 }else {
612 TRACE("No IDispatchEx\n");
616 if(name) {
617 VARIANT v;
619 VariantClear(val);
621 V_I4(stack_top(ctx)) = id;
623 V_VT(&v) = VT_BSTR;
624 V_BSTR(&v) = name;
625 hres = disp_propput(ctx->script, var_obj, var_id, &v, ctx->ei);
626 SysFreeString(name);
627 if(FAILED(hres))
628 return hres;
630 ctx->ip++;
631 }else {
632 stack_popn(ctx, 4);
633 ctx->ip = arg;
634 return stack_push(ctx, val);
636 return S_OK;
639 /* ECMA-262 3rd Edition 12.10 */
640 static HRESULT interp_push_scope(exec_ctx_t *ctx)
642 IDispatch *disp;
643 jsdisp_t *obj;
644 VARIANT *v;
645 HRESULT hres;
647 TRACE("\n");
649 v = stack_pop(ctx);
650 hres = to_object(ctx->script, v, &disp);
651 VariantClear(v);
652 if(FAILED(hres))
653 return hres;
655 obj = to_jsdisp(disp);
656 if(!obj) {
657 IDispatch_Release(disp);
658 FIXME("disp is not jsdisp\n");
659 return E_NOTIMPL;
662 hres = scope_push(ctx->scope_chain, obj, &ctx->scope_chain);
663 jsdisp_release(obj);
664 return hres;
667 /* ECMA-262 3rd Edition 12.10 */
668 static HRESULT interp_pop_scope(exec_ctx_t *ctx)
670 TRACE("\n");
672 scope_pop(&ctx->scope_chain);
673 return S_OK;
676 /* ECMA-262 3rd Edition 12.13 */
677 static HRESULT interp_case(exec_ctx_t *ctx)
679 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
680 VARIANT *v;
681 BOOL b;
682 HRESULT hres;
684 TRACE("\n");
686 v = stack_pop(ctx);
687 hres = equal2_values(stack_top(ctx), v, &b);
688 VariantClear(v);
689 if(FAILED(hres))
690 return hres;
692 if(b) {
693 stack_popn(ctx, 1);
694 ctx->ip = arg;
695 }else {
696 ctx->ip++;
698 return S_OK;
701 /* ECMA-262 3rd Edition 12.13 */
702 static HRESULT interp_throw(exec_ctx_t *ctx)
704 TRACE("\n");
706 ctx->ei->var = *stack_pop(ctx);
707 return DISP_E_EXCEPTION;
710 static HRESULT interp_throw_ref(exec_ctx_t *ctx)
712 const HRESULT arg = ctx->code->instrs[ctx->ip].arg1.uint;
714 TRACE("%08x\n", arg);
716 return throw_reference_error(ctx->script, ctx->ei, arg, NULL);
719 static HRESULT interp_throw_type(exec_ctx_t *ctx)
721 const HRESULT hres = ctx->code->instrs[ctx->ip].arg1.uint;
722 const WCHAR *str = ctx->code->instrs[ctx->ip].arg2.str;
724 TRACE("%08x %s\n", hres, debugstr_w(str));
726 return throw_type_error(ctx->script, ctx->ei, hres, str);
729 /* ECMA-262 3rd Edition 12.14 */
730 static HRESULT interp_push_except(exec_ctx_t *ctx)
732 const unsigned arg1 = ctx->code->instrs[ctx->ip].arg1.uint;
733 const BSTR arg2 = ctx->code->instrs[ctx->ip].arg2.bstr;
734 except_frame_t *except;
735 unsigned stack_top;
737 TRACE("\n");
739 stack_top = ctx->top;
741 if(!arg2) {
742 HRESULT hres;
744 hres = stack_push_bool(ctx, TRUE);
745 if(FAILED(hres))
746 return hres;
747 hres = stack_push_bool(ctx, TRUE);
748 if(FAILED(hres))
749 return hres;
752 except = heap_alloc(sizeof(*except));
753 if(!except)
754 return E_OUTOFMEMORY;
756 except->stack_top = stack_top;
757 except->scope = ctx->scope_chain;
758 except->catch_off = arg1;
759 except->ident = arg2;
760 except->next = ctx->except_frame;
761 ctx->except_frame = except;
762 return S_OK;
765 /* ECMA-262 3rd Edition 12.14 */
766 static HRESULT interp_pop_except(exec_ctx_t *ctx)
768 except_frame_t *except;
770 TRACE("\n");
772 except = ctx->except_frame;
773 assert(except != NULL);
775 ctx->except_frame = except->next;
776 heap_free(except);
777 return S_OK;
780 /* ECMA-262 3rd Edition 12.14 */
781 static HRESULT interp_end_finally(exec_ctx_t *ctx)
783 VARIANT *v;
785 TRACE("\n");
787 v = stack_pop(ctx);
789 assert(V_VT(stack_top(ctx)) == VT_BOOL);
790 if(!V_BOOL(stack_top(ctx))) {
791 TRACE("passing exception\n");
793 VariantClear(v);
794 stack_popn(ctx, 1);
795 ctx->ei->var = *stack_pop(ctx);
796 return DISP_E_EXCEPTION;
799 stack_popn(ctx, 2);
800 return stack_push(ctx, v);
803 /* ECMA-262 3rd Edition 13 */
804 static HRESULT interp_func(exec_ctx_t *ctx)
806 function_expression_t *expr = ctx->code->instrs[ctx->ip].arg1.func;
807 jsdisp_t *dispex;
808 VARIANT v;
809 HRESULT hres;
811 TRACE("\n");
813 hres = create_source_function(ctx->script, ctx->code, expr->parameter_list, expr->source_elements, ctx->scope_chain,
814 expr->src_str, expr->src_len, &dispex);
815 if(FAILED(hres))
816 return hres;
818 var_set_jsdisp(&v, dispex);
819 return stack_push(ctx, &v);
822 /* ECMA-262 3rd Edition 11.2.1 */
823 static HRESULT interp_array(exec_ctx_t *ctx)
825 VARIANT v, *namev;
826 IDispatch *obj;
827 DISPID id;
828 BSTR name;
829 HRESULT hres;
831 TRACE("\n");
833 namev = stack_pop(ctx);
835 hres = stack_pop_object(ctx, &obj);
836 if(FAILED(hres)) {
837 VariantClear(namev);
838 return hres;
841 hres = to_string(ctx->script, namev, ctx->ei, &name);
842 VariantClear(namev);
843 if(FAILED(hres)) {
844 IDispatch_Release(obj);
845 return hres;
848 hres = disp_get_id(ctx->script, obj, name, 0, &id);
849 SysFreeString(name);
850 if(SUCCEEDED(hres)) {
851 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
852 }else if(hres == DISP_E_UNKNOWNNAME) {
853 V_VT(&v) = VT_EMPTY;
854 hres = S_OK;
856 IDispatch_Release(obj);
857 if(FAILED(hres))
858 return hres;
860 return stack_push(ctx, &v);
863 /* ECMA-262 3rd Edition 11.2.1 */
864 static HRESULT interp_member(exec_ctx_t *ctx)
866 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
867 IDispatch *obj;
868 VARIANT v;
869 DISPID id;
870 HRESULT hres;
872 TRACE("\n");
874 hres = stack_pop_object(ctx, &obj);
875 if(FAILED(hres))
876 return hres;
878 hres = disp_get_id(ctx->script, obj, arg, 0, &id);
879 if(SUCCEEDED(hres)) {
880 V_VT(&v) = VT_EMPTY;
881 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
882 }else if(hres == DISP_E_UNKNOWNNAME) {
883 V_VT(&v) = VT_EMPTY;
884 hres = S_OK;
886 IDispatch_Release(obj);
887 if(FAILED(hres))
888 return hres;
890 return stack_push(ctx, &v);
893 /* ECMA-262 3rd Edition 11.2.1 */
894 static HRESULT interp_memberid(exec_ctx_t *ctx)
896 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.lng;
897 VARIANT *objv, *namev;
898 IDispatch *obj;
899 BSTR name;
900 DISPID id;
901 HRESULT hres;
903 TRACE("%x\n", arg);
905 namev = stack_pop(ctx);
906 objv = stack_pop(ctx);
908 hres = to_object(ctx->script, objv, &obj);
909 VariantClear(objv);
910 if(SUCCEEDED(hres)) {
911 hres = to_string(ctx->script, namev, ctx->ei, &name);
912 if(FAILED(hres))
913 IDispatch_Release(obj);
915 VariantClear(namev);
916 if(FAILED(hres))
917 return hres;
919 hres = disp_get_id(ctx->script, obj, name, arg, &id);
920 SysFreeString(name);
921 if(FAILED(hres)) {
922 IDispatch_Release(obj);
923 if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
924 obj = NULL;
925 id = JS_E_INVALID_PROPERTY;
926 }else {
927 return hres;
931 return stack_push_objid(ctx, obj, id);
934 /* ECMA-262 3rd Edition 11.2.1 */
935 static HRESULT interp_refval(exec_ctx_t *ctx)
937 IDispatch *disp;
938 VARIANT v;
939 DISPID id;
940 HRESULT hres;
942 TRACE("\n");
944 disp = stack_topn_objid(ctx, 0, &id);
945 if(!disp)
946 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
948 hres = disp_propget(ctx->script, disp, id, &v, ctx->ei);
949 if(FAILED(hres))
950 return hres;
952 return stack_push(ctx, &v);
955 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
957 VARIANT tmp;
958 unsigned i;
960 dp->cArgs = arg_cnt;
961 dp->rgdispidNamedArgs = NULL;
962 dp->cNamedArgs = 0;
964 assert(ctx->top >= arg_cnt);
966 for(i=1; i*2 <= arg_cnt; i++) {
967 tmp = ctx->stack[ctx->top-i];
968 ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
969 ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
972 dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
975 /* ECMA-262 3rd Edition 11.2.2 */
976 static HRESULT interp_new(exec_ctx_t *ctx)
978 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
979 VARIANT *constr, v;
980 DISPPARAMS dp;
981 HRESULT hres;
983 TRACE("%d\n", arg);
985 constr = stack_topn(ctx, arg);
987 /* NOTE: Should use to_object here */
989 if(V_VT(constr) == VT_NULL)
990 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
991 else if(V_VT(constr) != VT_DISPATCH)
992 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_ACTION, NULL);
993 else if(!V_DISPATCH(constr))
994 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
996 jsstack_to_dp(ctx, arg, &dp);
997 hres = disp_call(ctx->script, V_DISPATCH(constr), DISPID_VALUE,
998 DISPATCH_CONSTRUCT, &dp, &v, ctx->ei);
999 if(FAILED(hres))
1000 return hres;
1002 stack_popn(ctx, arg+1);
1003 return stack_push(ctx, &v);
1006 /* ECMA-262 3rd Edition 11.2.3 */
1007 static HRESULT interp_call(exec_ctx_t *ctx)
1009 const unsigned argn = ctx->code->instrs[ctx->ip].arg1.uint;
1010 const int do_ret = ctx->code->instrs[ctx->ip].arg2.lng;
1011 VARIANT v, *objv;
1012 DISPPARAMS dp;
1013 HRESULT hres;
1015 TRACE("%d %d\n", argn, do_ret);
1017 objv = stack_topn(ctx, argn);
1018 if(V_VT(objv) != VT_DISPATCH)
1019 return throw_type_error(ctx->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1021 jsstack_to_dp(ctx, argn, &dp);
1022 hres = disp_call(ctx->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1023 do_ret ? &v : NULL, ctx->ei);
1024 if(FAILED(hres))
1025 return hres;
1027 stack_popn(ctx, argn+1);
1028 return do_ret ? stack_push(ctx, &v) : S_OK;
1032 /* ECMA-262 3rd Edition 11.2.3 */
1033 static HRESULT interp_call_member(exec_ctx_t *ctx)
1035 const unsigned argn = ctx->code->instrs[ctx->ip].arg1.uint;
1036 const int do_ret = ctx->code->instrs[ctx->ip].arg2.lng;
1037 IDispatch *obj;
1038 DISPPARAMS dp;
1039 VARIANT v;
1040 DISPID id;
1041 HRESULT hres;
1043 TRACE("%d %d\n", argn, do_ret);
1045 obj = stack_topn_objid(ctx, argn, &id);
1046 if(!obj)
1047 return throw_type_error(ctx->script, ctx->ei, id, NULL);
1049 jsstack_to_dp(ctx, argn, &dp);
1050 hres = disp_call(ctx->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, ctx->ei);
1051 if(FAILED(hres))
1052 return hres;
1054 stack_popn(ctx, argn+2);
1055 return do_ret ? stack_push(ctx, &v) : S_OK;
1059 /* ECMA-262 3rd Edition 11.1.1 */
1060 static HRESULT interp_this(exec_ctx_t *ctx)
1062 VARIANT v;
1064 TRACE("\n");
1066 V_VT(&v) = VT_DISPATCH;
1067 V_DISPATCH(&v) = ctx->this_obj;
1068 IDispatch_AddRef(ctx->this_obj);
1069 return stack_push(ctx, &v);
1072 /* ECMA-262 3rd Edition 10.1.4 */
1073 static HRESULT interp_ident(exec_ctx_t *ctx)
1075 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1076 exprval_t exprval;
1077 VARIANT v;
1078 HRESULT hres;
1080 TRACE("%s\n", debugstr_w(arg));
1082 hres = identifier_eval(ctx->script, arg, &exprval);
1083 if(FAILED(hres))
1084 return hres;
1086 if(exprval.type == EXPRVAL_INVALID)
1087 return throw_type_error(ctx->script, ctx->ei, JS_E_UNDEFINED_VARIABLE, arg);
1089 hres = exprval_to_value(ctx->script, &exprval, ctx->ei, &v);
1090 exprval_release(&exprval);
1091 if(FAILED(hres))
1092 return hres;
1094 return stack_push(ctx, &v);
1097 /* ECMA-262 3rd Edition 10.1.4 */
1098 static HRESULT interp_identid(exec_ctx_t *ctx)
1100 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1101 const unsigned flags = ctx->code->instrs[ctx->ip].arg2.uint;
1102 exprval_t exprval;
1103 HRESULT hres;
1105 TRACE("%s %x\n", debugstr_w(arg), flags);
1107 hres = identifier_eval(ctx->script, arg, &exprval);
1108 if(FAILED(hres))
1109 return hres;
1111 if(exprval.type == EXPRVAL_INVALID && (flags & fdexNameEnsure)) {
1112 DISPID id;
1114 hres = jsdisp_get_id(ctx->script->global, arg, fdexNameEnsure, &id);
1115 if(FAILED(hres))
1116 return hres;
1118 exprval_set_idref(&exprval, to_disp(ctx->script->global), id);
1121 if(exprval.type != EXPRVAL_IDREF) {
1122 WARN("invalid ref\n");
1123 exprval_release(&exprval);
1124 return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1127 return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1130 /* ECMA-262 3rd Edition 7.8.1 */
1131 static HRESULT interp_null(exec_ctx_t *ctx)
1133 VARIANT v;
1135 TRACE("\n");
1137 V_VT(&v) = VT_NULL;
1138 return stack_push(ctx, &v);
1141 /* ECMA-262 3rd Edition 7.8.2 */
1142 static HRESULT interp_bool(exec_ctx_t *ctx)
1144 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
1146 TRACE("%s\n", arg ? "true" : "false");
1148 return stack_push_bool(ctx, arg);
1151 /* ECMA-262 3rd Edition 7.8.3 */
1152 static HRESULT interp_int(exec_ctx_t *ctx)
1154 const LONG arg = ctx->code->instrs[ctx->ip].arg1.lng;
1155 VARIANT v;
1157 TRACE("%d\n", arg);
1159 V_VT(&v) = VT_I4;
1160 V_I4(&v) = arg;
1161 return stack_push(ctx, &v);
1164 /* ECMA-262 3rd Edition 7.8.3 */
1165 static HRESULT interp_double(exec_ctx_t *ctx)
1167 const double arg = *ctx->code->instrs[ctx->ip].arg1.dbl;
1168 VARIANT v;
1170 TRACE("%lf\n", arg);
1172 V_VT(&v) = VT_R8;
1173 V_R8(&v) = arg;
1174 return stack_push(ctx, &v);
1177 /* ECMA-262 3rd Edition 7.8.4 */
1178 static HRESULT interp_str(exec_ctx_t *ctx)
1180 const WCHAR *str = ctx->code->instrs[ctx->ip].arg1.str;
1181 VARIANT v;
1183 TRACE("%s\n", debugstr_w(str));
1185 V_VT(&v) = VT_BSTR;
1186 V_BSTR(&v) = SysAllocString(str);
1187 if(!V_BSTR(&v))
1188 return E_OUTOFMEMORY;
1190 return stack_push(ctx, &v);
1193 /* ECMA-262 3rd Edition 7.8 */
1194 static HRESULT interp_regexp(exec_ctx_t *ctx)
1196 const WCHAR *source = ctx->code->instrs[ctx->ip].arg1.str;
1197 const LONG flags = ctx->code->instrs[ctx->ip].arg2.lng;
1198 jsdisp_t *regexp;
1199 VARIANT v;
1200 HRESULT hres;
1202 TRACE("%s %x\n", debugstr_w(source), flags);
1204 hres = create_regexp(ctx->script, source, strlenW(source), flags, &regexp);
1205 if(FAILED(hres))
1206 return hres;
1208 var_set_jsdisp(&v, regexp);
1209 return stack_push(ctx, &v);
1212 /* ECMA-262 3rd Edition 11.1.4 */
1213 static HRESULT interp_carray(exec_ctx_t *ctx)
1215 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1216 jsdisp_t *array;
1217 VARIANT *v, r;
1218 unsigned i;
1219 HRESULT hres;
1221 TRACE("%u\n", arg);
1223 hres = create_array(ctx->script, arg, &array);
1224 if(FAILED(hres))
1225 return hres;
1227 i = arg;
1228 while(i--) {
1229 v = stack_pop(ctx);
1230 hres = jsdisp_propput_idx(array, i, v, ctx->ei);
1231 VariantClear(v);
1232 if(FAILED(hres)) {
1233 jsdisp_release(array);
1234 return hres;
1238 var_set_jsdisp(&r, array);
1239 return stack_push(ctx, &r);
1242 /* ECMA-262 3rd Edition 11.1.5 */
1243 static HRESULT interp_new_obj(exec_ctx_t *ctx)
1245 jsdisp_t *obj;
1246 VARIANT v;
1247 HRESULT hres;
1249 TRACE("\n");
1251 hres = create_object(ctx->script, NULL, &obj);
1252 if(FAILED(hres))
1253 return hres;
1255 var_set_jsdisp(&v, obj);
1256 return stack_push(ctx, &v);
1259 /* ECMA-262 3rd Edition 11.1.5 */
1260 static HRESULT interp_obj_prop(exec_ctx_t *ctx)
1262 const BSTR name = ctx->code->instrs[ctx->ip].arg1.bstr;
1263 jsdisp_t *obj;
1264 VARIANT *v;
1265 HRESULT hres;
1267 TRACE("%s\n", debugstr_w(name));
1269 v = stack_pop(ctx);
1271 assert(V_VT(stack_top(ctx)) == VT_DISPATCH);
1272 obj = as_jsdisp(V_DISPATCH(stack_top(ctx)));
1274 hres = jsdisp_propput_name(obj, name, v, ctx->ei);
1275 VariantClear(v);
1276 return hres;
1279 /* ECMA-262 3rd Edition 11.11 */
1280 static HRESULT interp_cnd_nz(exec_ctx_t *ctx)
1282 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1283 VARIANT_BOOL b;
1284 HRESULT hres;
1286 TRACE("\n");
1288 hres = to_boolean(stack_top(ctx), &b);
1289 if(FAILED(hres))
1290 return hres;
1292 if(b) {
1293 ctx->ip = arg;
1294 }else {
1295 stack_popn(ctx, 1);
1296 ctx->ip++;
1298 return S_OK;
1301 /* ECMA-262 3rd Edition 11.11 */
1302 static HRESULT interp_cnd_z(exec_ctx_t *ctx)
1304 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
1305 VARIANT_BOOL b;
1306 HRESULT hres;
1308 TRACE("\n");
1310 hres = to_boolean(stack_top(ctx), &b);
1311 if(FAILED(hres))
1312 return hres;
1314 if(b) {
1315 stack_popn(ctx, 1);
1316 ctx->ip++;
1317 }else {
1318 ctx->ip = arg;
1320 return S_OK;
1323 /* ECMA-262 3rd Edition 11.10 */
1324 static HRESULT interp_or(exec_ctx_t *ctx)
1326 INT l, r;
1327 HRESULT hres;
1329 TRACE("\n");
1331 hres = stack_pop_int(ctx, &r);
1332 if(FAILED(hres))
1333 return hres;
1335 hres = stack_pop_int(ctx, &l);
1336 if(FAILED(hres))
1337 return hres;
1339 return stack_push_int(ctx, l|r);
1342 /* ECMA-262 3rd Edition 11.10 */
1343 static HRESULT interp_xor(exec_ctx_t *ctx)
1345 INT l, r;
1346 HRESULT hres;
1348 TRACE("\n");
1350 hres = stack_pop_int(ctx, &r);
1351 if(FAILED(hres))
1352 return hres;
1354 hres = stack_pop_int(ctx, &l);
1355 if(FAILED(hres))
1356 return hres;
1358 return stack_push_int(ctx, l^r);
1361 /* ECMA-262 3rd Edition 11.10 */
1362 static HRESULT interp_and(exec_ctx_t *ctx)
1364 INT l, r;
1365 HRESULT hres;
1367 TRACE("\n");
1369 hres = stack_pop_int(ctx, &r);
1370 if(FAILED(hres))
1371 return hres;
1373 hres = stack_pop_int(ctx, &l);
1374 if(FAILED(hres))
1375 return hres;
1377 return stack_push_int(ctx, l&r);
1380 /* ECMA-262 3rd Edition 11.8.6 */
1381 static HRESULT interp_instanceof(exec_ctx_t *ctx)
1383 jsdisp_t *obj, *iter, *tmp = NULL;
1384 VARIANT prot, *v;
1385 BOOL ret = FALSE;
1386 HRESULT hres;
1388 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
1390 v = stack_pop(ctx);
1391 if(V_VT(v) != VT_DISPATCH || !V_DISPATCH(v)) {
1392 VariantClear(v);
1393 return throw_type_error(ctx->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1396 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1397 IDispatch_Release(V_DISPATCH(v));
1398 if(!obj) {
1399 FIXME("non-jsdisp objects not supported\n");
1400 return E_FAIL;
1403 if(is_class(obj, JSCLASS_FUNCTION)) {
1404 hres = jsdisp_propget_name(obj, prototypeW, &prot, ctx->ei);
1405 }else {
1406 hres = throw_type_error(ctx->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1408 jsdisp_release(obj);
1409 if(FAILED(hres))
1410 return hres;
1412 v = stack_pop(ctx);
1414 if(V_VT(&prot) == VT_DISPATCH) {
1415 if(V_VT(v) == VT_DISPATCH)
1416 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1417 for(iter = tmp; !ret && iter; iter = iter->prototype) {
1418 hres = disp_cmp(V_DISPATCH(&prot), to_disp(iter), &ret);
1419 if(FAILED(hres))
1420 break;
1423 if(tmp)
1424 jsdisp_release(tmp);
1425 }else {
1426 FIXME("prototype is not an object\n");
1427 hres = E_FAIL;
1430 VariantClear(&prot);
1431 VariantClear(v);
1432 if(FAILED(hres))
1433 return hres;
1435 return stack_push_bool(ctx, ret);
1438 /* ECMA-262 3rd Edition 11.8.7 */
1439 static HRESULT interp_in(exec_ctx_t *ctx)
1441 VARIANT *obj, *v;
1442 DISPID id = 0;
1443 BOOL ret;
1444 BSTR str;
1445 HRESULT hres;
1447 TRACE("\n");
1449 obj = stack_pop(ctx);
1450 v = stack_pop(ctx);
1452 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
1453 VariantClear(obj);
1454 VariantClear(v);
1455 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1458 hres = to_string(ctx->script, v, ctx->ei, &str);
1459 VariantClear(v);
1460 if(FAILED(hres)) {
1461 IDispatch_Release(V_DISPATCH(obj));
1462 return hres;
1465 hres = disp_get_id(ctx->script, V_DISPATCH(obj), str, 0, &id);
1466 IDispatch_Release(V_DISPATCH(obj));
1467 SysFreeString(str);
1468 if(SUCCEEDED(hres))
1469 ret = TRUE;
1470 else if(hres == DISP_E_UNKNOWNNAME)
1471 ret = FALSE;
1472 else
1473 return hres;
1475 return stack_push_bool(ctx, ret);
1478 /* ECMA-262 3rd Edition 11.6.1 */
1479 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1481 VARIANT r, l;
1482 HRESULT hres;
1484 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
1485 if(FAILED(hres))
1486 return hres;
1488 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
1489 if(FAILED(hres)) {
1490 VariantClear(&l);
1491 return hres;
1494 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1495 BSTR lstr = NULL, rstr = NULL;
1497 if(V_VT(&l) == VT_BSTR)
1498 lstr = V_BSTR(&l);
1499 else
1500 hres = to_string(ctx, &l, ei, &lstr);
1502 if(SUCCEEDED(hres)) {
1503 if(V_VT(&r) == VT_BSTR)
1504 rstr = V_BSTR(&r);
1505 else
1506 hres = to_string(ctx, &r, ei, &rstr);
1509 if(SUCCEEDED(hres)) {
1510 int len1, len2;
1512 len1 = SysStringLen(lstr);
1513 len2 = SysStringLen(rstr);
1515 V_VT(retv) = VT_BSTR;
1516 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1517 if(len1)
1518 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1519 if(len2)
1520 memcpy(V_BSTR(retv)+len1, rstr, len2*sizeof(WCHAR));
1521 V_BSTR(retv)[len1+len2] = 0;
1524 if(V_VT(&l) != VT_BSTR)
1525 SysFreeString(lstr);
1526 if(V_VT(&r) != VT_BSTR)
1527 SysFreeString(rstr);
1528 }else {
1529 double nl, nr;
1531 hres = to_number(ctx, &l, ei, &nl);
1532 if(SUCCEEDED(hres)) {
1533 hres = to_number(ctx, &r, ei, &nr);
1534 if(SUCCEEDED(hres))
1535 num_set_val(retv, nl + nr);
1539 VariantClear(&r);
1540 VariantClear(&l);
1541 return hres;
1544 /* ECMA-262 3rd Edition 11.6.1 */
1545 static HRESULT interp_add(exec_ctx_t *ctx)
1547 VARIANT *l, *r, ret;
1548 HRESULT hres;
1550 r = stack_pop(ctx);
1551 l = stack_pop(ctx);
1553 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
1555 hres = add_eval(ctx->script, l, r, ctx->ei, &ret);
1556 VariantClear(l);
1557 VariantClear(r);
1558 if(FAILED(hres))
1559 return hres;
1561 return stack_push(ctx, &ret);
1564 /* ECMA-262 3rd Edition 11.6.2 */
1565 static HRESULT interp_sub(exec_ctx_t *ctx)
1567 double l, r;
1568 HRESULT hres;
1570 TRACE("\n");
1572 hres = stack_pop_number(ctx, &r);
1573 if(FAILED(hres))
1574 return hres;
1576 hres = stack_pop_number(ctx, &l);
1577 if(FAILED(hres))
1578 return hres;
1580 return stack_push_number(ctx, l-r);
1583 /* ECMA-262 3rd Edition 11.5.1 */
1584 static HRESULT interp_mul(exec_ctx_t *ctx)
1586 double l, r;
1587 HRESULT hres;
1589 TRACE("\n");
1591 hres = stack_pop_number(ctx, &r);
1592 if(FAILED(hres))
1593 return hres;
1595 hres = stack_pop_number(ctx, &l);
1596 if(FAILED(hres))
1597 return hres;
1599 return stack_push_number(ctx, l*r);
1602 /* ECMA-262 3rd Edition 11.5.2 */
1603 static HRESULT interp_div(exec_ctx_t *ctx)
1605 double l, r;
1606 HRESULT hres;
1608 TRACE("\n");
1610 hres = stack_pop_number(ctx, &r);
1611 if(FAILED(hres))
1612 return hres;
1614 hres = stack_pop_number(ctx, &l);
1615 if(FAILED(hres))
1616 return hres;
1618 return stack_push_number(ctx, l/r);
1621 /* ECMA-262 3rd Edition 11.5.3 */
1622 static HRESULT interp_mod(exec_ctx_t *ctx)
1624 double l, r;
1625 HRESULT hres;
1627 TRACE("\n");
1629 hres = stack_pop_number(ctx, &r);
1630 if(FAILED(hres))
1631 return hres;
1633 hres = stack_pop_number(ctx, &l);
1634 if(FAILED(hres))
1635 return hres;
1637 return stack_push_number(ctx, fmod(l, r));
1640 /* ECMA-262 3rd Edition 11.4.2 */
1641 static HRESULT interp_delete(exec_ctx_t *ctx)
1643 VARIANT *obj_var, *name_var;
1644 IDispatchEx *dispex;
1645 IDispatch *obj;
1646 BSTR name;
1647 BOOL ret;
1648 HRESULT hres;
1650 TRACE("\n");
1652 name_var = stack_pop(ctx);
1653 obj_var = stack_pop(ctx);
1655 hres = to_object(ctx->script, obj_var, &obj);
1656 VariantClear(obj_var);
1657 if(FAILED(hres)) {
1658 VariantClear(name_var);
1659 return hres;
1662 hres = to_string(ctx->script, name_var, ctx->ei, &name);
1663 VariantClear(name_var);
1664 if(FAILED(hres)) {
1665 IDispatch_Release(obj);
1666 return hres;
1669 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
1670 if(SUCCEEDED(hres)) {
1671 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->script, fdexNameCaseSensitive));
1672 ret = TRUE;
1673 IDispatchEx_Release(dispex);
1674 }else {
1675 hres = S_OK;
1676 ret = FALSE;
1679 IDispatch_Release(obj);
1680 SysFreeString(name);
1681 if(FAILED(hres))
1682 return hres;
1684 return stack_push_bool(ctx, ret);
1687 /* ECMA-262 3rd Edition 11.4.2 */
1688 static HRESULT interp_delete_ident(exec_ctx_t *ctx)
1690 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1691 IDispatchEx *dispex;
1692 exprval_t exprval;
1693 BOOL ret = FALSE;
1694 HRESULT hres;
1696 TRACE("%s\n", debugstr_w(arg));
1698 hres = identifier_eval(ctx->script, arg, &exprval);
1699 if(FAILED(hres))
1700 return hres;
1702 if(exprval.type != EXPRVAL_IDREF) {
1703 FIXME("Unsupported exprval\n");
1704 exprval_release(&exprval);
1705 return E_NOTIMPL;
1708 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
1709 IDispatch_Release(exprval.u.idref.disp);
1710 if(SUCCEEDED(hres)) {
1711 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
1712 IDispatchEx_Release(dispex);
1713 if(FAILED(hres))
1714 return hres;
1716 ret = TRUE;
1719 return stack_push_bool(ctx, ret);
1722 /* ECMA-262 3rd Edition 11.4.2 */
1723 static HRESULT interp_void(exec_ctx_t *ctx)
1725 VARIANT v;
1727 TRACE("\n");
1729 stack_popn(ctx, 1);
1731 V_VT(&v) = VT_EMPTY;
1732 return stack_push(ctx, &v);
1735 /* ECMA-262 3rd Edition 11.4.3 */
1736 static HRESULT typeof_string(VARIANT *v, const WCHAR **ret)
1738 switch(V_VT(v)) {
1739 case VT_EMPTY:
1740 *ret = undefinedW;
1741 break;
1742 case VT_NULL:
1743 *ret = objectW;
1744 break;
1745 case VT_BOOL:
1746 *ret = booleanW;
1747 break;
1748 case VT_I4:
1749 case VT_R8:
1750 *ret = numberW;
1751 break;
1752 case VT_BSTR:
1753 *ret = stringW;
1754 break;
1755 case VT_DISPATCH: {
1756 jsdisp_t *dispex;
1758 if(V_DISPATCH(v) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(v)))) {
1759 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
1760 jsdisp_release(dispex);
1761 }else {
1762 *ret = objectW;
1764 break;
1766 default:
1767 FIXME("unhandled vt %d\n", V_VT(v));
1768 return E_NOTIMPL;
1771 return S_OK;
1774 /* ECMA-262 3rd Edition 11.4.3 */
1775 static HRESULT interp_typeofid(exec_ctx_t *ctx)
1777 const WCHAR *ret;
1778 IDispatch *obj;
1779 VARIANT v;
1780 DISPID id;
1781 HRESULT hres;
1783 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
1785 TRACE("\n");
1787 obj = stack_pop_objid(ctx, &id);
1788 if(!obj)
1789 return stack_push_string(ctx, undefinedW);
1791 V_VT(&v) = VT_EMPTY;
1792 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1793 IDispatch_Release(obj);
1794 if(FAILED(hres))
1795 return stack_push_string(ctx, unknownW);
1797 hres = typeof_string(&v, &ret);
1798 VariantClear(&v);
1799 if(FAILED(hres))
1800 return hres;
1802 return stack_push_string(ctx, ret);
1805 /* ECMA-262 3rd Edition 11.4.3 */
1806 static HRESULT interp_typeofident(exec_ctx_t *ctx)
1808 const BSTR arg = ctx->code->instrs[ctx->ip].arg1.bstr;
1809 exprval_t exprval;
1810 const WCHAR *ret;
1811 VARIANT v;
1812 HRESULT hres;
1814 TRACE("%s\n", debugstr_w(arg));
1816 hres = identifier_eval(ctx->script, arg, &exprval);
1817 if(FAILED(hres))
1818 return hres;
1820 if(exprval.type == EXPRVAL_INVALID) {
1821 hres = stack_push_string(ctx, undefinedW);
1822 exprval_release(&exprval);
1823 return hres;
1826 hres = exprval_to_value(ctx->script, &exprval, ctx->ei, &v);
1827 exprval_release(&exprval);
1828 if(FAILED(hres))
1829 return hres;
1831 hres = typeof_string(&v, &ret);
1832 VariantClear(&v);
1833 if(FAILED(hres))
1834 return hres;
1836 return stack_push_string(ctx, ret);
1839 /* ECMA-262 3rd Edition 11.4.3 */
1840 static HRESULT interp_typeof(exec_ctx_t *ctx)
1842 const WCHAR *ret;
1843 VARIANT *v;
1844 HRESULT hres;
1846 TRACE("\n");
1848 v = stack_pop(ctx);
1849 hres = typeof_string(v, &ret);
1850 VariantClear(v);
1851 if(FAILED(hres))
1852 return hres;
1854 return stack_push_string(ctx, ret);
1857 /* ECMA-262 3rd Edition 11.4.7 */
1858 static HRESULT interp_minus(exec_ctx_t *ctx)
1860 double n;
1861 HRESULT hres;
1863 TRACE("\n");
1865 hres = stack_pop_number(ctx, &n);
1866 if(FAILED(hres))
1867 return hres;
1869 return stack_push_number(ctx, -n);
1872 /* ECMA-262 3rd Edition 11.4.6 */
1873 static HRESULT interp_tonum(exec_ctx_t *ctx)
1875 VARIANT *v;
1876 double n;
1877 HRESULT hres;
1879 TRACE("\n");
1881 v = stack_pop(ctx);
1882 hres = to_number(ctx->script, v, ctx->ei, &n);
1883 VariantClear(v);
1884 if(FAILED(hres))
1885 return hres;
1887 return stack_push_number(ctx, n);
1890 /* ECMA-262 3rd Edition 11.3.1 */
1891 static HRESULT interp_postinc(exec_ctx_t *ctx)
1893 const int arg = ctx->code->instrs[ctx->ip].arg1.lng;
1894 IDispatch *obj;
1895 DISPID id;
1896 VARIANT v;
1897 HRESULT hres;
1899 TRACE("%d\n", arg);
1901 obj = stack_pop_objid(ctx, &id);
1902 if(!obj)
1903 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1905 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1906 if(SUCCEEDED(hres)) {
1907 VARIANT inc;
1908 double n;
1910 hres = to_number(ctx->script, &v, ctx->ei, &n);
1911 if(SUCCEEDED(hres)) {
1912 num_set_val(&inc, n+(double)arg);
1913 hres = disp_propput(ctx->script, obj, id, &inc, ctx->ei);
1915 if(FAILED(hres))
1916 VariantClear(&v);
1918 IDispatch_Release(obj);
1919 if(FAILED(hres))
1920 return hres;
1922 return stack_push(ctx, &v);
1925 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
1926 static HRESULT interp_preinc(exec_ctx_t *ctx)
1928 const int arg = ctx->code->instrs[ctx->ip].arg1.lng;
1929 IDispatch *obj;
1930 DISPID id;
1931 VARIANT v;
1932 HRESULT hres;
1934 TRACE("%d\n", arg);
1936 obj = stack_pop_objid(ctx, &id);
1937 if(!obj)
1938 return throw_type_error(ctx->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1940 hres = disp_propget(ctx->script, obj, id, &v, ctx->ei);
1941 if(SUCCEEDED(hres)) {
1942 double n;
1944 hres = to_number(ctx->script, &v, ctx->ei, &n);
1945 VariantClear(&v);
1946 if(SUCCEEDED(hres)) {
1947 num_set_val(&v, n+(double)arg);
1948 hres = disp_propput(ctx->script, obj, id, &v, ctx->ei);
1951 IDispatch_Release(obj);
1952 if(FAILED(hres))
1953 return hres;
1955 return stack_push(ctx, &v);
1958 /* ECMA-262 3rd Edition 11.9.3 */
1959 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
1961 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
1962 return equal2_values(lval, rval, ret);
1964 /* FIXME: NULL disps should be handled in more general way */
1965 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
1966 VARIANT v;
1967 V_VT(&v) = VT_NULL;
1968 return equal_values(ctx, &v, rval, ei, ret);
1971 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
1972 VARIANT v;
1973 V_VT(&v) = VT_NULL;
1974 return equal_values(ctx, lval, &v, ei, ret);
1977 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
1978 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
1979 *ret = TRUE;
1980 return S_OK;
1983 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
1984 VARIANT v;
1985 double n;
1986 HRESULT hres;
1988 hres = to_number(ctx, lval, ei, &n);
1989 if(FAILED(hres))
1990 return hres;
1992 /* FIXME: optimize */
1993 num_set_val(&v, n);
1995 return equal_values(ctx, &v, rval, ei, ret);
1998 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
1999 VARIANT v;
2000 double n;
2001 HRESULT hres;
2003 hres = to_number(ctx, rval, ei, &n);
2004 if(FAILED(hres))
2005 return hres;
2007 /* FIXME: optimize */
2008 num_set_val(&v, n);
2010 return equal_values(ctx, lval, &v, ei, ret);
2013 if(V_VT(rval) == VT_BOOL) {
2014 VARIANT v;
2016 V_VT(&v) = VT_I4;
2017 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2018 return equal_values(ctx, lval, &v, ei, ret);
2021 if(V_VT(lval) == VT_BOOL) {
2022 VARIANT v;
2024 V_VT(&v) = VT_I4;
2025 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2026 return equal_values(ctx, &v, rval, ei, ret);
2030 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2031 VARIANT v;
2032 HRESULT hres;
2034 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2035 if(FAILED(hres))
2036 return hres;
2038 hres = equal_values(ctx, lval, &v, ei, ret);
2040 VariantClear(&v);
2041 return hres;
2045 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2046 VARIANT v;
2047 HRESULT hres;
2049 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2050 if(FAILED(hres))
2051 return hres;
2053 hres = equal_values(ctx, &v, rval, ei, ret);
2055 VariantClear(&v);
2056 return hres;
2060 *ret = FALSE;
2061 return S_OK;
2064 /* ECMA-262 3rd Edition 11.9.1 */
2065 static HRESULT interp_eq(exec_ctx_t *ctx)
2067 VARIANT *l, *r;
2068 BOOL b;
2069 HRESULT hres;
2071 r = stack_pop(ctx);
2072 l = stack_pop(ctx);
2074 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2076 hres = equal_values(ctx->script, l, r, ctx->ei, &b);
2077 VariantClear(l);
2078 VariantClear(r);
2079 if(FAILED(hres))
2080 return hres;
2082 return stack_push_bool(ctx, b);
2085 /* ECMA-262 3rd Edition 11.9.2 */
2086 static HRESULT interp_neq(exec_ctx_t *ctx)
2088 VARIANT *l, *r;
2089 BOOL b;
2090 HRESULT hres;
2092 r = stack_pop(ctx);
2093 l = stack_pop(ctx);
2095 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2097 hres = equal_values(ctx->script, l, r, ctx->ei, &b);
2098 VariantClear(l);
2099 VariantClear(r);
2100 if(FAILED(hres))
2101 return hres;
2103 return stack_push_bool(ctx, !b);
2106 /* ECMA-262 3rd Edition 11.9.4 */
2107 static HRESULT interp_eq2(exec_ctx_t *ctx)
2109 VARIANT *l, *r;
2110 BOOL b;
2111 HRESULT hres;
2113 TRACE("\n");
2115 r = stack_pop(ctx);
2116 l = stack_pop(ctx);
2118 hres = equal2_values(r, l, &b);
2119 VariantClear(l);
2120 VariantClear(r);
2121 if(FAILED(hres))
2122 return hres;
2124 return stack_push_bool(ctx, b);
2127 /* ECMA-262 3rd Edition 11.9.5 */
2128 static HRESULT interp_neq2(exec_ctx_t *ctx)
2130 VARIANT *l, *r;
2131 BOOL b;
2132 HRESULT hres;
2134 TRACE("\n");
2136 r = stack_pop(ctx);
2137 l = stack_pop(ctx);
2139 hres = equal2_values(r, l, &b);
2140 VariantClear(l);
2141 VariantClear(r);
2142 if(FAILED(hres))
2143 return hres;
2145 return stack_push_bool(ctx, !b);
2148 /* ECMA-262 3rd Edition 11.8.5 */
2149 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2151 double ln, rn;
2152 VARIANT l, r;
2153 HRESULT hres;
2155 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2156 if(FAILED(hres))
2157 return hres;
2159 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2160 if(FAILED(hres)) {
2161 VariantClear(&l);
2162 return hres;
2165 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2166 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2167 SysFreeString(V_BSTR(&l));
2168 SysFreeString(V_BSTR(&r));
2169 return S_OK;
2172 hres = to_number(ctx, &l, ei, &ln);
2173 VariantClear(&l);
2174 if(SUCCEEDED(hres))
2175 hres = to_number(ctx, &r, ei, &rn);
2176 VariantClear(&r);
2177 if(FAILED(hres))
2178 return hres;
2180 *ret = !isnan(ln) && !isnan(rn) && ((ln < rn) ^ greater);
2181 return S_OK;
2184 /* ECMA-262 3rd Edition 11.8.1 */
2185 static HRESULT interp_lt(exec_ctx_t *ctx)
2187 VARIANT *l, *r;
2188 BOOL b;
2189 HRESULT hres;
2191 r = stack_pop(ctx);
2192 l = stack_pop(ctx);
2194 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2196 hres = less_eval(ctx->script, l, r, FALSE, ctx->ei, &b);
2197 VariantClear(l);
2198 VariantClear(r);
2199 if(FAILED(hres))
2200 return hres;
2202 return stack_push_bool(ctx, b);
2205 /* ECMA-262 3rd Edition 11.8.1 */
2206 static HRESULT interp_lteq(exec_ctx_t *ctx)
2208 VARIANT *l, *r;
2209 BOOL b;
2210 HRESULT hres;
2212 r = stack_pop(ctx);
2213 l = stack_pop(ctx);
2215 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
2217 hres = less_eval(ctx->script, r, l, TRUE, ctx->ei, &b);
2218 VariantClear(l);
2219 VariantClear(r);
2220 if(FAILED(hres))
2221 return hres;
2223 return stack_push_bool(ctx, b);
2226 /* ECMA-262 3rd Edition 11.8.2 */
2227 static HRESULT interp_gt(exec_ctx_t *ctx)
2229 VARIANT *l, *r;
2230 BOOL b;
2231 HRESULT hres;
2233 r = stack_pop(ctx);
2234 l = stack_pop(ctx);
2236 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
2238 hres = less_eval(ctx->script, r, l, FALSE, ctx->ei, &b);
2239 VariantClear(l);
2240 VariantClear(r);
2241 if(FAILED(hres))
2242 return hres;
2244 return stack_push_bool(ctx, b);
2247 /* ECMA-262 3rd Edition 11.8.4 */
2248 static HRESULT interp_gteq(exec_ctx_t *ctx)
2250 VARIANT *l, *r;
2251 BOOL b;
2252 HRESULT hres;
2254 r = stack_pop(ctx);
2255 l = stack_pop(ctx);
2257 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
2259 hres = less_eval(ctx->script, l, r, TRUE, ctx->ei, &b);
2260 VariantClear(l);
2261 VariantClear(r);
2262 if(FAILED(hres))
2263 return hres;
2265 return stack_push_bool(ctx, b);
2268 /* ECMA-262 3rd Edition 11.4.8 */
2269 static HRESULT interp_bneg(exec_ctx_t *ctx)
2271 VARIANT *v, r;
2272 INT i;
2273 HRESULT hres;
2275 TRACE("\n");
2277 v = stack_pop(ctx);
2278 hres = to_int32(ctx->script, v, ctx->ei, &i);
2279 VariantClear(v);
2280 if(FAILED(hres))
2281 return hres;
2283 V_VT(&r) = VT_I4;
2284 V_I4(&r) = ~i;
2285 return stack_push(ctx, &r);
2288 /* ECMA-262 3rd Edition 11.4.9 */
2289 static HRESULT interp_neg(exec_ctx_t *ctx)
2291 VARIANT *v;
2292 VARIANT_BOOL b;
2293 HRESULT hres;
2295 TRACE("\n");
2297 v = stack_pop(ctx);
2298 hres = to_boolean(v, &b);
2299 VariantClear(v);
2300 if(FAILED(hres))
2301 return hres;
2303 return stack_push_bool(ctx, !b);
2306 /* ECMA-262 3rd Edition 11.7.1 */
2307 static HRESULT interp_lshift(exec_ctx_t *ctx)
2309 DWORD r;
2310 INT l;
2311 HRESULT hres;
2313 hres = stack_pop_uint(ctx, &r);
2314 if(FAILED(hres))
2315 return hres;
2317 hres = stack_pop_int(ctx, &l);
2318 if(FAILED(hres))
2319 return hres;
2321 return stack_push_int(ctx, l << (r&0x1f));
2324 /* ECMA-262 3rd Edition 11.7.2 */
2325 static HRESULT interp_rshift(exec_ctx_t *ctx)
2327 DWORD r;
2328 INT l;
2329 HRESULT hres;
2331 hres = stack_pop_uint(ctx, &r);
2332 if(FAILED(hres))
2333 return hres;
2335 hres = stack_pop_int(ctx, &l);
2336 if(FAILED(hres))
2337 return hres;
2339 return stack_push_int(ctx, l >> (r&0x1f));
2342 /* ECMA-262 3rd Edition 11.7.3 */
2343 static HRESULT interp_rshift2(exec_ctx_t *ctx)
2345 DWORD r, l;
2346 HRESULT hres;
2348 hres = stack_pop_uint(ctx, &r);
2349 if(FAILED(hres))
2350 return hres;
2352 hres = stack_pop_uint(ctx, &l);
2353 if(FAILED(hres))
2354 return hres;
2356 return stack_push_int(ctx, l >> (r&0x1f));
2359 /* ECMA-262 3rd Edition 11.13.1 */
2360 static HRESULT interp_assign(exec_ctx_t *ctx)
2362 IDispatch *disp;
2363 DISPID id;
2364 VARIANT *v;
2365 HRESULT hres;
2367 TRACE("\n");
2369 v = stack_pop(ctx);
2370 disp = stack_pop_objid(ctx, &id);
2372 if(!disp)
2373 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
2375 hres = disp_propput(ctx->script, disp, id, v, ctx->ei);
2376 IDispatch_Release(disp);
2377 if(FAILED(hres)) {
2378 VariantClear(v);
2379 return hres;
2382 return stack_push(ctx, v);
2385 /* JScript extension */
2386 static HRESULT interp_assign_call(exec_ctx_t *ctx)
2388 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2389 DISPID propput_dispid = DISPID_PROPERTYPUT;
2390 IDispatch *disp;
2391 DISPPARAMS dp;
2392 VARIANT *v;
2393 DISPID id;
2394 HRESULT hres;
2396 TRACE("%u\n", arg);
2398 disp = stack_topn_objid(ctx, arg+1, &id);
2399 if(!disp)
2400 return throw_reference_error(ctx->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
2402 jsstack_to_dp(ctx, arg+1, &dp);
2403 dp.cNamedArgs = 1;
2404 dp.rgdispidNamedArgs = &propput_dispid;
2405 hres = disp_call(ctx->script, disp, id, DISPATCH_PROPERTYPUT, &dp, NULL, ctx->ei);
2406 if(FAILED(hres))
2407 return hres;
2409 v = stack_pop(ctx);
2410 stack_popn(ctx, arg+2);
2411 return stack_push(ctx, v);
2414 static HRESULT interp_undefined(exec_ctx_t *ctx)
2416 VARIANT v;
2418 TRACE("\n");
2420 V_VT(&v) = VT_EMPTY;
2421 return stack_push(ctx, &v);
2424 static HRESULT interp_jmp(exec_ctx_t *ctx)
2426 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2428 TRACE("\n");
2430 ctx->ip = arg;
2431 return S_OK;
2434 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2436 const unsigned arg = ctx->code->instrs[ctx->ip].arg1.uint;
2437 VARIANT_BOOL b;
2438 VARIANT *v;
2439 HRESULT hres;
2441 TRACE("\n");
2443 v = stack_pop(ctx);
2444 hres = to_boolean(v, &b);
2445 VariantClear(v);
2446 if(FAILED(hres))
2447 return hres;
2449 if(b)
2450 ctx->ip++;
2451 else
2452 ctx->ip = arg;
2453 return S_OK;
2456 static HRESULT interp_pop(exec_ctx_t *ctx)
2458 TRACE("\n");
2460 stack_popn(ctx, 1);
2461 return S_OK;
2464 static HRESULT interp_ret(exec_ctx_t *ctx)
2466 TRACE("\n");
2468 ctx->ip = -1;
2469 return S_OK;
2472 typedef HRESULT (*op_func_t)(exec_ctx_t*);
2474 static const op_func_t op_funcs[] = {
2475 #define X(x,a,b,c) interp_##x,
2476 OP_LIST
2477 #undef X
2480 static const unsigned op_move[] = {
2481 #define X(a,x,b,c) x,
2482 OP_LIST
2483 #undef X
2486 static HRESULT unwind_exception(exec_ctx_t *ctx)
2488 except_frame_t *except_frame;
2489 VARIANT except_val;
2490 BSTR ident;
2491 HRESULT hres;
2493 except_frame = ctx->except_frame;
2494 ctx->except_frame = except_frame->next;
2496 assert(except_frame->stack_top <= ctx->top);
2497 stack_popn(ctx, ctx->top - except_frame->stack_top);
2499 while(except_frame->scope != ctx->scope_chain)
2500 scope_pop(&ctx->scope_chain);
2502 ctx->ip = except_frame->catch_off;
2504 except_val = ctx->ei->var;
2505 memset(ctx->ei, 0, sizeof(*ctx->ei));
2507 ident = except_frame->ident;
2508 heap_free(except_frame);
2510 if(ident) {
2511 jsdisp_t *scope_obj;
2513 hres = create_dispex(ctx->script, NULL, NULL, &scope_obj);
2514 if(SUCCEEDED(hres)) {
2515 hres = jsdisp_propput_name(scope_obj, ident, &except_val, ctx->ei);
2516 if(FAILED(hres))
2517 jsdisp_release(scope_obj);
2519 VariantClear(&except_val);
2520 if(FAILED(hres))
2521 return hres;
2523 hres = scope_push(ctx->scope_chain, scope_obj, &ctx->scope_chain);
2524 jsdisp_release(scope_obj);
2525 }else {
2526 VARIANT v;
2528 hres = stack_push(ctx, &except_val);
2529 if(FAILED(hres))
2530 return hres;
2532 hres = stack_push_bool(ctx, FALSE);
2533 if(FAILED(hres))
2534 return hres;
2536 V_VT(&v) = VT_EMPTY;
2537 hres = stack_push(ctx, &v);
2540 return hres;
2543 static HRESULT enter_bytecode(script_ctx_t *ctx, bytecode_t *code, unsigned ip, jsexcept_t *ei, VARIANT *ret)
2545 exec_ctx_t *exec_ctx = ctx->exec_ctx;
2546 except_frame_t *prev_except_frame;
2547 unsigned prev_ip, prev_top;
2548 scope_chain_t *prev_scope;
2549 bytecode_t *prev_code;
2550 jsexcept_t *prev_ei;
2551 jsop_t op;
2552 HRESULT hres = S_OK;
2554 TRACE("\n");
2556 prev_top = exec_ctx->top;
2557 prev_scope = exec_ctx->scope_chain;
2558 prev_except_frame = exec_ctx->except_frame;
2559 prev_ip = exec_ctx->ip;
2560 prev_ei = exec_ctx->ei;
2561 prev_code = exec_ctx->code;
2562 exec_ctx->ip = ip;
2563 exec_ctx->ei = ei;
2564 exec_ctx->except_frame = NULL;
2565 exec_ctx->code = code;
2567 while(exec_ctx->ip != -1) {
2568 op = code->instrs[exec_ctx->ip].op;
2569 hres = op_funcs[op](exec_ctx);
2570 if(FAILED(hres)) {
2571 TRACE("EXCEPTION\n");
2573 if(!exec_ctx->except_frame)
2574 break;
2576 hres = unwind_exception(exec_ctx);
2577 if(FAILED(hres))
2578 break;
2579 }else {
2580 exec_ctx->ip += op_move[op];
2584 exec_ctx->ip = prev_ip;
2585 exec_ctx->ei = prev_ei;
2586 exec_ctx->except_frame = prev_except_frame;
2587 exec_ctx->code = prev_code;
2589 if(FAILED(hres)) {
2590 while(exec_ctx->scope_chain != prev_scope)
2591 scope_pop(&exec_ctx->scope_chain);
2592 stack_popn(exec_ctx, exec_ctx->top-prev_top);
2593 return hres;
2596 assert(exec_ctx->top == prev_top+1 || exec_ctx->top == prev_top);
2597 assert(exec_ctx->scope_chain == prev_scope);
2599 if(exec_ctx->top == prev_top)
2600 V_VT(ret) = VT_EMPTY;
2601 else
2602 *ret = *stack_pop(exec_ctx);
2603 return S_OK;
2606 HRESULT exec_source(exec_ctx_t *ctx, bytecode_t *code, source_elements_t *source, BOOL from_eval,
2607 jsexcept_t *ei, VARIANT *retv)
2609 function_declaration_t *func;
2610 var_list_t *var;
2611 VARIANT val;
2612 exec_ctx_t *prev_ctx;
2613 HRESULT hres = S_OK;
2615 for(func = source->functions; func; func = func->next) {
2616 jsdisp_t *func_obj;
2617 VARIANT var;
2619 if(!func->expr->identifier)
2620 continue;
2622 hres = create_source_function(ctx->script, code, func->expr->parameter_list, func->expr->source_elements,
2623 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
2624 if(FAILED(hres))
2625 return hres;
2627 var_set_jsdisp(&var, func_obj);
2628 hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei);
2629 jsdisp_release(func_obj);
2630 if(FAILED(hres))
2631 return hres;
2634 for(var = source->variables; var; var = var->next) {
2635 DISPID id = 0;
2636 BSTR name;
2638 name = SysAllocString(var->identifier);
2639 if(!name)
2640 return E_OUTOFMEMORY;
2642 if(!ctx->is_global || !lookup_global_members(ctx->script, name, NULL))
2643 hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
2644 SysFreeString(name);
2645 if(FAILED(hres))
2646 return hres;
2649 prev_ctx = ctx->script->exec_ctx;
2650 ctx->script->exec_ctx = ctx;
2652 if(source->statement) {
2653 assert(source->instr_off);
2654 hres = enter_bytecode(ctx->script, code, source->instr_off, ei, &val);
2655 }else {
2656 V_VT(&val) = VT_EMPTY;
2659 assert(ctx->script->exec_ctx == ctx);
2660 ctx->script->exec_ctx = prev_ctx;
2661 if(FAILED(hres))
2662 return hres;
2664 if(retv)
2665 *retv = val;
2666 else
2667 VariantClear(&val);
2668 return S_OK;