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