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