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