dlls/jscript/engine.c

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