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