git.oblomov.eu Git - wine/blob - dlls/jscript/engine.c

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