dlls/jscript/engine.c

   1 /*
   2  * Copyright 2008,2011 Jacek Caban for CodeWeavers
   3  *
   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.
   8  *
   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.
  13  *
  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
  17  */
  18
  19
  20 #include <math.h>
  21 #include <assert.h>
  22
  23 #include "jscript.h"
  24 #include "engine.h"
  25
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  29
  30 struct _except_frame_t {
  31     unsigned stack_top;
  32     scope_chain_t *scope;
  33     unsigned catch_off;
  34     unsigned finally_off;
  35
  36     except_frame_t *next;
  37 };
  38
  39 typedef struct {
  40     enum {
  41         EXPRVAL_JSVAL,
  42         EXPRVAL_IDREF,
  43         EXPRVAL_STACK_REF,
  44         EXPRVAL_INVALID
  45     } type;
  46     union {
  47         jsval_t val;
  48         struct {
  49             IDispatch *disp;
  50             DISPID id;
  51         } idref;
  52         unsigned off;
  53         HRESULT hres;
  54     } u;
  55 } exprval_t;
  56
  57 static const size_t stack_size = 0x4000;
  58
  59 static HRESULT stack_push(script_ctx_t *ctx, jsval_t v)
  60 {
  61     if(ctx->stack_top == stack_size)
  62         return JS_E_STACK_OVERFLOW;
  63
  64     ctx->stack[ctx->stack_top++] = v;
  65     return S_OK;
  66 }
  67
  68 static inline HRESULT stack_push_string(script_ctx_t *ctx, const WCHAR *str)
  69 {
  70     jsstr_t *v;
  71
  72     v = jsstr_alloc(str);
  73     if(!v)
  74         return E_OUTOFMEMORY;
  75
  76     return stack_push(ctx, jsval_string(v));
  77 }
  78
  79 static inline jsval_t stack_top(script_ctx_t *ctx)
  80 {
  81     assert(ctx->stack_top > ctx->call_ctx->stack_base);
  82     return ctx->stack[ctx->stack_top-1];
  83 }
  84
  85 static inline jsval_t *stack_top_ref(script_ctx_t *ctx, unsigned n)
  86 {
  87     assert(ctx->stack_top > ctx->call_ctx->stack_base+n);
  88     return ctx->stack+ctx->stack_top-1-n;
  89 }
  90
  91 static inline jsval_t stack_topn(script_ctx_t *ctx, unsigned n)
  92 {
  93     return *stack_top_ref(ctx, n);
  94 }
  95
  96 static inline jsval_t *stack_args(script_ctx_t *ctx, unsigned n)
  97 {
  98     if(!n)
  99         return NULL;
 100     assert(ctx->stack_top > ctx->call_ctx->stack_base+n-1);
 101     return ctx->stack + ctx->stack_top-n;
 102 }
 103
 104 static inline jsval_t stack_pop(script_ctx_t *ctx)
 105 {
 106     assert(ctx->stack_top > ctx->call_ctx->stack_base);
 107     return ctx->stack[--ctx->stack_top];
 108 }
 109
 110 static void stack_popn(script_ctx_t *ctx, unsigned n)
 111 {
 112     while(n--)
 113         jsval_release(stack_pop(ctx));
 114 }
 115
 116 static HRESULT stack_pop_number(script_ctx_t *ctx, double *r)
 117 {
 118     jsval_t v;
 119     HRESULT hres;
 120
 121     v = stack_pop(ctx);
 122     hres = to_number(ctx, v, r);
 123     jsval_release(v);
 124     return hres;
 125 }
 126
 127 static HRESULT stack_pop_object(script_ctx_t *ctx, IDispatch **r)
 128 {
 129     jsval_t v;
 130     HRESULT hres;
 131
 132     v = stack_pop(ctx);
 133     if(is_object_instance(v)) {
 134         if(!get_object(v))
 135             return JS_E_OBJECT_REQUIRED;
 136         *r = get_object(v);
 137         return S_OK;
 138     }
 139
 140     hres = to_object(ctx, v, r);
 141     jsval_release(v);
 142     return hres;
 143 }
 144
 145 static inline HRESULT stack_pop_int(script_ctx_t *ctx, INT *r)
 146 {
 147     return to_int32(ctx, stack_pop(ctx), r);
 148 }
 149
 150 static inline HRESULT stack_pop_uint(script_ctx_t *ctx, DWORD *r)
 151 {
 152     return to_uint32(ctx, stack_pop(ctx), r);
 153 }
 154
 155 static inline unsigned local_off(call_frame_t *frame, int ref)
 156 {
 157     return ref < 0
 158         ? frame->arguments_off - ref-1
 159         : frame->variables_off + ref;
 160 }
 161
 162 static inline BSTR local_name(call_frame_t *frame, int ref)
 163 {
 164     return ref < 0 ? frame->function->params[-ref-1] : frame->function->variables[ref].name;
 165 }
 166
 167 /* Steals input reference even on failure. */
 168 static HRESULT stack_push_exprval(script_ctx_t *ctx, exprval_t *val)
 169 {
 170     HRESULT hres;
 171
 172     switch(val->type) {
 173     case EXPRVAL_JSVAL:
 174         assert(0);
 175     case EXPRVAL_IDREF:
 176         hres = stack_push(ctx, jsval_disp(val->u.idref.disp));
 177         if(SUCCEEDED(hres))
 178             hres = stack_push(ctx, jsval_number(val->u.idref.id));
 179         else
 180             IDispatch_Release(val->u.idref.disp);
 181         return hres;
 182     case EXPRVAL_STACK_REF:
 183         hres = stack_push(ctx, jsval_number(val->u.off));
 184         if(SUCCEEDED(hres))
 185             hres = stack_push(ctx, jsval_undefined());
 186         return hres;
 187     case EXPRVAL_INVALID:
 188         hres = stack_push(ctx, jsval_undefined());
 189         if(SUCCEEDED(hres))
 190             hres = stack_push(ctx, jsval_number(val->u.hres));
 191         return hres;
 192     }
 193
 194     assert(0);
 195     return E_FAIL;
 196 }
 197
 198 static BOOL stack_topn_exprval(script_ctx_t *ctx, unsigned n, exprval_t *r)
 199 {
 200     jsval_t v = stack_topn(ctx, n+1);
 201
 202     switch(jsval_type(v)) {
 203     case JSV_NUMBER: {
 204         call_frame_t *frame = ctx->call_ctx;
 205         unsigned off = get_number(v);
 206
 207         if(!frame->base_scope->frame && off >= frame->arguments_off) {
 208             DISPID id;
 209             BSTR name;
 210             HRESULT hres;
 211
 212             /* Got stack reference in deoptimized code. Need to convert it back to variable object reference. */
 213
 214             assert(off < frame->variables_off + frame->function->var_cnt);
 215             name = off >= frame->variables_off
 216                 ? frame->function->variables[off - frame->variables_off].name
 217                 : frame->function->params[off - frame->arguments_off];
 218             hres = jsdisp_get_id(ctx->call_ctx->base_scope->jsobj, name, 0, &id);
 219             if(FAILED(hres)) {
 220                 r->type = EXPRVAL_INVALID;
 221                 r->u.hres = hres;
 222                 return FALSE;
 223             }
 224
 225             *stack_top_ref(ctx, n+1) = jsval_obj(jsdisp_addref(frame->base_scope->jsobj));
 226             *stack_top_ref(ctx, n) = jsval_number(id);
 227             r->type = EXPRVAL_IDREF;
 228             r->u.idref.disp = frame->base_scope->obj;
 229             r->u.idref.id = id;
 230             return TRUE;
 231         }
 232
 233         r->type = EXPRVAL_STACK_REF;
 234         r->u.off = off;
 235         return TRUE;
 236     }
 237     case JSV_OBJECT:
 238         r->type = EXPRVAL_IDREF;
 239         r->u.idref.disp = get_object(v);
 240         assert(is_number(stack_topn(ctx, n)));
 241         r->u.idref.id = get_number(stack_topn(ctx, n));
 242         return TRUE;
 243     case JSV_UNDEFINED:
 244         r->type = EXPRVAL_INVALID;
 245         assert(is_number(stack_topn(ctx, n)));
 246         r->u.hres = get_number(stack_topn(ctx, n));
 247         return FALSE;
 248     default:
 249         assert(0);
 250         return FALSE;
 251     }
 252 }
 253
 254 static inline BOOL stack_pop_exprval(script_ctx_t *ctx, exprval_t *r)
 255 {
 256     BOOL ret = stack_topn_exprval(ctx, 0, r);
 257     ctx->stack_top -= 2;
 258     return ret;
 259 }
 260
 261 static HRESULT exprval_propput(script_ctx_t *ctx, exprval_t *ref, jsval_t v)
 262 {
 263     switch(ref->type) {
 264     case EXPRVAL_STACK_REF: {
 265         jsval_t *r = ctx->stack + ref->u.off;
 266         jsval_release(*r);
 267         return jsval_copy(v, r);
 268     }
 269     case EXPRVAL_IDREF:
 270         return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v);
 271     default:
 272         assert(0);
 273         return E_FAIL;
 274     }
 275 }
 276
 277 static HRESULT exprval_propget(script_ctx_t *ctx, exprval_t *ref, jsval_t *r)
 278 {
 279     switch(ref->type) {
 280     case EXPRVAL_STACK_REF:
 281         return jsval_copy(ctx->stack[ref->u.off], r);
 282     case EXPRVAL_IDREF:
 283         return disp_propget(ctx, ref->u.idref.disp, ref->u.idref.id, r);
 284     default:
 285         assert(0);
 286         return E_FAIL;
 287     }
 288 }
 289
 290 static HRESULT exprval_call(script_ctx_t *ctx, exprval_t *ref, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
 291 {
 292     switch(ref->type) {
 293     case EXPRVAL_STACK_REF: {
 294         jsval_t v = ctx->stack[ref->u.off];
 295
 296         if(!is_object_instance(v)) {
 297             FIXME("invoke %s\n", debugstr_jsval(v));
 298             return E_FAIL;
 299         }
 300
 301         return disp_call_value(ctx, get_object(v), NULL, flags, argc, argv, r);
 302     }
 303     case EXPRVAL_IDREF:
 304         return disp_call(ctx, ref->u.idref.disp, ref->u.idref.id, flags, argc, argv, r);
 305     default:
 306         assert(0);
 307         return E_FAIL;
 308     }
 309 }
 310
 311 /* ECMA-262 3rd Edition    8.7.1 */
 312 /* Steals input reference. */
 313 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *ref, jsval_t *r)
 314 {
 315     HRESULT hres;
 316
 317     if(ref->type == EXPRVAL_JSVAL) {
 318         *r = ref->u.val;
 319         return S_OK;
 320     }
 321
 322     hres = exprval_propget(ctx, ref, r);
 323
 324     if(ref->type == EXPRVAL_IDREF)
 325         IDispatch_Release(ref->u.idref.disp);
 326     return hres;
 327 }
 328
 329 static void exprval_release(exprval_t *val)
 330 {
 331     switch(val->type) {
 332     case EXPRVAL_JSVAL:
 333         jsval_release(val->u.val);
 334         return;
 335     case EXPRVAL_IDREF:
 336         if(val->u.idref.disp)
 337             IDispatch_Release(val->u.idref.disp);
 338         return;
 339     case EXPRVAL_STACK_REF:
 340     case EXPRVAL_INVALID:
 341         return;
 342     }
 343 }
 344
 345 static inline void exprval_set_exception(exprval_t *val, HRESULT hres)
 346 {
 347     val->type = EXPRVAL_INVALID;
 348     val->u.hres = hres;
 349 }
 350
 351 static inline void exprval_set_disp_ref(exprval_t *ref, IDispatch *obj, DISPID id)
 352 {
 353     ref->type = EXPRVAL_IDREF;
 354     IDispatch_AddRef(ref->u.idref.disp = obj);
 355     ref->u.idref.id = id;
 356 }
 357
 358 static inline jsval_t steal_ret(call_frame_t *frame)
 359 {
 360     jsval_t r = frame->ret;
 361     frame->ret = jsval_undefined();
 362     return r;
 363 }
 364
 365 static inline void clear_acc(script_ctx_t *ctx)
 366 {
 367     jsval_release(ctx->acc);
 368     ctx->acc = jsval_undefined();
 369 }
 370
 371 static HRESULT scope_push(scope_chain_t *scope, jsdisp_t *jsobj, IDispatch *obj, scope_chain_t **ret)
 372 {
 373     scope_chain_t *new_scope;
 374
 375     new_scope = heap_alloc(sizeof(scope_chain_t));
 376     if(!new_scope)
 377         return E_OUTOFMEMORY;
 378
 379     new_scope->ref = 1;
 380
 381     IDispatch_AddRef(obj);
 382     new_scope->jsobj = jsobj;
 383     new_scope->obj = obj;
 384     new_scope->frame = NULL;
 385     new_scope->next = scope ? scope_addref(scope) : NULL;
 386
 387     *ret = new_scope;
 388     return S_OK;
 389 }
 390
 391 static void scope_pop(scope_chain_t **scope)
 392 {
 393     scope_chain_t *tmp;
 394
 395     tmp = *scope;
 396     *scope = tmp->next;
 397     scope_release(tmp);
 398 }
 399
 400 void scope_release(scope_chain_t *scope)
 401 {
 402     if(--scope->ref)
 403         return;
 404
 405     if(scope->next)
 406         scope_release(scope->next);
 407
 408     IDispatch_Release(scope->obj);
 409     heap_free(scope);
 410 }
 411
 412 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, const WCHAR *name, BSTR name_bstr, DWORD flags, DISPID *id)
 413 {
 414     IDispatchEx *dispex;
 415     jsdisp_t *jsdisp;
 416     BSTR bstr;
 417     HRESULT hres;
 418
 419     jsdisp = iface_to_jsdisp(disp);
 420     if(jsdisp) {
 421         hres = jsdisp_get_id(jsdisp, name, flags, id);
 422         jsdisp_release(jsdisp);
 423         return hres;
 424     }
 425
 426     if(name_bstr) {
 427         bstr = name_bstr;
 428     }else {
 429         bstr = SysAllocString(name);
 430         if(!bstr)
 431             return E_OUTOFMEMORY;
 432     }
 433
 434     *id = 0;
 435     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 436     if(SUCCEEDED(hres)) {
 437         hres = IDispatchEx_GetDispID(dispex, bstr, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
 438         IDispatchEx_Release(dispex);
 439     }else {
 440         TRACE("using IDispatch\n");
 441         hres = IDispatch_GetIDsOfNames(disp, &IID_NULL, &bstr, 1, 0, id);
 442     }
 443
 444     if(name_bstr != bstr)
 445         SysFreeString(bstr);
 446     return hres;
 447 }
 448
 449 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
 450 {
 451     IObjectIdentity *identity;
 452     IUnknown *unk1, *unk2;
 453     HRESULT hres;
 454
 455     if(disp1 == disp2) {
 456         *ret = TRUE;
 457         return S_OK;
 458     }
 459
 460     if(!disp1 || !disp2) {
 461         *ret = FALSE;
 462         return S_OK;
 463     }
 464
 465     hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
 466     if(FAILED(hres))
 467         return hres;
 468
 469     hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
 470     if(FAILED(hres)) {
 471         IUnknown_Release(unk1);
 472         return hres;
 473     }
 474
 475     if(unk1 == unk2) {
 476         *ret = TRUE;
 477     }else {
 478         hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
 479         if(SUCCEEDED(hres)) {
 480             hres = IObjectIdentity_IsEqualObject(identity, unk2);
 481             IObjectIdentity_Release(identity);
 482             *ret = hres == S_OK;
 483         }else {
 484             *ret = FALSE;
 485         }
 486     }
 487
 488     IUnknown_Release(unk1);
 489     IUnknown_Release(unk2);
 490     return S_OK;
 491 }
 492
 493 /* ECMA-262 3rd Edition    11.9.6 */
 494 HRESULT jsval_strict_equal(jsval_t lval, jsval_t rval, BOOL *ret)
 495 {
 496     jsval_type_t type = jsval_type(lval);
 497
 498     TRACE("\n");
 499
 500     if(type != jsval_type(rval)) {
 501         if(is_null_instance(lval))
 502             *ret = is_null_instance(rval);
 503         else
 504             *ret = FALSE;
 505         return S_OK;
 506     }
 507
 508     switch(type) {
 509     case JSV_UNDEFINED:
 510     case JSV_NULL:
 511         *ret = TRUE;
 512         break;
 513     case JSV_OBJECT:
 514         return disp_cmp(get_object(lval), get_object(rval), ret);
 515     case JSV_STRING:
 516         *ret = jsstr_eq(get_string(lval), get_string(rval));
 517         break;
 518     case JSV_NUMBER:
 519         *ret = get_number(lval) == get_number(rval);
 520         break;
 521     case JSV_BOOL:
 522         *ret = !get_bool(lval) == !get_bool(rval);
 523         break;
 524     case JSV_VARIANT:
 525         WARN("VARIANT type, returning false\n");
 526         *ret = FALSE;
 527         return S_OK;
 528     }
 529
 530     return S_OK;
 531 }
 532
 533 /*
 534  * Transfers local variables from stack to variable object.
 535  * It's slow, so we want to avoid it as much as possible.
 536  */
 537 static HRESULT detach_variable_object(script_ctx_t *ctx, call_frame_t *frame, BOOL from_release)
 538 {
 539     unsigned i;
 540     HRESULT hres;
 541
 542     if(!frame->base_scope || !frame->base_scope->frame)
 543         return S_OK;
 544
 545     TRACE("detaching %p\n", frame);
 546
 547     assert(frame == frame->base_scope->frame);
 548     assert(frame->variable_obj == frame->base_scope->jsobj);
 549
 550     if(!from_release && !frame->arguments_obj) {
 551         hres = setup_arguments_object(ctx, frame);
 552         if(FAILED(hres))
 553             return hres;
 554     }
 555
 556     frame->base_scope->frame = NULL;
 557
 558     for(i = 0; i < frame->function->locals_cnt; i++) {
 559         hres = jsdisp_propput_name(frame->variable_obj, frame->function->locals[i].name,
 560                                    ctx->stack[local_off(frame, frame->function->locals[i].ref)]);
 561         if(FAILED(hres))
 562             return hres;
 563     }
 564
 565     return S_OK;
 566 }
 567
 568 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
 569 {
 570     named_item_t *item;
 571     DISPID id;
 572     HRESULT hres;
 573
 574     LIST_FOR_EACH_ENTRY(item, &ctx->named_items, named_item_t, entry) {
 575         if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
 576             hres = disp_get_id(ctx, item->disp, identifier, identifier, 0, &id);
 577             if(SUCCEEDED(hres)) {
 578                 if(ret)
 579                     exprval_set_disp_ref(ret, item->disp, id);
 580                 return TRUE;
 581             }
 582         }
 583     }
 584
 585     return FALSE;
 586 }
 587
 588 IDispatch *lookup_global_host(script_ctx_t *ctx)
 589 {
 590     IDispatch *disp = NULL;
 591     named_item_t *item;
 592
 593     LIST_FOR_EACH_ENTRY(item, &ctx->named_items, named_item_t, entry) {
 594         if(!(item->flags & SCRIPTITEM_GLOBALMEMBERS)) continue;
 595         disp = item->disp;
 596         break;
 597     }
 598     if(!disp) disp = to_disp(ctx->global);
 599
 600     return disp;
 601 }
 602
 603 static int __cdecl local_ref_cmp(const void *key, const void *ref)
 604 {
 605     return wcscmp((const WCHAR*)key, ((const local_ref_t*)ref)->name);
 606 }
 607
 608 local_ref_t *lookup_local(const function_code_t *function, const WCHAR *identifier)
 609 {
 610     return bsearch(identifier, function->locals, function->locals_cnt, sizeof(*function->locals), local_ref_cmp);
 611 }
 612
 613 /* ECMA-262 3rd Edition    10.1.4 */
 614 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
 615 {
 616     scope_chain_t *scope;
 617     named_item_t *item;
 618     DISPID id = 0;
 619     HRESULT hres;
 620
 621     TRACE("%s\n", debugstr_w(identifier));
 622
 623     if(ctx->call_ctx) {
 624         for(scope = ctx->call_ctx->scope; scope; scope = scope->next) {
 625             if(scope->frame) {
 626                 function_code_t *func = scope->frame->function;
 627                 local_ref_t *ref = lookup_local(func, identifier);
 628
 629                 if(ref) {
 630                     ret->type = EXPRVAL_STACK_REF;
 631                     ret->u.off = local_off(scope->frame, ref->ref);
 632                     TRACE("returning ref %d for %d\n", ret->u.off, ref->ref);
 633                     return S_OK;
 634                 }
 635
 636                 if(!wcscmp(identifier, L"arguments")) {
 637                     hres = detach_variable_object(ctx, scope->frame, FALSE);
 638                     if(FAILED(hres))
 639                         return hres;
 640                 }
 641             }
 642             if(scope->jsobj)
 643                 hres = jsdisp_get_id(scope->jsobj, identifier, fdexNameImplicit, &id);
 644             else
 645                 hres = disp_get_id(ctx, scope->obj, identifier, identifier, fdexNameImplicit, &id);
 646             if(SUCCEEDED(hres)) {
 647                 exprval_set_disp_ref(ret, scope->obj, id);
 648                 return S_OK;
 649             }
 650         }
 651
 652         item = ctx->call_ctx->bytecode->named_item;
 653         if(item) {
 654             hres = jsdisp_get_id(item->script_obj, identifier, 0, &id);
 655             if(SUCCEEDED(hres)) {
 656                 exprval_set_disp_ref(ret, to_disp(item->script_obj), id);
 657                 return S_OK;
 658             }
 659             if(!(item->flags & SCRIPTITEM_CODEONLY)) {
 660                 hres = disp_get_id(ctx, item->disp, identifier, identifier, 0, &id);
 661                 if(SUCCEEDED(hres)) {
 662                     exprval_set_disp_ref(ret, item->disp, id);
 663                     return S_OK;
 664                 }
 665             }
 666         }
 667     }
 668
 669     hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
 670     if(SUCCEEDED(hres)) {
 671         exprval_set_disp_ref(ret, to_disp(ctx->global), id);
 672         return S_OK;
 673     }
 674
 675     item = lookup_named_item(ctx, identifier, SCRIPTITEM_ISVISIBLE);
 676     if(item) {
 677         IDispatch_AddRef(item->disp);
 678         ret->type = EXPRVAL_JSVAL;
 679         ret->u.val = jsval_disp(item->disp);
 680         return S_OK;
 681     }
 682
 683     if(lookup_global_members(ctx, identifier, ret))
 684         return S_OK;
 685
 686     exprval_set_exception(ret, JS_E_UNDEFINED_VARIABLE);
 687     return S_OK;
 688 }
 689
 690 static inline BSTR get_op_bstr(script_ctx_t *ctx, int i)
 691 {
 692     call_frame_t *frame = ctx->call_ctx;
 693     return frame->bytecode->instrs[frame->ip].u.arg[i].bstr;
 694 }
 695
 696 static inline unsigned get_op_uint(script_ctx_t *ctx, int i)
 697 {
 698     call_frame_t *frame = ctx->call_ctx;
 699     return frame->bytecode->instrs[frame->ip].u.arg[i].uint;
 700 }
 701
 702 static inline unsigned get_op_int(script_ctx_t *ctx, int i)
 703 {
 704     call_frame_t *frame = ctx->call_ctx;
 705     return frame->bytecode->instrs[frame->ip].u.arg[i].lng;
 706 }
 707
 708 static inline jsstr_t *get_op_str(script_ctx_t *ctx, int i)
 709 {
 710     call_frame_t *frame = ctx->call_ctx;
 711     return frame->bytecode->instrs[frame->ip].u.arg[i].str;
 712 }
 713
 714 static inline double get_op_double(script_ctx_t *ctx)
 715 {
 716     call_frame_t *frame = ctx->call_ctx;
 717     return frame->bytecode->instrs[frame->ip].u.dbl;
 718 }
 719
 720 static inline void jmp_next(script_ctx_t *ctx)
 721 {
 722     ctx->call_ctx->ip++;
 723 }
 724
 725 static inline void jmp_abs(script_ctx_t *ctx, unsigned dst)
 726 {
 727     ctx->call_ctx->ip = dst;
 728 }
 729
 730 /* ECMA-262 3rd Edition    12.6.4 */
 731 static HRESULT interp_forin(script_ctx_t *ctx)
 732 {
 733     const HRESULT arg = get_op_uint(ctx, 0);
 734     IDispatch *obj = NULL;
 735     IDispatchEx *dispex;
 736     exprval_t prop_ref;
 737     DISPID id;
 738     BSTR name = NULL;
 739     HRESULT hres;
 740
 741     TRACE("\n");
 742
 743     assert(is_number(stack_top(ctx)));
 744     id = get_number(stack_top(ctx));
 745
 746     if(!stack_topn_exprval(ctx, 1, &prop_ref)) {
 747         FIXME("invalid ref: %08x\n", prop_ref.u.hres);
 748         return E_FAIL;
 749     }
 750
 751     if(is_object_instance(stack_topn(ctx, 3)))
 752         obj = get_object(stack_topn(ctx, 3));
 753
 754     if(obj) {
 755         hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
 756         if(SUCCEEDED(hres)) {
 757             hres = IDispatchEx_GetNextDispID(dispex, fdexEnumDefault, id, &id);
 758             if(hres == S_OK)
 759                 hres = IDispatchEx_GetMemberName(dispex, id, &name);
 760             IDispatchEx_Release(dispex);
 761             if(FAILED(hres))
 762                 return hres;
 763         }else {
 764             TRACE("No IDispatchEx\n");
 765         }
 766     }
 767
 768     if(name) {
 769         jsstr_t *str;
 770
 771         str = jsstr_alloc_len(name, SysStringLen(name));
 772         SysFreeString(name);
 773         if(!str)
 774             return E_OUTOFMEMORY;
 775
 776         stack_pop(ctx);
 777         stack_push(ctx, jsval_number(id)); /* safe, just after pop() */
 778
 779         hres = exprval_propput(ctx, &prop_ref, jsval_string(str));
 780         jsstr_release(str);
 781         if(FAILED(hres))
 782             return hres;
 783
 784         jmp_next(ctx);
 785     }else {
 786         stack_popn(ctx, 4);
 787         jmp_abs(ctx, arg);
 788     }
 789     return S_OK;
 790 }
 791
 792 /* ECMA-262 3rd Edition    12.10 */
 793 static HRESULT interp_push_scope(script_ctx_t *ctx)
 794 {
 795     IDispatch *disp;
 796     jsval_t v;
 797     HRESULT hres;
 798
 799     TRACE("\n");
 800
 801     v = stack_pop(ctx);
 802     hres = to_object(ctx, v, &disp);
 803     jsval_release(v);
 804     if(FAILED(hres))
 805         return hres;
 806
 807     hres = scope_push(ctx->call_ctx->scope, to_jsdisp(disp), disp, &ctx->call_ctx->scope);
 808     IDispatch_Release(disp);
 809     return hres;
 810 }
 811
 812 /* ECMA-262 3rd Edition    12.10 */
 813 static HRESULT interp_pop_scope(script_ctx_t *ctx)
 814 {
 815     TRACE("\n");
 816
 817     scope_pop(&ctx->call_ctx->scope);
 818     return S_OK;
 819 }
 820
 821 /* ECMA-262 3rd Edition    12.13 */
 822 static HRESULT interp_case(script_ctx_t *ctx)
 823 {
 824     const unsigned arg = get_op_uint(ctx, 0);
 825     jsval_t v;
 826     BOOL b;
 827     HRESULT hres;
 828
 829     TRACE("\n");
 830
 831     v = stack_pop(ctx);
 832     hres = jsval_strict_equal(stack_top(ctx), v, &b);
 833     jsval_release(v);
 834     if(FAILED(hres))
 835         return hres;
 836
 837     if(b) {
 838         stack_popn(ctx, 1);
 839         jmp_abs(ctx, arg);
 840     }else {
 841         jmp_next(ctx);
 842     }
 843     return S_OK;
 844 }
 845
 846 static void set_error_value(script_ctx_t *ctx, jsval_t value)
 847 {
 848     jsexcept_t *ei = ctx->ei;
 849     jsdisp_t *obj;
 850
 851     reset_ei(ei);
 852     ei->error = JS_E_EXCEPTION_THROWN;
 853     ei->valid_value = TRUE;
 854     ei->value = value;
 855
 856     if(is_object_instance(value) && get_object(value) && (obj = to_jsdisp(get_object(value)))) {
 857         UINT32 number;
 858         jsstr_t *str;
 859         jsval_t v;
 860         HRESULT hres;
 861
 862         /* FIXME: We should check if object is an error instance */
 863
 864         hres = jsdisp_propget_name(obj, L"number", &v);
 865         if(SUCCEEDED(hres)) {
 866             hres = to_uint32(ctx, v, &number);
 867             if(SUCCEEDED(hres))
 868                 ei->error = FAILED(number) ? number : E_FAIL;
 869             jsval_release(v);
 870         }
 871
 872         hres = jsdisp_propget_name(obj, L"description", &v);
 873         if(SUCCEEDED(hres)) {
 874             hres = to_string(ctx, v, &str);
 875             if(SUCCEEDED(hres))
 876                 ei->message = str;
 877             jsval_release(v);
 878         }
 879     }
 880 }
 881
 882 /* ECMA-262 3rd Edition    12.13 */
 883 static HRESULT interp_throw(script_ctx_t *ctx)
 884 {
 885     TRACE("\n");
 886
 887     set_error_value(ctx, stack_pop(ctx));
 888     return DISP_E_EXCEPTION;
 889 }
 890
 891 static HRESULT interp_throw_ref(script_ctx_t *ctx)
 892 {
 893     const HRESULT arg = get_op_uint(ctx, 0);
 894
 895     TRACE("%08x\n", arg);
 896
 897     return arg;
 898 }
 899
 900 static HRESULT interp_throw_type(script_ctx_t *ctx)
 901 {
 902     const HRESULT hres = get_op_uint(ctx, 0);
 903     jsstr_t *str = get_op_str(ctx, 1);
 904     const WCHAR *ptr;
 905
 906     TRACE("%08x %s\n", hres, debugstr_jsstr(str));
 907
 908     ptr = jsstr_flatten(str);
 909     return ptr ? throw_error(ctx, hres, ptr) : E_OUTOFMEMORY;
 910 }
 911
 912 /* ECMA-262 3rd Edition    12.14 */
 913 static HRESULT interp_push_except(script_ctx_t *ctx)
 914 {
 915     const unsigned catch_off = get_op_uint(ctx, 0);
 916     const unsigned finally_off = get_op_uint(ctx, 1);
 917     call_frame_t *frame = ctx->call_ctx;
 918     except_frame_t *except;
 919
 920     TRACE("\n");
 921
 922     except = heap_alloc(sizeof(*except));
 923     if(!except)
 924         return E_OUTOFMEMORY;
 925
 926     except->stack_top = ctx->stack_top;
 927     except->scope = frame->scope;
 928     except->catch_off = catch_off;
 929     except->finally_off = finally_off;
 930     except->next = frame->except_frame;
 931     frame->except_frame = except;
 932     return S_OK;
 933 }
 934
 935 /* ECMA-262 3rd Edition    12.14 */
 936 static HRESULT interp_pop_except(script_ctx_t *ctx)
 937 {
 938     const unsigned ret_off = get_op_uint(ctx, 0);
 939     call_frame_t *frame = ctx->call_ctx;
 940     except_frame_t *except;
 941     unsigned finally_off;
 942
 943     TRACE("%u\n", ret_off);
 944
 945     except = frame->except_frame;
 946     assert(except != NULL);
 947
 948     finally_off = except->finally_off;
 949     frame->except_frame = except->next;
 950     heap_free(except);
 951
 952     if(finally_off) {
 953         HRESULT hres;
 954
 955         hres = stack_push(ctx, jsval_number(ret_off));
 956         if(FAILED(hres))
 957             return hres;
 958         hres = stack_push(ctx, jsval_bool(TRUE));
 959         if(FAILED(hres))
 960             return hres;
 961         frame->ip = finally_off;
 962     }else {
 963         frame->ip = ret_off;
 964     }
 965
 966     return S_OK;
 967 }
 968
 969 /* ECMA-262 3rd Edition    12.14 */
 970 static HRESULT interp_end_finally(script_ctx_t *ctx)
 971 {
 972     call_frame_t *frame = ctx->call_ctx;
 973     jsval_t v;
 974
 975     TRACE("\n");
 976
 977     v = stack_pop(ctx);
 978     assert(is_bool(v));
 979
 980     if(!get_bool(v)) {
 981         TRACE("passing exception\n");
 982
 983         set_error_value(ctx, stack_pop(ctx));
 984         return DISP_E_EXCEPTION;
 985     }
 986
 987     v = stack_pop(ctx);
 988     assert(is_number(v));
 989     frame->ip = get_number(v);
 990     return S_OK;
 991 }
 992
 993 static HRESULT interp_enter_catch(script_ctx_t *ctx)
 994 {
 995     const BSTR ident = get_op_bstr(ctx, 0);
 996     jsdisp_t *scope_obj;
 997     jsval_t v;
 998     HRESULT hres;
 999
1000     hres = create_dispex(ctx, NULL, NULL, &scope_obj);
1001     if(FAILED(hres))
1002         return hres;
1003
1004     v = stack_pop(ctx);
1005     hres = jsdisp_propput_name(scope_obj, ident, v);
1006     jsval_release(v);
1007     if(SUCCEEDED(hres))
1008         hres = scope_push(ctx->call_ctx->scope, scope_obj, to_disp(scope_obj), &ctx->call_ctx->scope);
1009     jsdisp_release(scope_obj);
1010     return hres;
1011 }
1012
1013 /* ECMA-262 3rd Edition    13 */
1014 static HRESULT interp_func(script_ctx_t *ctx)
1015 {
1016     unsigned func_idx = get_op_uint(ctx, 0);
1017     call_frame_t *frame = ctx->call_ctx;
1018     jsdisp_t *dispex;
1019     HRESULT hres;
1020
1021     TRACE("%d\n", func_idx);
1022
1023     hres = create_source_function(ctx, frame->bytecode, frame->function->funcs+func_idx,
1024             frame->scope, &dispex);
1025     if(FAILED(hres))
1026         return hres;
1027
1028     return stack_push(ctx, jsval_obj(dispex));
1029 }
1030
1031 /* ECMA-262 3rd Edition    11.2.1 */
1032 static HRESULT interp_array(script_ctx_t *ctx)
1033 {
1034     jsstr_t *name_str;
1035     const WCHAR *name;
1036     jsval_t v, namev;
1037     IDispatch *obj;
1038     DISPID id;
1039     HRESULT hres;
1040
1041     TRACE("\n");
1042
1043     namev = stack_pop(ctx);
1044
1045     hres = stack_pop_object(ctx, &obj);
1046     if(FAILED(hres)) {
1047         jsval_release(namev);
1048         return hres;
1049     }
1050
1051     hres = to_flat_string(ctx, namev, &name_str, &name);
1052     jsval_release(namev);
1053     if(FAILED(hres)) {
1054         IDispatch_Release(obj);
1055         return hres;
1056     }
1057
1058     hres = disp_get_id(ctx, obj, name, NULL, 0, &id);
1059     jsstr_release(name_str);
1060     if(SUCCEEDED(hres)) {
1061         hres = disp_propget(ctx, obj, id, &v);
1062     }else if(hres == DISP_E_UNKNOWNNAME) {
1063         v = jsval_undefined();
1064         hres = S_OK;
1065     }
1066     IDispatch_Release(obj);
1067     if(FAILED(hres))
1068         return hres;
1069
1070     return stack_push(ctx, v);
1071 }
1072
1073 /* ECMA-262 3rd Edition    11.2.1 */
1074 static HRESULT interp_member(script_ctx_t *ctx)
1075 {
1076     const BSTR arg = get_op_bstr(ctx, 0);
1077     IDispatch *obj;
1078     jsval_t v;
1079     DISPID id;
1080     HRESULT hres;
1081
1082     TRACE("\n");
1083
1084     hres = stack_pop_object(ctx, &obj);
1085     if(FAILED(hres))
1086         return hres;
1087
1088     hres = disp_get_id(ctx, obj, arg, arg, 0, &id);
1089     if(SUCCEEDED(hres)) {
1090         hres = disp_propget(ctx, obj, id, &v);
1091     }else if(hres == DISP_E_UNKNOWNNAME) {
1092         v = jsval_undefined();
1093         hres = S_OK;
1094     }
1095     IDispatch_Release(obj);
1096     if(FAILED(hres))
1097         return hres;
1098
1099     return stack_push(ctx, v);
1100 }
1101
1102 /* ECMA-262 3rd Edition    11.2.1 */
1103 static HRESULT interp_memberid(script_ctx_t *ctx)
1104 {
1105     const unsigned arg = get_op_uint(ctx, 0);
1106     jsval_t objv, namev;
1107     const WCHAR *name;
1108     jsstr_t *name_str;
1109     IDispatch *obj;
1110     exprval_t ref;
1111     DISPID id;
1112     HRESULT hres;
1113
1114     TRACE("%x\n", arg);
1115
1116     namev = stack_pop(ctx);
1117     objv = stack_pop(ctx);
1118
1119     hres = to_object(ctx, objv, &obj);
1120     jsval_release(objv);
1121     if(SUCCEEDED(hres)) {
1122         hres = to_flat_string(ctx, namev, &name_str, &name);
1123         if(FAILED(hres))
1124             IDispatch_Release(obj);
1125     }
1126     jsval_release(namev);
1127     if(FAILED(hres))
1128         return hres;
1129
1130     hres = disp_get_id(ctx, obj, name, NULL, arg, &id);
1131     jsstr_release(name_str);
1132     if(SUCCEEDED(hres)) {
1133         ref.type = EXPRVAL_IDREF;
1134         ref.u.idref.disp = obj;
1135         ref.u.idref.id = id;
1136     }else {
1137         IDispatch_Release(obj);
1138         if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1139             exprval_set_exception(&ref, JS_E_INVALID_PROPERTY);
1140             hres = S_OK;
1141         }else {
1142             ERR("failed %08x\n", hres);
1143             return hres;
1144         }
1145     }
1146
1147     return stack_push_exprval(ctx, &ref);
1148 }
1149
1150 /* ECMA-262 3rd Edition    11.2.1 */
1151 static HRESULT interp_refval(script_ctx_t *ctx)
1152 {
1153     exprval_t ref;
1154     jsval_t v;
1155     HRESULT hres;
1156
1157     TRACE("\n");
1158
1159     if(!stack_topn_exprval(ctx, 0, &ref))
1160         return JS_E_ILLEGAL_ASSIGN;
1161
1162     hres = exprval_propget(ctx, &ref, &v);
1163     if(FAILED(hres))
1164         return hres;
1165
1166     return stack_push(ctx, v);
1167 }
1168
1169 /* ECMA-262 3rd Edition    11.2.2 */
1170 static HRESULT interp_new(script_ctx_t *ctx)
1171 {
1172     const unsigned argc = get_op_uint(ctx, 0);
1173     jsval_t constr;
1174
1175     TRACE("%d\n", argc);
1176
1177     constr = stack_topn(ctx, argc);
1178
1179     /* NOTE: Should use to_object here */
1180
1181     if(is_null(constr))
1182         return JS_E_OBJECT_EXPECTED;
1183     else if(!is_object_instance(constr))
1184         return JS_E_INVALID_ACTION;
1185     else if(!get_object(constr))
1186         return JS_E_INVALID_PROPERTY;
1187
1188     clear_acc(ctx);
1189     return disp_call_value(ctx, get_object(constr), NULL, DISPATCH_CONSTRUCT | DISPATCH_JSCRIPT_CALLEREXECSSOURCE,
1190                            argc, stack_args(ctx, argc), &ctx->acc);
1191 }
1192
1193 /* ECMA-262 3rd Edition    11.2.3 */
1194 static HRESULT interp_call(script_ctx_t *ctx)
1195 {
1196     const unsigned argn = get_op_uint(ctx, 0);
1197     const int do_ret = get_op_int(ctx, 1);
1198     jsval_t obj;
1199
1200     TRACE("%d %d\n", argn, do_ret);
1201
1202     obj = stack_topn(ctx, argn);
1203     if(!is_object_instance(obj))
1204         return JS_E_INVALID_PROPERTY;
1205
1206     clear_acc(ctx);
1207     return disp_call_value(ctx, get_object(obj), NULL, DISPATCH_METHOD | DISPATCH_JSCRIPT_CALLEREXECSSOURCE,
1208                            argn, stack_args(ctx, argn), do_ret ? &ctx->acc : NULL);
1209 }
1210
1211 /* ECMA-262 3rd Edition    11.2.3 */
1212 static HRESULT interp_call_member(script_ctx_t *ctx)
1213 {
1214     const unsigned argn = get_op_uint(ctx, 0);
1215     const int do_ret = get_op_int(ctx, 1);
1216     exprval_t ref;
1217
1218     TRACE("%d %d\n", argn, do_ret);
1219
1220     if(!stack_topn_exprval(ctx, argn, &ref))
1221         return ref.u.hres;
1222
1223     clear_acc(ctx);
1224     return exprval_call(ctx, &ref, DISPATCH_METHOD | DISPATCH_JSCRIPT_CALLEREXECSSOURCE,
1225             argn, stack_args(ctx, argn), do_ret ? &ctx->acc : NULL);
1226 }
1227
1228 /* ECMA-262 3rd Edition    11.1.1 */
1229 static HRESULT interp_this(script_ctx_t *ctx)
1230 {
1231     IDispatch *this_obj = ctx->call_ctx->this_obj;
1232
1233     TRACE("\n");
1234
1235     if(!this_obj) {
1236         named_item_t *item = ctx->call_ctx->bytecode->named_item;
1237
1238         if(item)
1239             this_obj = (item->flags & SCRIPTITEM_CODEONLY) ? to_disp(item->script_obj) : item->disp;
1240         else
1241             this_obj = lookup_global_host(ctx);
1242     }
1243
1244     IDispatch_AddRef(this_obj);
1245     return stack_push(ctx, jsval_disp(this_obj));
1246 }
1247
1248 static HRESULT interp_identifier_ref(script_ctx_t *ctx, BSTR identifier, unsigned flags)
1249 {
1250     exprval_t exprval;
1251     HRESULT hres;
1252
1253     hres = identifier_eval(ctx, identifier, &exprval);
1254     if(FAILED(hres))
1255         return hres;
1256
1257     if(exprval.type == EXPRVAL_INVALID && (flags & fdexNameEnsure)) {
1258         jsdisp_t *script_obj = ctx->global;
1259         DISPID id;
1260
1261         if(ctx->call_ctx->bytecode->named_item)
1262             script_obj = ctx->call_ctx->bytecode->named_item->script_obj;
1263
1264         hres = jsdisp_get_id(script_obj, identifier, fdexNameEnsure, &id);
1265         if(FAILED(hres))
1266             return hres;
1267
1268         exprval_set_disp_ref(&exprval, to_disp(script_obj), id);
1269     }
1270
1271     if(exprval.type == EXPRVAL_JSVAL || exprval.type == EXPRVAL_INVALID) {
1272         WARN("invalid ref\n");
1273         exprval_release(&exprval);
1274         exprval_set_exception(&exprval, JS_E_OBJECT_EXPECTED);
1275     }
1276
1277     return stack_push_exprval(ctx, &exprval);
1278 }
1279
1280 static HRESULT identifier_value(script_ctx_t *ctx, BSTR identifier)
1281 {
1282     exprval_t exprval;
1283     jsval_t v;
1284     HRESULT hres;
1285
1286     hres = identifier_eval(ctx, identifier, &exprval);
1287     if(FAILED(hres))
1288         return hres;
1289
1290     if(exprval.type == EXPRVAL_INVALID)
1291         return throw_error(ctx, exprval.u.hres, identifier);
1292
1293     hres = exprval_to_value(ctx, &exprval, &v);
1294     if(FAILED(hres))
1295         return hres;
1296
1297     return stack_push(ctx, v);
1298 }
1299
1300 static HRESULT interp_local_ref(script_ctx_t *ctx)
1301 {
1302     const int arg = get_op_int(ctx, 0);
1303     const unsigned flags = get_op_uint(ctx, 1);
1304     call_frame_t *frame = ctx->call_ctx;
1305     exprval_t ref;
1306
1307     TRACE("%d\n", arg);
1308
1309     if(!frame->base_scope || !frame->base_scope->frame)
1310         return interp_identifier_ref(ctx, local_name(frame, arg), flags);
1311
1312     ref.type = EXPRVAL_STACK_REF;
1313     ref.u.off = local_off(frame, arg);
1314     return stack_push_exprval(ctx, &ref);
1315 }
1316
1317 static HRESULT interp_local(script_ctx_t *ctx)
1318 {
1319     const int arg = get_op_int(ctx, 0);
1320     call_frame_t *frame = ctx->call_ctx;
1321     jsval_t copy;
1322     HRESULT hres;
1323
1324     TRACE("%d: %s\n", arg, debugstr_w(local_name(frame, arg)));
1325
1326     if(!frame->base_scope || !frame->base_scope->frame)
1327         return identifier_value(ctx, local_name(frame, arg));
1328
1329     hres = jsval_copy(ctx->stack[local_off(frame, arg)], &copy);
1330     if(FAILED(hres))
1331         return hres;
1332
1333     return stack_push(ctx, copy);
1334 }
1335
1336 /* ECMA-262 3rd Edition    10.1.4 */
1337 static HRESULT interp_ident(script_ctx_t *ctx)
1338 {
1339     const BSTR arg = get_op_bstr(ctx, 0);
1340
1341     TRACE("%s\n", debugstr_w(arg));
1342
1343     return identifier_value(ctx, arg);
1344 }
1345
1346 /* ECMA-262 3rd Edition    10.1.4 */
1347 static HRESULT interp_identid(script_ctx_t *ctx)
1348 {
1349     const BSTR arg = get_op_bstr(ctx, 0);
1350     const unsigned flags = get_op_uint(ctx, 1);
1351
1352     TRACE("%s %x\n", debugstr_w(arg), flags);
1353
1354     return interp_identifier_ref(ctx, arg, flags);
1355 }
1356
1357 /* ECMA-262 3rd Edition    7.8.1 */
1358 static HRESULT interp_null(script_ctx_t *ctx)
1359 {
1360     TRACE("\n");
1361
1362     return stack_push(ctx, jsval_null());
1363 }
1364
1365 /* ECMA-262 3rd Edition    7.8.2 */
1366 static HRESULT interp_bool(script_ctx_t *ctx)
1367 {
1368     const int arg = get_op_int(ctx, 0);
1369
1370     TRACE("%s\n", arg ? "true" : "false");
1371
1372     return stack_push(ctx, jsval_bool(arg));
1373 }
1374
1375 /* ECMA-262 3rd Edition    7.8.3 */
1376 static HRESULT interp_int(script_ctx_t *ctx)
1377 {
1378     const int arg = get_op_int(ctx, 0);
1379
1380     TRACE("%d\n", arg);
1381
1382     return stack_push(ctx, jsval_number(arg));
1383 }
1384
1385 /* ECMA-262 3rd Edition    7.8.3 */
1386 static HRESULT interp_double(script_ctx_t *ctx)
1387 {
1388     const double arg = get_op_double(ctx);
1389
1390     TRACE("%lf\n", arg);
1391
1392     return stack_push(ctx, jsval_number(arg));
1393 }
1394
1395 /* ECMA-262 3rd Edition    7.8.4 */
1396 static HRESULT interp_str(script_ctx_t *ctx)
1397 {
1398     jsstr_t *str = get_op_str(ctx, 0);
1399
1400     TRACE("%s\n", debugstr_jsstr(str));
1401
1402     return stack_push(ctx, jsval_string(jsstr_addref(str)));
1403 }
1404
1405 /* ECMA-262 3rd Edition    7.8 */
1406 static HRESULT interp_regexp(script_ctx_t *ctx)
1407 {
1408     jsstr_t *source = get_op_str(ctx, 0);
1409     const unsigned flags = get_op_uint(ctx, 1);
1410     jsdisp_t *regexp;
1411     HRESULT hres;
1412
1413     TRACE("%s %x\n", debugstr_jsstr(source), flags);
1414
1415     hres = create_regexp(ctx, source, flags, &regexp);
1416     if(FAILED(hres))
1417         return hres;
1418
1419     return stack_push(ctx, jsval_obj(regexp));
1420 }
1421
1422 /* ECMA-262 3rd Edition    11.1.4 */
1423 static HRESULT interp_carray(script_ctx_t *ctx)
1424 {
1425     const unsigned arg = get_op_uint(ctx, 0);
1426     jsdisp_t *array;
1427     HRESULT hres;
1428
1429     TRACE("%u\n", arg);
1430
1431     hres = create_array(ctx, arg, &array);
1432     if(FAILED(hres))
1433         return hres;
1434
1435     return stack_push(ctx, jsval_obj(array));
1436 }
1437
1438 static HRESULT interp_carray_set(script_ctx_t *ctx)
1439 {
1440     const unsigned index = get_op_uint(ctx, 0);
1441     jsval_t value, array;
1442     HRESULT hres;
1443
1444     value = stack_pop(ctx);
1445
1446     TRACE("[%u] = %s\n", index, debugstr_jsval(value));
1447
1448     array = stack_top(ctx);
1449     assert(is_object_instance(array));
1450
1451     hres = jsdisp_propput_idx(iface_to_jsdisp(get_object(array)), index, value);
1452     jsval_release(value);
1453     return hres;
1454 }
1455
1456 /* ECMA-262 3rd Edition    11.1.5 */
1457 static HRESULT interp_new_obj(script_ctx_t *ctx)
1458 {
1459     jsdisp_t *obj;
1460     HRESULT hres;
1461
1462     TRACE("\n");
1463
1464     hres = create_object(ctx, NULL, &obj);
1465     if(FAILED(hres))
1466         return hres;
1467
1468     return stack_push(ctx, jsval_obj(obj));
1469 }
1470
1471 /* ECMA-262 3rd Edition    11.1.5 */
1472 static HRESULT interp_obj_prop(script_ctx_t *ctx)
1473 {
1474     jsstr_t *name_arg = get_op_str(ctx, 0);
1475     unsigned type = get_op_uint(ctx, 1);
1476     const WCHAR *name;
1477     jsdisp_t *obj;
1478     jsval_t val;
1479     HRESULT hres;
1480
1481     TRACE("%s\n", debugstr_jsstr(name_arg));
1482
1483     val = stack_pop(ctx);
1484
1485     /* FIXME: we should pass it as jsstr_t */
1486     name = jsstr_flatten(name_arg);
1487
1488     assert(is_object_instance(stack_top(ctx)));
1489     obj = as_jsdisp(get_object(stack_top(ctx)));
1490
1491     if(type == PROPERTY_DEFINITION_VALUE) {
1492         hres = jsdisp_propput_name(obj, name, val);
1493     }else {
1494         property_desc_t desc = {PROPF_ENUMERABLE | PROPF_CONFIGURABLE};
1495         jsdisp_t *func;
1496
1497         assert(is_object_instance(val));
1498         func = iface_to_jsdisp(get_object(val));
1499
1500         desc.mask = desc.flags;
1501         if(type == PROPERTY_DEFINITION_GETTER) {
1502             desc.explicit_getter = TRUE;
1503             desc.getter = func;
1504         }else {
1505             desc.explicit_setter = TRUE;
1506             desc.setter = func;
1507         }
1508
1509         hres = jsdisp_define_property(obj, name, &desc);
1510         jsdisp_release(func);
1511     }
1512
1513     jsval_release(val);
1514     return hres;
1515 }
1516
1517 /* ECMA-262 3rd Edition    11.11 */
1518 static HRESULT interp_cnd_nz(script_ctx_t *ctx)
1519 {
1520     const unsigned arg = get_op_uint(ctx, 0);
1521     BOOL b;
1522     HRESULT hres;
1523
1524     TRACE("\n");
1525
1526     hres = to_boolean(stack_top(ctx), &b);
1527     if(FAILED(hres))
1528         return hres;
1529
1530     if(b) {
1531         jmp_abs(ctx, arg);
1532     }else {
1533         stack_popn(ctx, 1);
1534         jmp_next(ctx);
1535     }
1536     return S_OK;
1537 }
1538
1539 /* ECMA-262 3rd Edition    11.11 */
1540 static HRESULT interp_cnd_z(script_ctx_t *ctx)
1541 {
1542     const unsigned arg = get_op_uint(ctx, 0);
1543     BOOL b;
1544     HRESULT hres;
1545
1546     TRACE("\n");
1547
1548     hres = to_boolean(stack_top(ctx), &b);
1549     if(FAILED(hres))
1550         return hres;
1551
1552     if(b) {
1553         stack_popn(ctx, 1);
1554         jmp_next(ctx);
1555     }else {
1556         jmp_abs(ctx, arg);
1557     }
1558     return S_OK;
1559 }
1560
1561 /* ECMA-262 3rd Edition    11.10 */
1562 static HRESULT interp_or(script_ctx_t *ctx)
1563 {
1564     INT l, r;
1565     HRESULT hres;
1566
1567     TRACE("\n");
1568
1569     hres = stack_pop_int(ctx, &r);
1570     if(FAILED(hres))
1571         return hres;
1572
1573     hres = stack_pop_int(ctx, &l);
1574     if(FAILED(hres))
1575         return hres;
1576
1577     return stack_push(ctx, jsval_number(l|r));
1578 }
1579
1580 /* ECMA-262 3rd Edition    11.10 */
1581 static HRESULT interp_xor(script_ctx_t *ctx)
1582 {
1583     INT l, r;
1584     HRESULT hres;
1585
1586     TRACE("\n");
1587
1588     hres = stack_pop_int(ctx, &r);
1589     if(FAILED(hres))
1590         return hres;
1591
1592     hres = stack_pop_int(ctx, &l);
1593     if(FAILED(hres))
1594         return hres;
1595
1596     return stack_push(ctx, jsval_number(l^r));
1597 }
1598
1599 /* ECMA-262 3rd Edition    11.10 */
1600 static HRESULT interp_and(script_ctx_t *ctx)
1601 {
1602     INT l, r;
1603     HRESULT hres;
1604
1605     TRACE("\n");
1606
1607     hres = stack_pop_int(ctx, &r);
1608     if(FAILED(hres))
1609         return hres;
1610
1611     hres = stack_pop_int(ctx, &l);
1612     if(FAILED(hres))
1613         return hres;
1614
1615     return stack_push(ctx, jsval_number(l&r));
1616 }
1617
1618 /* ECMA-262 3rd Edition    11.8.6 */
1619 static HRESULT interp_instanceof(script_ctx_t *ctx)
1620 {
1621     jsdisp_t *obj, *iter, *tmp = NULL;
1622     jsval_t prot, v;
1623     BOOL ret = FALSE;
1624     HRESULT hres;
1625
1626     v = stack_pop(ctx);
1627     if(!is_object_instance(v) || !get_object(v)) {
1628         jsval_release(v);
1629         return JS_E_FUNCTION_EXPECTED;
1630     }
1631
1632     obj = iface_to_jsdisp(get_object(v));
1633     IDispatch_Release(get_object(v));
1634     if(!obj) {
1635         FIXME("non-jsdisp objects not supported\n");
1636         return E_FAIL;
1637     }
1638
1639     if(is_class(obj, JSCLASS_FUNCTION)) {
1640         hres = jsdisp_propget_name(obj, L"prototype", &prot);
1641     }else {
1642         hres = JS_E_FUNCTION_EXPECTED;
1643     }
1644     jsdisp_release(obj);
1645     if(FAILED(hres))
1646         return hres;
1647
1648     v = stack_pop(ctx);
1649
1650     if(is_object_instance(prot)) {
1651         if(is_object_instance(v))
1652             tmp = iface_to_jsdisp(get_object(v));
1653         for(iter = tmp; !ret && iter; iter = iter->prototype) {
1654             hres = disp_cmp(get_object(prot), to_disp(iter), &ret);
1655             if(FAILED(hres))
1656                 break;
1657         }
1658
1659         if(tmp)
1660             jsdisp_release(tmp);
1661     }else {
1662         FIXME("prototype is not an object\n");
1663         hres = E_FAIL;
1664     }
1665
1666     jsval_release(prot);
1667     jsval_release(v);
1668     if(FAILED(hres))
1669         return hres;
1670
1671     return stack_push(ctx, jsval_bool(ret));
1672 }
1673
1674 /* ECMA-262 3rd Edition    11.8.7 */
1675 static HRESULT interp_in(script_ctx_t *ctx)
1676 {
1677     const WCHAR *str;
1678     jsstr_t *jsstr;
1679     jsval_t obj, v;
1680     DISPID id = 0;
1681     BOOL ret;
1682     HRESULT hres;
1683
1684     TRACE("\n");
1685
1686     obj = stack_pop(ctx);
1687     if(!is_object_instance(obj) || !get_object(obj)) {
1688         jsval_release(obj);
1689         return JS_E_OBJECT_EXPECTED;
1690     }
1691
1692     v = stack_pop(ctx);
1693     hres = to_flat_string(ctx, v, &jsstr, &str);
1694     jsval_release(v);
1695     if(FAILED(hres)) {
1696         IDispatch_Release(get_object(obj));
1697         return hres;
1698     }
1699
1700     hres = disp_get_id(ctx, get_object(obj), str, NULL, 0, &id);
1701     IDispatch_Release(get_object(obj));
1702     jsstr_release(jsstr);
1703     if(SUCCEEDED(hres))
1704         ret = TRUE;
1705     else if(hres == DISP_E_UNKNOWNNAME)
1706         ret = FALSE;
1707     else
1708         return hres;
1709
1710     return stack_push(ctx, jsval_bool(ret));
1711 }
1712
1713 /* ECMA-262 3rd Edition    11.6.1 */
1714 static HRESULT interp_add(script_ctx_t *ctx)
1715 {
1716     jsval_t l, r, lval, rval, ret;
1717     HRESULT hres;
1718
1719     rval = stack_pop(ctx);
1720     lval = stack_pop(ctx);
1721
1722     TRACE("%s + %s\n", debugstr_jsval(lval), debugstr_jsval(rval));
1723
1724     hres = to_primitive(ctx, lval, &l, NO_HINT);
1725     if(SUCCEEDED(hres)) {
1726         hres = to_primitive(ctx, rval, &r, NO_HINT);
1727         if(FAILED(hres))
1728             jsval_release(l);
1729     }
1730     jsval_release(lval);
1731     jsval_release(rval);
1732     if(FAILED(hres))
1733         return hres;
1734
1735     if(is_string(l) || is_string(r)) {
1736         jsstr_t *lstr, *rstr = NULL;
1737
1738         hres = to_string(ctx, l, &lstr);
1739         if(SUCCEEDED(hres))
1740             hres = to_string(ctx, r, &rstr);
1741
1742         if(SUCCEEDED(hres)) {
1743             jsstr_t *ret_str;
1744
1745             ret_str = jsstr_concat(lstr, rstr);
1746             if(ret_str)
1747                 ret = jsval_string(ret_str);
1748             else
1749                 hres = E_OUTOFMEMORY;
1750         }
1751
1752         jsstr_release(lstr);
1753         if(rstr)
1754             jsstr_release(rstr);
1755     }else {
1756         double nl, nr;
1757
1758         hres = to_number(ctx, l, &nl);
1759         if(SUCCEEDED(hres)) {
1760             hres = to_number(ctx, r, &nr);
1761             if(SUCCEEDED(hres))
1762                 ret = jsval_number(nl+nr);
1763         }
1764     }
1765
1766     jsval_release(r);
1767     jsval_release(l);
1768     if(FAILED(hres))
1769         return hres;
1770
1771     return stack_push(ctx, ret);
1772 }
1773
1774 /* ECMA-262 3rd Edition    11.6.2 */
1775 static HRESULT interp_sub(script_ctx_t *ctx)
1776 {
1777     double l, r;
1778     HRESULT hres;
1779
1780     TRACE("\n");
1781
1782     hres = stack_pop_number(ctx, &r);
1783     if(FAILED(hres))
1784         return hres;
1785
1786     hres = stack_pop_number(ctx, &l);
1787     if(FAILED(hres))
1788         return hres;
1789
1790     return stack_push(ctx, jsval_number(l-r));
1791 }
1792
1793 /* ECMA-262 3rd Edition    11.5.1 */
1794 static HRESULT interp_mul(script_ctx_t *ctx)
1795 {
1796     double l, r;
1797     HRESULT hres;
1798
1799     TRACE("\n");
1800
1801     hres = stack_pop_number(ctx, &r);
1802     if(FAILED(hres))
1803         return hres;
1804
1805     hres = stack_pop_number(ctx, &l);
1806     if(FAILED(hres))
1807         return hres;
1808
1809     return stack_push(ctx, jsval_number(l*r));
1810 }
1811
1812 /* ECMA-262 3rd Edition    11.5.2 */
1813 static HRESULT interp_div(script_ctx_t *ctx)
1814 {
1815     double l, r;
1816     HRESULT hres;
1817
1818     TRACE("\n");
1819
1820     hres = stack_pop_number(ctx, &r);
1821     if(FAILED(hres))
1822         return hres;
1823
1824     hres = stack_pop_number(ctx, &l);
1825     if(FAILED(hres))
1826         return hres;
1827
1828     return stack_push(ctx, jsval_number(l/r));
1829 }
1830
1831 /* ECMA-262 3rd Edition    11.5.3 */
1832 static HRESULT interp_mod(script_ctx_t *ctx)
1833 {
1834     double l, r;
1835     HRESULT hres;
1836
1837     TRACE("\n");
1838
1839     hres = stack_pop_number(ctx, &r);
1840     if(FAILED(hres))
1841         return hres;
1842
1843     hres = stack_pop_number(ctx, &l);
1844     if(FAILED(hres))
1845         return hres;
1846
1847     return stack_push(ctx, jsval_number(fmod(l, r)));
1848 }
1849
1850 /* ECMA-262 3rd Edition    11.4.2 */
1851 static HRESULT interp_delete(script_ctx_t *ctx)
1852 {
1853     jsval_t objv, namev;
1854     IDispatch *obj;
1855     jsstr_t *name;
1856     BOOL ret;
1857     HRESULT hres;
1858
1859     TRACE("\n");
1860
1861     namev = stack_pop(ctx);
1862     objv = stack_pop(ctx);
1863
1864     hres = to_object(ctx, objv, &obj);
1865     jsval_release(objv);
1866     if(FAILED(hres)) {
1867         jsval_release(namev);
1868         return hres;
1869     }
1870
1871     hres = to_string(ctx, namev, &name);
1872     jsval_release(namev);
1873     if(FAILED(hres)) {
1874         IDispatch_Release(obj);
1875         return hres;
1876     }
1877
1878     hres = disp_delete_name(ctx, obj, name, &ret);
1879     IDispatch_Release(obj);
1880     jsstr_release(name);
1881     if(FAILED(hres))
1882         return hres;
1883
1884     return stack_push(ctx, jsval_bool(ret));
1885 }
1886
1887 /* ECMA-262 3rd Edition    11.4.2 */
1888 static HRESULT interp_delete_ident(script_ctx_t *ctx)
1889 {
1890     const BSTR arg = get_op_bstr(ctx, 0);
1891     exprval_t exprval;
1892     BOOL ret;
1893     HRESULT hres;
1894
1895     TRACE("%s\n", debugstr_w(arg));
1896
1897     hres = identifier_eval(ctx, arg, &exprval);
1898     if(FAILED(hres))
1899         return hres;
1900
1901     switch(exprval.type) {
1902     case EXPRVAL_STACK_REF:
1903         ret = FALSE;
1904         break;
1905     case EXPRVAL_IDREF:
1906         hres = disp_delete(exprval.u.idref.disp, exprval.u.idref.id, &ret);
1907         IDispatch_Release(exprval.u.idref.disp);
1908         if(FAILED(hres))
1909             return hres;
1910         break;
1911     case EXPRVAL_INVALID:
1912         ret = TRUE;
1913         break;
1914     default:
1915         FIXME("Unsupported exprval\n");
1916         exprval_release(&exprval);
1917         return E_NOTIMPL;
1918     }
1919
1920
1921     return stack_push(ctx, jsval_bool(ret));
1922 }
1923
1924 /* ECMA-262 3rd Edition    11.4.2 */
1925 static HRESULT interp_void(script_ctx_t *ctx)
1926 {
1927     TRACE("\n");
1928
1929     stack_popn(ctx, 1);
1930     return stack_push(ctx, jsval_undefined());
1931 }
1932
1933 /* ECMA-262 3rd Edition    11.4.3 */
1934 static HRESULT typeof_string(jsval_t v, const WCHAR **ret)
1935 {
1936     switch(jsval_type(v)) {
1937     case JSV_UNDEFINED:
1938         *ret = L"undefined";
1939         break;
1940     case JSV_NULL:
1941         *ret = L"object";
1942         break;
1943     case JSV_OBJECT: {
1944         jsdisp_t *dispex;
1945
1946         if(get_object(v) && (dispex = iface_to_jsdisp(get_object(v)))) {
1947             *ret = is_class(dispex, JSCLASS_FUNCTION) ? L"function" : L"object";
1948             jsdisp_release(dispex);
1949         }else {
1950             *ret = L"object";
1951         }
1952         break;
1953     }
1954     case JSV_STRING:
1955         *ret = L"string";
1956         break;
1957     case JSV_NUMBER:
1958         *ret = L"number";
1959         break;
1960     case JSV_BOOL:
1961         *ret = L"boolean";
1962         break;
1963     case JSV_VARIANT:
1964         FIXME("unhandled variant %s\n", debugstr_variant(get_variant(v)));
1965         return E_NOTIMPL;
1966     }
1967
1968     return S_OK;
1969 }
1970
1971 /* ECMA-262 3rd Edition    11.4.3 */
1972 static HRESULT interp_typeofid(script_ctx_t *ctx)
1973 {
1974     const WCHAR *ret;
1975     exprval_t ref;
1976     jsval_t v;
1977     HRESULT hres;
1978
1979     TRACE("\n");
1980
1981     if(!stack_pop_exprval(ctx, &ref))
1982         return stack_push(ctx, jsval_string(jsstr_undefined()));
1983
1984     hres = exprval_propget(ctx, &ref, &v);
1985     exprval_release(&ref);
1986     if(FAILED(hres))
1987         return stack_push_string(ctx, L"unknown");
1988
1989     hres = typeof_string(v, &ret);
1990     jsval_release(v);
1991     if(FAILED(hres))
1992         return hres;
1993
1994     return stack_push_string(ctx, ret);
1995 }
1996
1997 /* ECMA-262 3rd Edition    11.4.3 */
1998 static HRESULT interp_typeofident(script_ctx_t *ctx)
1999 {
2000     const BSTR arg = get_op_bstr(ctx, 0);
2001     exprval_t exprval;
2002     const WCHAR *ret;
2003     jsval_t v;
2004     HRESULT hres;
2005
2006     TRACE("%s\n", debugstr_w(arg));
2007
2008     hres = identifier_eval(ctx, arg, &exprval);
2009     if(FAILED(hres))
2010         return hres;
2011
2012     if(exprval.type == EXPRVAL_INVALID)
2013         return stack_push(ctx, jsval_string(jsstr_undefined()));
2014
2015     hres = exprval_to_value(ctx, &exprval, &v);
2016     if(FAILED(hres))
2017         return hres;
2018
2019     hres = typeof_string(v, &ret);
2020     jsval_release(v);
2021     if(FAILED(hres))
2022         return hres;
2023
2024     return stack_push_string(ctx, ret);
2025 }
2026
2027 /* ECMA-262 3rd Edition    11.4.3 */
2028 static HRESULT interp_typeof(script_ctx_t *ctx)
2029 {
2030     const WCHAR *ret;
2031     jsval_t v;
2032     HRESULT hres;
2033
2034     TRACE("\n");
2035
2036     v = stack_pop(ctx);
2037     hres = typeof_string(v, &ret);
2038     jsval_release(v);
2039     if(FAILED(hres))
2040         return hres;
2041
2042     return stack_push_string(ctx, ret);
2043 }
2044
2045 /* ECMA-262 3rd Edition    11.4.7 */
2046 static HRESULT interp_minus(script_ctx_t *ctx)
2047 {
2048     double n;
2049     HRESULT hres;
2050
2051     TRACE("\n");
2052
2053     hres = stack_pop_number(ctx, &n);
2054     if(FAILED(hres))
2055         return hres;
2056
2057     return stack_push(ctx, jsval_number(-n));
2058 }
2059
2060 /* ECMA-262 3rd Edition    11.4.6 */
2061 static HRESULT interp_tonum(script_ctx_t *ctx)
2062 {
2063     jsval_t v;
2064     double n;
2065     HRESULT hres;
2066
2067     TRACE("\n");
2068
2069     v = stack_pop(ctx);
2070     hres = to_number(ctx, v, &n);
2071     jsval_release(v);
2072     if(FAILED(hres))
2073         return hres;
2074
2075     return stack_push(ctx, jsval_number(n));
2076 }
2077
2078 /* ECMA-262 3rd Edition    11.3.1 */
2079 static HRESULT interp_postinc(script_ctx_t *ctx)
2080 {
2081     const int arg = get_op_int(ctx, 0);
2082     exprval_t ref;
2083     jsval_t v;
2084     HRESULT hres;
2085
2086     TRACE("%d\n", arg);
2087
2088     if(!stack_pop_exprval(ctx, &ref))
2089         return JS_E_OBJECT_EXPECTED;
2090
2091     hres = exprval_propget(ctx, &ref, &v);
2092     if(SUCCEEDED(hres)) {
2093         double n;
2094
2095         hres = to_number(ctx, v, &n);
2096         if(SUCCEEDED(hres))
2097             hres = exprval_propput(ctx, &ref, jsval_number(n+(double)arg));
2098         if(FAILED(hres))
2099             jsval_release(v);
2100     }
2101     exprval_release(&ref);
2102     if(FAILED(hres))
2103         return hres;
2104
2105     return stack_push(ctx, v);
2106 }
2107
2108 /* ECMA-262 3rd Edition    11.4.4, 11.4.5 */
2109 static HRESULT interp_preinc(script_ctx_t *ctx)
2110 {
2111     const int arg = get_op_int(ctx, 0);
2112     exprval_t ref;
2113     double ret;
2114     jsval_t v;
2115     HRESULT hres;
2116
2117     TRACE("%d\n", arg);
2118
2119     if(!stack_pop_exprval(ctx, &ref))
2120         return JS_E_OBJECT_EXPECTED;
2121
2122     hres = exprval_propget(ctx, &ref, &v);
2123     if(SUCCEEDED(hres)) {
2124         double n;
2125
2126         hres = to_number(ctx, v, &n);
2127         jsval_release(v);
2128         if(SUCCEEDED(hres)) {
2129             ret = n+(double)arg;
2130             hres = exprval_propput(ctx, &ref, jsval_number(ret));
2131         }
2132     }
2133     exprval_release(&ref);
2134     if(FAILED(hres))
2135         return hres;
2136
2137     return stack_push(ctx, jsval_number(ret));
2138 }
2139
2140 /* ECMA-262 3rd Edition    11.9.3 */
2141 static HRESULT equal_values(script_ctx_t *ctx, jsval_t lval, jsval_t rval, BOOL *ret)
2142 {
2143     if(jsval_type(lval) == jsval_type(rval) || (is_number(lval) && is_number(rval)))
2144        return jsval_strict_equal(lval, rval, ret);
2145
2146     /* FIXME: NULL disps should be handled in more general way */
2147     if(is_object_instance(lval) && !get_object(lval))
2148         return equal_values(ctx, jsval_null(), rval, ret);
2149     if(is_object_instance(rval) && !get_object(rval))
2150         return equal_values(ctx, lval, jsval_null(), ret);
2151
2152     if((is_null(lval) && is_undefined(rval)) || (is_undefined(lval) && is_null(rval))) {
2153         *ret = TRUE;
2154         return S_OK;
2155     }
2156
2157     if(is_string(lval) && is_number(rval)) {
2158         double n;
2159         HRESULT hres;
2160
2161         hres = to_number(ctx, lval, &n);
2162         if(FAILED(hres))
2163             return hres;
2164
2165         /* FIXME: optimize */
2166         return equal_values(ctx, jsval_number(n), rval, ret);
2167     }
2168
2169     if(is_string(rval) && is_number(lval)) {
2170         double n;
2171         HRESULT hres;
2172
2173         hres = to_number(ctx, rval, &n);
2174         if(FAILED(hres))
2175             return hres;
2176
2177         /* FIXME: optimize */
2178         return equal_values(ctx, lval, jsval_number(n), ret);
2179     }
2180
2181     if(is_bool(rval))
2182         return equal_values(ctx, lval, jsval_number(get_bool(rval) ? 1 : 0), ret);
2183
2184     if(is_bool(lval))
2185         return equal_values(ctx, jsval_number(get_bool(lval) ? 1 : 0), rval, ret);
2186
2187
2188     if(is_object_instance(rval) && (is_string(lval) || is_number(lval))) {
2189         jsval_t prim;
2190         HRESULT hres;
2191
2192         hres = to_primitive(ctx, rval, &prim, NO_HINT);
2193         if(FAILED(hres))
2194             return hres;
2195
2196         hres = equal_values(ctx, lval, prim, ret);
2197         jsval_release(prim);
2198         return hres;
2199     }
2200
2201
2202     if(is_object_instance(lval) && (is_string(rval) || is_number(rval))) {
2203         jsval_t prim;
2204         HRESULT hres;
2205
2206         hres = to_primitive(ctx, lval, &prim, NO_HINT);
2207         if(FAILED(hres))
2208             return hres;
2209
2210         hres = equal_values(ctx, prim, rval, ret);
2211         jsval_release(prim);
2212         return hres;
2213     }
2214
2215
2216     *ret = FALSE;
2217     return S_OK;
2218 }
2219
2220 /* ECMA-262 3rd Edition    11.9.1 */
2221 static HRESULT interp_eq(script_ctx_t *ctx)
2222 {
2223     jsval_t l, r;
2224     BOOL b;
2225     HRESULT hres;
2226
2227     r = stack_pop(ctx);
2228     l = stack_pop(ctx);
2229
2230     TRACE("%s == %s\n", debugstr_jsval(l), debugstr_jsval(r));
2231
2232     hres = equal_values(ctx, l, r, &b);
2233     jsval_release(l);
2234     jsval_release(r);
2235     if(FAILED(hres))
2236         return hres;
2237
2238     return stack_push(ctx, jsval_bool(b));
2239 }
2240
2241 /* ECMA-262 3rd Edition    11.9.2 */
2242 static HRESULT interp_neq(script_ctx_t *ctx)
2243 {
2244     jsval_t l, r;
2245     BOOL b;
2246     HRESULT hres;
2247
2248     r = stack_pop(ctx);
2249     l = stack_pop(ctx);
2250
2251     TRACE("%s != %s\n", debugstr_jsval(l), debugstr_jsval(r));
2252
2253     hres = equal_values(ctx, l, r, &b);
2254     jsval_release(l);
2255     jsval_release(r);
2256     if(FAILED(hres))
2257         return hres;
2258
2259     return stack_push(ctx, jsval_bool(!b));
2260 }
2261
2262 /* ECMA-262 3rd Edition    11.9.4 */
2263 static HRESULT interp_eq2(script_ctx_t *ctx)
2264 {
2265     jsval_t l, r;
2266     BOOL b;
2267     HRESULT hres;
2268
2269     r = stack_pop(ctx);
2270     l = stack_pop(ctx);
2271
2272     TRACE("%s === %s\n", debugstr_jsval(l), debugstr_jsval(r));
2273
2274     hres = jsval_strict_equal(r, l, &b);
2275     jsval_release(l);
2276     jsval_release(r);
2277     if(FAILED(hres))
2278         return hres;
2279
2280     return stack_push(ctx, jsval_bool(b));
2281 }
2282
2283 /* ECMA-262 3rd Edition    11.9.5 */
2284 static HRESULT interp_neq2(script_ctx_t *ctx)
2285 {
2286     jsval_t l, r;
2287     BOOL b;
2288     HRESULT hres;
2289
2290     TRACE("\n");
2291
2292     r = stack_pop(ctx);
2293     l = stack_pop(ctx);
2294
2295     hres = jsval_strict_equal(r, l, &b);
2296     jsval_release(l);
2297     jsval_release(r);
2298     if(FAILED(hres))
2299         return hres;
2300
2301     return stack_push(ctx, jsval_bool(!b));
2302 }
2303
2304 /* ECMA-262 3rd Edition    11.8.5 */
2305 static HRESULT less_eval(script_ctx_t *ctx, jsval_t lval, jsval_t rval, BOOL greater, BOOL *ret)
2306 {
2307     double ln, rn;
2308     jsval_t l, r;
2309     HRESULT hres;
2310
2311     hres = to_primitive(ctx, lval, &l, NO_HINT);
2312     if(FAILED(hres))
2313         return hres;
2314
2315     hres = to_primitive(ctx, rval, &r, NO_HINT);
2316     if(FAILED(hres)) {
2317         jsval_release(l);
2318         return hres;
2319     }
2320
2321     if(is_string(l) && is_string(r)) {
2322         *ret = (jsstr_cmp(get_string(l), get_string(r)) < 0) ^ greater;
2323         jsstr_release(get_string(l));
2324         jsstr_release(get_string(r));
2325         return S_OK;
2326     }
2327
2328     hres = to_number(ctx, l, &ln);
2329     jsval_release(l);
2330     if(SUCCEEDED(hres))
2331         hres = to_number(ctx, r, &rn);
2332     jsval_release(r);
2333     if(FAILED(hres))
2334         return hres;
2335
2336     *ret = !isnan(ln) && !isnan(rn) && ((ln < rn) ^ greater);
2337     return S_OK;
2338 }
2339
2340 /* ECMA-262 3rd Edition    11.8.1 */
2341 static HRESULT interp_lt(script_ctx_t *ctx)
2342 {
2343     jsval_t l, r;
2344     BOOL b;
2345     HRESULT hres;
2346
2347     r = stack_pop(ctx);
2348     l = stack_pop(ctx);
2349
2350     TRACE("%s < %s\n", debugstr_jsval(l), debugstr_jsval(r));
2351
2352     hres = less_eval(ctx, l, r, FALSE, &b);
2353     jsval_release(l);
2354     jsval_release(r);
2355     if(FAILED(hres))
2356         return hres;
2357
2358     return stack_push(ctx, jsval_bool(b));
2359 }
2360
2361 /* ECMA-262 3rd Edition    11.8.1 */
2362 static HRESULT interp_lteq(script_ctx_t *ctx)
2363 {
2364     jsval_t l, r;
2365     BOOL b;
2366     HRESULT hres;
2367
2368     r = stack_pop(ctx);
2369     l = stack_pop(ctx);
2370
2371     TRACE("%s <= %s\n", debugstr_jsval(l), debugstr_jsval(r));
2372
2373     hres = less_eval(ctx, r, l, TRUE, &b);
2374     jsval_release(l);
2375     jsval_release(r);
2376     if(FAILED(hres))
2377         return hres;
2378
2379     return stack_push(ctx, jsval_bool(b));
2380 }
2381
2382 /* ECMA-262 3rd Edition    11.8.2 */
2383 static HRESULT interp_gt(script_ctx_t *ctx)
2384 {
2385     jsval_t l, r;
2386     BOOL b;
2387     HRESULT hres;
2388
2389     r = stack_pop(ctx);
2390     l = stack_pop(ctx);
2391
2392     TRACE("%s > %s\n", debugstr_jsval(l), debugstr_jsval(r));
2393
2394     hres = less_eval(ctx, r, l, FALSE, &b);
2395     jsval_release(l);
2396     jsval_release(r);
2397     if(FAILED(hres))
2398         return hres;
2399
2400     return stack_push(ctx, jsval_bool(b));
2401 }
2402
2403 /* ECMA-262 3rd Edition    11.8.4 */
2404 static HRESULT interp_gteq(script_ctx_t *ctx)
2405 {
2406     jsval_t l, r;
2407     BOOL b;
2408     HRESULT hres;
2409
2410     r = stack_pop(ctx);
2411     l = stack_pop(ctx);
2412
2413     TRACE("%s >= %s\n", debugstr_jsval(l), debugstr_jsval(r));
2414
2415     hres = less_eval(ctx, l, r, TRUE, &b);
2416     jsval_release(l);
2417     jsval_release(r);
2418     if(FAILED(hres))
2419         return hres;
2420
2421     return stack_push(ctx, jsval_bool(b));
2422 }
2423
2424 /* ECMA-262 3rd Edition    11.4.8 */
2425 static HRESULT interp_bneg(script_ctx_t *ctx)
2426 {
2427     jsval_t v;
2428     INT i;
2429     HRESULT hres;
2430
2431     TRACE("\n");
2432
2433     v = stack_pop(ctx);
2434     hres = to_int32(ctx, v, &i);
2435     jsval_release(v);
2436     if(FAILED(hres))
2437         return hres;
2438
2439     return stack_push(ctx, jsval_number(~i));
2440 }
2441
2442 /* ECMA-262 3rd Edition    11.4.9 */
2443 static HRESULT interp_neg(script_ctx_t *ctx)
2444 {
2445     jsval_t v;
2446     BOOL b;
2447     HRESULT hres;
2448
2449     TRACE("\n");
2450
2451     v = stack_pop(ctx);
2452     hres = to_boolean(v, &b);
2453     jsval_release(v);
2454     if(FAILED(hres))
2455         return hres;
2456
2457     return stack_push(ctx, jsval_bool(!b));
2458 }
2459
2460 /* ECMA-262 3rd Edition    11.7.1 */
2461 static HRESULT interp_lshift(script_ctx_t *ctx)
2462 {
2463     DWORD r;
2464     INT l;
2465     HRESULT hres;
2466
2467     hres = stack_pop_uint(ctx, &r);
2468     if(FAILED(hres))
2469         return hres;
2470
2471     hres = stack_pop_int(ctx, &l);
2472     if(FAILED(hres))
2473         return hres;
2474
2475     return stack_push(ctx, jsval_number(l << (r&0x1f)));
2476 }
2477
2478 /* ECMA-262 3rd Edition    11.7.2 */
2479 static HRESULT interp_rshift(script_ctx_t *ctx)
2480 {
2481     DWORD r;
2482     INT l;
2483     HRESULT hres;
2484
2485     hres = stack_pop_uint(ctx, &r);
2486     if(FAILED(hres))
2487         return hres;
2488
2489     hres = stack_pop_int(ctx, &l);
2490     if(FAILED(hres))
2491         return hres;
2492
2493     return stack_push(ctx, jsval_number(l >> (r&0x1f)));
2494 }
2495
2496 /* ECMA-262 3rd Edition    11.7.3 */
2497 static HRESULT interp_rshift2(script_ctx_t *ctx)
2498 {
2499     DWORD r, l;
2500     HRESULT hres;
2501
2502     hres = stack_pop_uint(ctx, &r);
2503     if(FAILED(hres))
2504         return hres;
2505
2506     hres = stack_pop_uint(ctx, &l);
2507     if(FAILED(hres))
2508         return hres;
2509
2510     return stack_push(ctx, jsval_number(l >> (r&0x1f)));
2511 }
2512
2513 /* ECMA-262 3rd Edition    11.13.1 */
2514 static HRESULT interp_assign(script_ctx_t *ctx)
2515 {
2516     exprval_t ref;
2517     jsval_t v;
2518     HRESULT hres;
2519
2520     TRACE("\n");
2521
2522     v = stack_pop(ctx);
2523
2524     if(!stack_pop_exprval(ctx, &ref)) {
2525         jsval_release(v);
2526         return JS_E_ILLEGAL_ASSIGN;
2527     }
2528
2529     hres = exprval_propput(ctx, &ref, v);
2530     exprval_release(&ref);
2531     if(FAILED(hres)) {
2532         jsval_release(v);
2533         return hres;
2534     }
2535
2536     return stack_push(ctx, v);
2537 }
2538
2539 /* JScript extension */
2540 static HRESULT interp_assign_call(script_ctx_t *ctx)
2541 {
2542     const unsigned argc = get_op_uint(ctx, 0);
2543     exprval_t ref;
2544     jsval_t v;
2545     HRESULT hres;
2546
2547     TRACE("%u\n", argc);
2548
2549     if(!stack_topn_exprval(ctx, argc+1, &ref))
2550         return JS_E_ILLEGAL_ASSIGN;
2551
2552     hres = exprval_call(ctx, &ref, DISPATCH_PROPERTYPUT, argc+1, stack_args(ctx, argc+1), NULL);
2553     if(FAILED(hres))
2554         return hres;
2555
2556     v = stack_pop(ctx);
2557     stack_popn(ctx, argc+2);
2558     return stack_push(ctx, v);
2559 }
2560
2561 static HRESULT interp_undefined(script_ctx_t *ctx)
2562 {
2563     TRACE("\n");
2564
2565     return stack_push(ctx, jsval_undefined());
2566 }
2567
2568 static HRESULT interp_jmp(script_ctx_t *ctx)
2569 {
2570     const unsigned arg = get_op_uint(ctx, 0);
2571
2572     TRACE("%u\n", arg);
2573
2574     jmp_abs(ctx, arg);
2575     return S_OK;
2576 }
2577
2578 static HRESULT interp_jmp_z(script_ctx_t *ctx)
2579 {
2580     const unsigned arg = get_op_uint(ctx, 0);
2581     BOOL b;
2582     jsval_t v;
2583     HRESULT hres;
2584
2585     TRACE("\n");
2586
2587     v = stack_pop(ctx);
2588     hres = to_boolean(v, &b);
2589     jsval_release(v);
2590     if(FAILED(hres))
2591         return hres;
2592
2593     if(b)
2594         jmp_next(ctx);
2595     else
2596         jmp_abs(ctx, arg);
2597     return S_OK;
2598 }
2599
2600 static HRESULT interp_pop(script_ctx_t *ctx)
2601 {
2602     const unsigned arg = get_op_uint(ctx, 0);
2603
2604     TRACE("%u\n", arg);
2605
2606     stack_popn(ctx, arg);
2607     return S_OK;
2608 }
2609
2610 static HRESULT interp_ret(script_ctx_t *ctx)
2611 {
2612     const unsigned clear_ret = get_op_uint(ctx, 0);
2613     call_frame_t *frame = ctx->call_ctx;
2614
2615     TRACE("\n");
2616
2617     if(clear_ret)
2618         jsval_release(steal_ret(frame));
2619
2620     if((frame->flags & EXEC_CONSTRUCTOR) && !is_object_instance(frame->ret)) {
2621         jsval_release(frame->ret);
2622         IDispatch_AddRef(frame->this_obj);
2623         frame->ret = jsval_disp(frame->this_obj);
2624     }
2625
2626     jmp_abs(ctx, -1);
2627     return S_OK;
2628 }
2629
2630 static HRESULT interp_setret(script_ctx_t *ctx)
2631 {
2632     call_frame_t *frame = ctx->call_ctx;
2633
2634     TRACE("\n");
2635
2636     jsval_release(frame->ret);
2637     frame->ret = stack_pop(ctx);
2638     return S_OK;
2639 }
2640
2641 static HRESULT interp_push_acc(script_ctx_t *ctx)
2642 {
2643     HRESULT hres;
2644
2645     TRACE("\n");
2646
2647     hres = stack_push(ctx, ctx->acc);
2648     if(SUCCEEDED(hres))
2649         ctx->acc = jsval_undefined();
2650     return hres;
2651 }
2652
2653 typedef HRESULT (*op_func_t)(script_ctx_t*);
2654
2655 static const op_func_t op_funcs[] = {
2656 #define X(x,a,b,c) interp_##x,
2657 OP_LIST
2658 #undef X
2659 };
2660
2661 static const unsigned op_move[] = {
2662 #define X(a,x,b,c) x,
2663 OP_LIST
2664 #undef X
2665 };
2666
2667 static void pop_call_frame(script_ctx_t *ctx)
2668 {
2669     call_frame_t *frame = ctx->call_ctx;
2670
2671     frame->stack_base -= frame->pop_locals + frame->pop_variables;
2672
2673     assert(frame->scope == frame->base_scope);
2674
2675     /* If current scope will be kept alive, we need to transfer local variables to its variable object. */
2676     if(frame->scope && frame->scope->ref > 1) {
2677         HRESULT hres = detach_variable_object(ctx, frame, TRUE);
2678         if(FAILED(hres))
2679             ERR("Failed to detach variable object: %08x\n", hres);
2680     }
2681
2682     if(frame->arguments_obj)
2683         detach_arguments_object(frame->arguments_obj);
2684     if(frame->scope)
2685         scope_release(frame->scope);
2686
2687     if(frame->pop_variables)
2688         stack_popn(ctx, frame->pop_variables);
2689     stack_popn(ctx, frame->pop_locals);
2690
2691     ctx->call_ctx = frame->prev_frame;
2692
2693     if(frame->function_instance)
2694         jsdisp_release(frame->function_instance);
2695     if(frame->variable_obj)
2696         jsdisp_release(frame->variable_obj);
2697     if(frame->this_obj)
2698         IDispatch_Release(frame->this_obj);
2699     jsval_release(frame->ret);
2700     release_bytecode(frame->bytecode);
2701     heap_free(frame);
2702 }
2703
2704 static void print_backtrace(script_ctx_t *ctx)
2705 {
2706     unsigned depth = 0, i;
2707     call_frame_t *frame;
2708
2709     for(frame = ctx->call_ctx; frame; frame = frame->prev_frame) {
2710         WARN("%u\t", depth);
2711         depth++;
2712
2713         if(frame->this_obj)
2714             WARN("%p->", frame->this_obj);
2715         WARN("%s(", frame->function->name ? debugstr_w(frame->function->name) : "[unnamed]");
2716         if(frame->base_scope && frame->base_scope->frame) {
2717             for(i=0; i < frame->argc; i++) {
2718                 if(i < frame->function->param_cnt)
2719                     WARN("%s%s=%s", i ? ", " : "", debugstr_w(frame->function->params[i]),
2720                          debugstr_jsval(ctx->stack[local_off(frame, -i-1)]));
2721                 else
2722                     WARN("%s%s", i ? ", " : "", debugstr_jsval(ctx->stack[local_off(frame, -i-1)]));
2723             }
2724         }else {
2725             WARN("[detached frame]");
2726         }
2727         WARN(")\n");
2728
2729         if(!(frame->flags & EXEC_RETURN_TO_INTERP)) {
2730             WARN("%u\t[native code]\n", depth);
2731             depth++;
2732         }
2733     }
2734 }
2735
2736 static HRESULT unwind_exception(script_ctx_t *ctx, HRESULT exception_hres)
2737 {
2738     except_frame_t *except_frame;
2739     jsexcept_t *ei = ctx->ei;
2740     call_frame_t *frame;
2741     jsval_t except_val;
2742     unsigned catch_off;
2743     HRESULT hres;
2744
2745     if(WARN_ON(jscript)) {
2746         jsdisp_t *error_obj;
2747         jsval_t msg;
2748
2749         WARN("Exception %08x %s", exception_hres, debugstr_jsval(ei->valid_value ? ei->value : jsval_undefined()));
2750         if(ei->valid_value && jsval_type(ei->value) == JSV_OBJECT) {
2751             error_obj = to_jsdisp(get_object(ei->value));
2752             if(error_obj) {
2753                 hres = jsdisp_propget_name(error_obj, L"message", &msg);
2754                 if(SUCCEEDED(hres)) {
2755                     WARN(" (message %s)", debugstr_jsval(msg));
2756                     jsval_release(msg);
2757                 }
2758             }
2759         }
2760         WARN(" in:\n");
2761
2762         print_backtrace(ctx);
2763     }
2764
2765     frame = ctx->call_ctx;
2766     if(exception_hres != DISP_E_EXCEPTION)
2767         throw_error(ctx, exception_hres, NULL);
2768     set_error_location(ei, frame->bytecode, frame->bytecode->instrs[frame->ip].loc, IDS_RUNTIME_ERROR, NULL);
2769
2770     while(!frame->except_frame) {
2771         DWORD flags;
2772
2773         while(frame->scope != frame->base_scope)
2774             scope_pop(&frame->scope);
2775
2776         stack_popn(ctx, ctx->stack_top-frame->stack_base);
2777
2778         flags = frame->flags;
2779         pop_call_frame(ctx);
2780         if(!(flags & EXEC_RETURN_TO_INTERP))
2781             return DISP_E_EXCEPTION;
2782         frame = ctx->call_ctx;
2783     }
2784
2785     except_frame = frame->except_frame;
2786     catch_off = except_frame->catch_off;
2787
2788     assert(except_frame->stack_top <= ctx->stack_top);
2789     stack_popn(ctx, ctx->stack_top - except_frame->stack_top);
2790
2791     while(except_frame->scope != frame->scope)
2792         scope_pop(&frame->scope);
2793
2794     frame->ip = catch_off ? catch_off : except_frame->finally_off;
2795     assert(!catch_off || frame->bytecode->instrs[frame->ip].op == OP_enter_catch);
2796
2797     if(ei->valid_value) {
2798         except_val = ctx->ei->value;
2799         ei->valid_value = FALSE;
2800     }else {
2801         jsdisp_t *err;
2802         if(!(err = create_builtin_error(ctx)))
2803             return E_OUTOFMEMORY;
2804         except_val = jsval_obj(err);
2805     }
2806
2807     /* keep current except_frame if we're entering catch block with finally block associated */
2808     if(catch_off && except_frame->finally_off) {
2809         except_frame->catch_off = 0;
2810     }else {
2811         frame->except_frame = except_frame->next;
2812         heap_free(except_frame);
2813     }
2814
2815     hres = stack_push(ctx, except_val);
2816     if(FAILED(hres))
2817         return hres;
2818
2819     if(!catch_off)
2820         hres = stack_push(ctx, jsval_bool(FALSE));
2821     return hres;
2822 }
2823
2824 static HRESULT enter_bytecode(script_ctx_t *ctx, jsval_t *r)
2825 {
2826     call_frame_t *frame;
2827     jsop_t op;
2828     HRESULT hres = S_OK;
2829
2830     TRACE("\n");
2831
2832     while(1) {
2833         frame = ctx->call_ctx;
2834         op = frame->bytecode->instrs[frame->ip].op;
2835         hres = op_funcs[op](ctx);
2836         if(FAILED(hres)) {
2837             hres = unwind_exception(ctx, hres);
2838             if(FAILED(hres))
2839                 return hres;
2840         }else if(frame->ip == -1) {
2841             const DWORD return_to_interp = frame->flags & EXEC_RETURN_TO_INTERP;
2842
2843             assert(ctx->stack_top == frame->stack_base);
2844             assert(frame->scope == frame->base_scope);
2845
2846             if(return_to_interp) {
2847                 jsval_release(ctx->acc);
2848                 ctx->acc = steal_ret(frame);
2849             }else if(r) {
2850                 *r = steal_ret(frame);
2851             }
2852             pop_call_frame(ctx);
2853             if(!return_to_interp)
2854                 break;
2855         }else {
2856             frame->ip += op_move[op];
2857         }
2858     }
2859
2860     return S_OK;
2861 }
2862
2863 static HRESULT bind_event_target(script_ctx_t *ctx, function_code_t *func, jsdisp_t *func_obj)
2864 {
2865     IBindEventHandler *target;
2866     exprval_t exprval;
2867     IDispatch *disp;
2868     jsval_t v;
2869     HRESULT hres;
2870
2871     hres = identifier_eval(ctx, func->event_target, &exprval);
2872     if(FAILED(hres))
2873         return hres;
2874
2875     hres = exprval_to_value(ctx, &exprval, &v);
2876     if(FAILED(hres))
2877         return hres;
2878
2879     if(!is_object_instance(v)) {
2880         FIXME("Can't bind to %s\n", debugstr_jsval(v));
2881         jsval_release(v);
2882     }
2883
2884     disp = get_object(v);
2885     hres = IDispatch_QueryInterface(disp, &IID_IBindEventHandler, (void**)&target);
2886     if(SUCCEEDED(hres)) {
2887         hres = IBindEventHandler_BindHandler(target, func->name, (IDispatch*)&func_obj->IDispatchEx_iface);
2888         IBindEventHandler_Release(target);
2889         if(FAILED(hres))
2890             WARN("BindEvent failed: %08x\n", hres);
2891     }else {
2892         FIXME("No IBindEventHandler, not yet supported binding\n");
2893     }
2894
2895     IDispatch_Release(disp);
2896     return hres;
2897 }
2898
2899 static HRESULT setup_scope(script_ctx_t *ctx, call_frame_t *frame, scope_chain_t *scope_chain, jsdisp_t *variable_object, unsigned argc, jsval_t *argv)
2900 {
2901     const unsigned orig_stack = ctx->stack_top;
2902     scope_chain_t *scope;
2903     unsigned i;
2904     jsval_t v;
2905     HRESULT hres;
2906
2907     /* If arguments are already on the stack, we may use them. */
2908     if(argv + argc == ctx->stack + ctx->stack_top) {
2909         frame->arguments_off = argv - ctx->stack;
2910         i = argc;
2911     }else {
2912         frame->arguments_off = ctx->stack_top;
2913         for(i = 0; i < argc; i++) {
2914             hres = jsval_copy(argv[i], &v);
2915             if(SUCCEEDED(hres))
2916                 hres = stack_push(ctx, v);
2917             if(FAILED(hres)) {
2918                 stack_popn(ctx, i);
2919                 return hres;
2920             }
2921         }
2922     }
2923
2924     /* If fewer than declared arguments were passed, fill remaining with undefined value. */
2925     for(; i < frame->function->param_cnt; i++) {
2926         hres = stack_push(ctx, jsval_undefined());
2927         if(FAILED(hres)) {
2928             stack_popn(ctx, ctx->stack_top - orig_stack);
2929             return hres;
2930         }
2931     }
2932
2933     frame->pop_locals = ctx->stack_top - orig_stack;
2934
2935     frame->variables_off = ctx->stack_top;
2936
2937     for(i = 0; i < frame->function->var_cnt; i++) {
2938         hres = stack_push(ctx, jsval_undefined());
2939         if(FAILED(hres)) {
2940             stack_popn(ctx, ctx->stack_top - orig_stack);
2941             return hres;
2942         }
2943     }
2944
2945     frame->pop_variables = i;
2946
2947     hres = scope_push(scope_chain, variable_object, to_disp(variable_object), &scope);
2948     if(FAILED(hres)) {
2949         stack_popn(ctx, ctx->stack_top - orig_stack);
2950         return hres;
2951     }
2952
2953     for(i = 0; i < frame->function->func_cnt; i++) {
2954         if(frame->function->funcs[i].name && !frame->function->funcs[i].event_target) {
2955             jsdisp_t *func_obj;
2956             unsigned off;
2957
2958             hres = create_source_function(ctx, frame->bytecode, frame->function->funcs+i, scope, &func_obj);
2959             if(FAILED(hres)) {
2960                 stack_popn(ctx, ctx->stack_top - orig_stack);
2961                 scope_release(scope);
2962                 return hres;
2963             }
2964
2965             off = local_off(frame, frame->function->funcs[i].local_ref);
2966             jsval_release(ctx->stack[off]);
2967             ctx->stack[off] = jsval_obj(func_obj);
2968         }
2969     }
2970
2971     scope->frame = frame;
2972     frame->base_scope = frame->scope = scope;
2973     return S_OK;
2974 }
2975
2976 HRESULT exec_source(script_ctx_t *ctx, DWORD flags, bytecode_t *bytecode, function_code_t *function, scope_chain_t *scope,
2977         IDispatch *this_obj, jsdisp_t *function_instance, unsigned argc, jsval_t *argv, jsval_t *r)
2978 {
2979     jsdisp_t *variable_obj;
2980     call_frame_t *frame;
2981     unsigned i;
2982     HRESULT hres;
2983
2984     if(!ctx->stack) {
2985         ctx->stack = heap_alloc(stack_size * sizeof(*ctx->stack));
2986         if(!ctx->stack)
2987             return E_OUTOFMEMORY;
2988     }
2989
2990     if(bytecode->named_item) {
2991         if(!bytecode->named_item->script_obj) {
2992             hres = create_named_item_script_obj(ctx, bytecode->named_item);
2993             if(FAILED(hres)) return hres;
2994         }
2995     }
2996
2997     if(!ctx->ei->enter_notified) {
2998         ctx->ei->enter_notified = TRUE;
2999         IActiveScriptSite_OnEnterScript(ctx->site);
3000     }
3001
3002     for(i = 0; i < function->func_cnt; i++) {
3003         jsdisp_t *func_obj;
3004
3005         if(!function->funcs[i].event_target)
3006             continue;
3007
3008         hres = create_source_function(ctx, bytecode, function->funcs+i, scope, &func_obj);
3009         if(FAILED(hres))
3010             return hres;
3011
3012         hres = bind_event_target(ctx, function->funcs+i, func_obj);
3013         jsdisp_release(func_obj);
3014         if(FAILED(hres))
3015             return hres;
3016     }
3017
3018     if((flags & EXEC_EVAL) && ctx->call_ctx) {
3019         variable_obj = jsdisp_addref(ctx->call_ctx->variable_obj);
3020     }else if(!(flags & (EXEC_GLOBAL | EXEC_EVAL))) {
3021         hres = create_dispex(ctx, NULL, NULL, &variable_obj);
3022         if(FAILED(hres)) return hres;
3023     }else if(bytecode->named_item) {
3024         variable_obj = jsdisp_addref(bytecode->named_item->script_obj);
3025     }else {
3026         variable_obj = jsdisp_addref(ctx->global);
3027     }
3028
3029     if(flags & (EXEC_GLOBAL | EXEC_EVAL)) {
3030         named_item_t *item = bytecode->named_item;
3031         DISPID id;
3032
3033         for(i=0; i < function->var_cnt; i++) {
3034             TRACE("[%d] %s %d\n", i, debugstr_w(function->variables[i].name), function->variables[i].func_id);
3035             if(function->variables[i].func_id != -1) {
3036                 jsdisp_t *func_obj;
3037
3038                 hres = create_source_function(ctx, bytecode, function->funcs+function->variables[i].func_id, scope, &func_obj);
3039                 if(FAILED(hres))
3040                     goto fail;
3041
3042                 hres = jsdisp_propput_name(variable_obj, function->variables[i].name, jsval_obj(func_obj));
3043                 jsdisp_release(func_obj);
3044                 continue;
3045             }
3046
3047             if(item && !(item->flags & SCRIPTITEM_CODEONLY)
3048                 && SUCCEEDED(disp_get_id(ctx, item->disp, function->variables[i].name, function->variables[i].name, 0, &id)))
3049                     continue;
3050
3051             if(!item && (flags & EXEC_GLOBAL) && lookup_global_members(ctx, function->variables[i].name, NULL))
3052                 continue;
3053
3054             hres = jsdisp_get_id(variable_obj, function->variables[i].name, fdexNameEnsure, &id);
3055             if(FAILED(hres))
3056                 goto fail;
3057         }
3058     }
3059
3060     /* ECMA-262 3rd Edition    11.2.3.7 */
3061     if(this_obj) {
3062         jsdisp_t *jsthis;
3063
3064         jsthis = iface_to_jsdisp(this_obj);
3065         if(jsthis) {
3066             if(jsthis->builtin_info->class == JSCLASS_GLOBAL || jsthis->builtin_info->class == JSCLASS_NONE)
3067                 this_obj = NULL;
3068             jsdisp_release(jsthis);
3069         }
3070     }
3071
3072     if(ctx->call_ctx && (flags & EXEC_EVAL)) {
3073         hres = detach_variable_object(ctx, ctx->call_ctx, FALSE);
3074         if(FAILED(hres))
3075             goto fail;
3076     }
3077
3078     frame = heap_alloc_zero(sizeof(*frame));
3079     if(!frame) {
3080         hres = E_OUTOFMEMORY;
3081         goto fail;
3082     }
3083
3084     frame->function = function;
3085     frame->ret = jsval_undefined();
3086     frame->argc = argc;
3087     frame->bytecode = bytecode_addref(bytecode);
3088
3089     if(!(flags & (EXEC_GLOBAL|EXEC_EVAL))) {
3090         hres = setup_scope(ctx, frame, scope, variable_obj, argc, argv);
3091         if(FAILED(hres)) {
3092             release_bytecode(frame->bytecode);
3093             heap_free(frame);
3094             goto fail;
3095         }
3096     }else if(scope) {
3097         frame->base_scope = frame->scope = scope_addref(scope);
3098     }
3099
3100     frame->ip = function->instr_off;
3101     frame->stack_base = ctx->stack_top;
3102     if(this_obj) {
3103         frame->this_obj = this_obj;
3104         IDispatch_AddRef(frame->this_obj);
3105     }
3106
3107     if(function_instance)
3108         frame->function_instance = jsdisp_addref(function_instance);
3109
3110     frame->flags = flags;
3111     frame->variable_obj = variable_obj;
3112
3113     frame->prev_frame = ctx->call_ctx;
3114     ctx->call_ctx = frame;
3115
3116     if(flags & EXEC_RETURN_TO_INTERP) {
3117         /*
3118          * We're called directly from interpreter, so we may just setup call frame and return.
3119          * Already running interpreter will take care of execution.
3120          */
3121         if(r)
3122             *r = jsval_undefined();
3123         return S_OK;
3124     }
3125
3126     return enter_bytecode(ctx, r);
3127
3128 fail:
3129     jsdisp_release(variable_obj);
3130     return hres;
3131 }