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