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