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