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