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

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <math.h>
  23 #include <assert.h>
  24
  25 #include "jscript.h"
  26 #include "engine.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  31
  32 #define EXPR_NOVAL   0x0001
  33 #define EXPR_NEWREF  0x0002
  34 #define EXPR_STRREF  0x0004
  35
  36 struct _return_type_t {
  37     enum{
  38         RT_NORMAL,
  39         RT_RETURN,
  40         RT_BREAK,
  41         RT_CONTINUE
  42     } type;
  43     jsexcept_t ei;
  44 };
  45
  46 static inline HRESULT stat_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
  47 {
  48     return stat->eval(ctx, stat, rt, ret);
  49 }
  50
  51 static inline HRESULT expr_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
  52 {
  53     return expr->eval(ctx, expr, flags, ei, ret);
  54 }
  55
  56 static HRESULT stack_push(exec_ctx_t *ctx, VARIANT *v)
  57 {
  58     if(!ctx->stack_size) {
  59         ctx->stack = heap_alloc(16*sizeof(VARIANT));
  60         if(!ctx->stack)
  61             return E_OUTOFMEMORY;
  62         ctx->stack_size = 16;
  63     }else if(ctx->stack_size == ctx->top) {
  64         VARIANT *new_stack;
  65
  66         new_stack = heap_realloc(ctx->stack, ctx->stack_size*2*sizeof(VARIANT));
  67         if(!new_stack) {
  68             VariantClear(v);
  69             return E_OUTOFMEMORY;
  70         }
  71
  72         ctx->stack = new_stack;
  73         ctx->stack_size *= 2;
  74     }
  75
  76     ctx->stack[ctx->top++] = *v;
  77     return S_OK;
  78 }
  79
  80 static HRESULT stack_push_bool(exec_ctx_t *ctx, BOOL b)
  81 {
  82     VARIANT v;
  83
  84     V_VT(&v) = VT_BOOL;
  85     V_BOOL(&v) = b ? VARIANT_TRUE : VARIANT_FALSE;
  86     return stack_push(ctx, &v);
  87 }
  88
  89 static inline HRESULT stack_push_number(exec_ctx_t *ctx, double number)
  90 {
  91     VARIANT v;
  92
  93     num_set_val(&v, number);
  94     return stack_push(ctx, &v);
  95 }
  96
  97 static inline HRESULT stack_push_int(exec_ctx_t *ctx, INT n)
  98 {
  99     VARIANT v;
 100
 101     V_VT(&v) = VT_I4;
 102     V_I4(&v) = n;
 103     return stack_push(ctx, &v);
 104 }
 105
 106 static inline VARIANT *stack_top(exec_ctx_t *ctx)
 107 {
 108     assert(ctx->top);
 109     return ctx->stack + ctx->top-1;
 110 }
 111
 112 static inline VARIANT *stack_topn(exec_ctx_t *ctx, unsigned n)
 113 {
 114     assert(ctx->top > n);
 115     return ctx->stack + ctx->top-1-n;
 116 }
 117
 118 static inline VARIANT *stack_pop(exec_ctx_t *ctx)
 119 {
 120     assert(ctx->top);
 121     return ctx->stack + --ctx->top;
 122 }
 123
 124 static void stack_popn(exec_ctx_t *ctx, unsigned n)
 125 {
 126     while(n--)
 127         VariantClear(stack_pop(ctx));
 128 }
 129
 130 static HRESULT stack_pop_number(exec_ctx_t *ctx, VARIANT *r)
 131 {
 132     VARIANT *v;
 133     HRESULT hres;
 134
 135     v = stack_pop(ctx);
 136     hres = to_number(ctx->parser->script, v, &ctx->ei, r);
 137     VariantClear(v);
 138     return hres;
 139 }
 140
 141 static inline HRESULT stack_pop_int(exec_ctx_t *ctx, INT *r)
 142 {
 143     return to_int32(ctx->parser->script, stack_pop(ctx), &ctx->ei, r);
 144 }
 145
 146 static void exprval_release(exprval_t *val)
 147 {
 148     switch(val->type) {
 149     case EXPRVAL_VARIANT:
 150         if(V_VT(&val->u.var) != VT_EMPTY)
 151             VariantClear(&val->u.var);
 152         return;
 153     case EXPRVAL_IDREF:
 154         if(val->u.idref.disp)
 155             IDispatch_Release(val->u.idref.disp);
 156         return;
 157     case EXPRVAL_NAMEREF:
 158         if(val->u.nameref.disp)
 159             IDispatch_Release(val->u.nameref.disp);
 160         SysFreeString(val->u.nameref.name);
 161         return;
 162     case EXPRVAL_INVALID:
 163         SysFreeString(val->u.identifier);
 164     }
 165 }
 166
 167 /* ECMA-262 3rd Edition    8.7.1 */
 168 static HRESULT exprval_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
 169 {
 170     V_VT(ret) = VT_EMPTY;
 171
 172     switch(val->type) {
 173     case EXPRVAL_VARIANT:
 174         return VariantCopy(ret, &val->u.var);
 175     case EXPRVAL_IDREF:
 176         if(!val->u.idref.disp) {
 177             FIXME("throw ReferenceError\n");
 178             return E_FAIL;
 179         }
 180
 181         return disp_propget(ctx, val->u.idref.disp, val->u.idref.id, ret, ei, NULL/*FIXME*/);
 182     case EXPRVAL_NAMEREF:
 183         break;
 184     case EXPRVAL_INVALID:
 185         return throw_type_error(ctx, ei, JS_E_UNDEFINED_VARIABLE, val->u.identifier);
 186     }
 187
 188     ERR("type %d\n", val->type);
 189     return E_FAIL;
 190 }
 191
 192 static HRESULT exprval_to_value(script_ctx_t *ctx, exprval_t *val, jsexcept_t *ei, VARIANT *ret)
 193 {
 194     if(val->type == EXPRVAL_VARIANT) {
 195         *ret = val->u.var;
 196         V_VT(&val->u.var) = VT_EMPTY;
 197         return S_OK;
 198     }
 199
 200     return exprval_value(ctx, val, ei, ret);
 201 }
 202
 203 static HRESULT exprval_to_boolean(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, VARIANT_BOOL *b)
 204 {
 205     if(exprval->type != EXPRVAL_VARIANT) {
 206         VARIANT val;
 207         HRESULT hres;
 208
 209         hres = exprval_to_value(ctx, exprval, ei, &val);
 210         if(FAILED(hres))
 211             return hres;
 212
 213         hres = to_boolean(&val, b);
 214         VariantClear(&val);
 215         return hres;
 216     }
 217
 218     return to_boolean(&exprval->u.var, b);
 219 }
 220
 221 static void exprval_init(exprval_t *val)
 222 {
 223     val->type = EXPRVAL_VARIANT;
 224     V_VT(&val->u.var) = VT_EMPTY;
 225 }
 226
 227 static void exprval_set_idref(exprval_t *val, IDispatch *disp, DISPID id)
 228 {
 229     val->type = EXPRVAL_IDREF;
 230     val->u.idref.disp = disp;
 231     val->u.idref.id = id;
 232
 233     if(disp)
 234         IDispatch_AddRef(disp);
 235 }
 236
 237 HRESULT scope_push(scope_chain_t *scope, jsdisp_t *obj, scope_chain_t **ret)
 238 {
 239     scope_chain_t *new_scope;
 240
 241     new_scope = heap_alloc(sizeof(scope_chain_t));
 242     if(!new_scope)
 243         return E_OUTOFMEMORY;
 244
 245     new_scope->ref = 1;
 246
 247     jsdisp_addref(obj);
 248     new_scope->obj = obj;
 249
 250     if(scope) {
 251         scope_addref(scope);
 252         new_scope->next = scope;
 253     }else {
 254         new_scope->next = NULL;
 255     }
 256
 257     *ret = new_scope;
 258     return S_OK;
 259 }
 260
 261 static void scope_pop(scope_chain_t **scope)
 262 {
 263     scope_chain_t *tmp;
 264
 265     tmp = *scope;
 266     *scope = tmp->next;
 267     scope_release(tmp);
 268 }
 269
 270 void scope_release(scope_chain_t *scope)
 271 {
 272     if(--scope->ref)
 273         return;
 274
 275     if(scope->next)
 276         scope_release(scope->next);
 277
 278     jsdisp_release(scope->obj);
 279     heap_free(scope);
 280 }
 281
 282 HRESULT create_exec_ctx(script_ctx_t *script_ctx, IDispatch *this_obj, jsdisp_t *var_disp,
 283         scope_chain_t *scope, BOOL is_global, exec_ctx_t **ret)
 284 {
 285     exec_ctx_t *ctx;
 286
 287     ctx = heap_alloc_zero(sizeof(exec_ctx_t));
 288     if(!ctx)
 289         return E_OUTOFMEMORY;
 290
 291     ctx->ref = 1;
 292     ctx->is_global = is_global;
 293
 294     if(this_obj)
 295         ctx->this_obj = this_obj;
 296     else if(script_ctx->host_global)
 297         ctx->this_obj = script_ctx->host_global;
 298     else
 299         ctx->this_obj = to_disp(script_ctx->global);
 300     IDispatch_AddRef(ctx->this_obj);
 301
 302     jsdisp_addref(var_disp);
 303     ctx->var_disp = var_disp;
 304
 305     if(scope) {
 306         scope_addref(scope);
 307         ctx->scope_chain = scope;
 308     }
 309
 310     *ret = ctx;
 311     return S_OK;
 312 }
 313
 314 void exec_release(exec_ctx_t *ctx)
 315 {
 316     if(--ctx->ref)
 317         return;
 318
 319     if(ctx->scope_chain)
 320         scope_release(ctx->scope_chain);
 321     if(ctx->var_disp)
 322         jsdisp_release(ctx->var_disp);
 323     if(ctx->this_obj)
 324         IDispatch_Release(ctx->this_obj);
 325     heap_free(ctx->stack);
 326     heap_free(ctx);
 327 }
 328
 329 static HRESULT disp_get_id(script_ctx_t *ctx, IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
 330 {
 331     IDispatchEx *dispex;
 332     HRESULT hres;
 333
 334     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 335     if(FAILED(hres)) {
 336         TRACE("unsing IDispatch\n");
 337
 338         *id = 0;
 339         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 340     }
 341
 342     *id = 0;
 343     hres = IDispatchEx_GetDispID(dispex, name, make_grfdex(ctx, flags|fdexNameCaseSensitive), id);
 344     IDispatchEx_Release(dispex);
 345     return hres;
 346 }
 347
 348 /* ECMA-262 3rd Edition    8.7.2 */
 349 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
 350 {
 351     if(ref->type != EXPRVAL_IDREF)
 352         return throw_reference_error(ctx, ei, JS_E_ILLEGAL_ASSIGN, NULL);
 353
 354     return disp_propput(ctx, ref->u.idref.disp, ref->u.idref.id, v, ei, NULL/*FIXME*/);
 355 }
 356
 357 static inline BOOL is_null(const VARIANT *v)
 358 {
 359     return V_VT(v) == VT_NULL || (V_VT(v) == VT_DISPATCH && !V_DISPATCH(v));
 360 }
 361
 362 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
 363 {
 364     IObjectIdentity *identity;
 365     IUnknown *unk1, *unk2;
 366     HRESULT hres;
 367
 368     if(disp1 == disp2) {
 369         *ret = TRUE;
 370         return S_OK;
 371     }
 372
 373     if(!disp1 || !disp2) {
 374         *ret = FALSE;
 375         return S_OK;
 376     }
 377
 378     hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
 379     if(FAILED(hres))
 380         return hres;
 381
 382     hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
 383     if(FAILED(hres)) {
 384         IUnknown_Release(unk1);
 385         return hres;
 386     }
 387
 388     if(unk1 == unk2) {
 389         *ret = TRUE;
 390     }else {
 391         hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
 392         if(SUCCEEDED(hres)) {
 393             hres = IObjectIdentity_IsEqualObject(identity, unk2);
 394             IObjectIdentity_Release(identity);
 395             *ret = hres == S_OK;
 396         }else {
 397             *ret = FALSE;
 398         }
 399     }
 400
 401     IUnknown_Release(unk1);
 402     IUnknown_Release(unk2);
 403     return S_OK;
 404 }
 405
 406 /* ECMA-262 3rd Edition    11.9.6 */
 407 static HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
 408 {
 409     TRACE("\n");
 410
 411     if(V_VT(lval) != V_VT(rval)) {
 412         if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval)))
 413             *ret = num_val(lval) == num_val(rval);
 414         else if(is_null(lval))
 415             *ret = is_null(rval);
 416         else
 417             *ret = FALSE;
 418         return S_OK;
 419     }
 420
 421     switch(V_VT(lval)) {
 422     case VT_EMPTY:
 423     case VT_NULL:
 424         *ret = VARIANT_TRUE;
 425         break;
 426     case VT_I4:
 427         *ret = V_I4(lval) == V_I4(rval);
 428         break;
 429     case VT_R8:
 430         *ret = V_R8(lval) == V_R8(rval);
 431         break;
 432     case VT_BSTR:
 433         if(!V_BSTR(lval))
 434             *ret = SysStringLen(V_BSTR(rval))?FALSE:TRUE;
 435         else if(!V_BSTR(rval))
 436             *ret = SysStringLen(V_BSTR(lval))?FALSE:TRUE;
 437         else
 438             *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
 439         break;
 440     case VT_DISPATCH:
 441         return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
 442     case VT_BOOL:
 443         *ret = !V_BOOL(lval) == !V_BOOL(rval);
 444         break;
 445     default:
 446         FIXME("unimplemented vt %d\n", V_VT(lval));
 447         return E_NOTIMPL;
 448     }
 449
 450     return S_OK;
 451 }
 452
 453 static HRESULT literal_to_var(script_ctx_t *ctx, literal_t *literal, VARIANT *v)
 454 {
 455     switch(literal->type) {
 456     case LT_NULL:
 457         V_VT(v) = VT_NULL;
 458         break;
 459     case LT_INT:
 460         V_VT(v) = VT_I4;
 461         V_I4(v) = literal->u.lval;
 462         break;
 463     case LT_DOUBLE:
 464         V_VT(v) = VT_R8;
 465         V_R8(v) = literal->u.dval;
 466         break;
 467     case LT_STRING: {
 468         BSTR str = SysAllocString(literal->u.wstr);
 469         if(!str)
 470             return E_OUTOFMEMORY;
 471
 472         V_VT(v) = VT_BSTR;
 473         V_BSTR(v) = str;
 474         break;
 475     }
 476     case LT_BOOL:
 477         V_VT(v) = VT_BOOL;
 478         V_BOOL(v) = literal->u.bval;
 479         break;
 480     case LT_REGEXP: {
 481         jsdisp_t *regexp;
 482         HRESULT hres;
 483
 484         hres = create_regexp(ctx, literal->u.regexp.str, literal->u.regexp.str_len,
 485                              literal->u.regexp.flags, &regexp);
 486         if(FAILED(hres))
 487             return hres;
 488
 489         var_set_jsdisp(v, regexp);
 490     }
 491     }
 492
 493     return S_OK;
 494 }
 495
 496 static BOOL lookup_global_members(script_ctx_t *ctx, BSTR identifier, exprval_t *ret)
 497 {
 498     named_item_t *item;
 499     DISPID id;
 500     HRESULT hres;
 501
 502     for(item = ctx->named_items; item; item = item->next) {
 503         if(item->flags & SCRIPTITEM_GLOBALMEMBERS) {
 504             hres = disp_get_id(ctx, item->disp, identifier, 0, &id);
 505             if(SUCCEEDED(hres)) {
 506                 if(ret)
 507                     exprval_set_idref(ret, item->disp, id);
 508                 return TRUE;
 509             }
 510         }
 511     }
 512
 513     return FALSE;
 514 }
 515
 516 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, BOOL from_eval,
 517         jsexcept_t *ei, VARIANT *retv)
 518 {
 519     script_ctx_t *script = parser->script;
 520     function_declaration_t *func;
 521     parser_ctx_t *prev_parser;
 522     var_list_t *var;
 523     VARIANT val, tmp;
 524     statement_t *stat;
 525     exec_ctx_t *prev_ctx;
 526     return_type_t rt;
 527     HRESULT hres = S_OK;
 528
 529     for(func = source->functions; func; func = func->next) {
 530         jsdisp_t *func_obj;
 531         VARIANT var;
 532
 533         hres = create_source_function(parser, func->expr->parameter_list, func->expr->source_elements,
 534                 ctx->scope_chain, func->expr->src_str, func->expr->src_len, &func_obj);
 535         if(FAILED(hres))
 536             return hres;
 537
 538         var_set_jsdisp(&var, func_obj);
 539         hres = jsdisp_propput_name(ctx->var_disp, func->expr->identifier, &var, ei, NULL);
 540         jsdisp_release(func_obj);
 541         if(FAILED(hres))
 542             return hres;
 543     }
 544
 545     for(var = source->variables; var; var = var->next) {
 546         DISPID id = 0;
 547         BSTR name;
 548
 549         name = SysAllocString(var->identifier);
 550         if(!name)
 551             return E_OUTOFMEMORY;
 552
 553         if(!ctx->is_global || !lookup_global_members(parser->script, name, NULL))
 554             hres = jsdisp_get_id(ctx->var_disp, var->identifier, fdexNameEnsure, &id);
 555         SysFreeString(name);
 556         if(FAILED(hres))
 557             return hres;
 558     }
 559
 560     prev_ctx = script->exec_ctx;
 561     script->exec_ctx = ctx;
 562
 563     prev_parser = ctx->parser;
 564     ctx->parser = parser;
 565
 566     V_VT(&val) = VT_EMPTY;
 567     memset(&rt, 0, sizeof(rt));
 568     rt.type = RT_NORMAL;
 569
 570     for(stat = source->statement; stat; stat = stat->next) {
 571         hres = stat_eval(script, stat, &rt, &tmp);
 572         if(FAILED(hres))
 573             break;
 574
 575         VariantClear(&val);
 576         val = tmp;
 577         if(rt.type != RT_NORMAL)
 578             break;
 579     }
 580
 581     script->exec_ctx = prev_ctx;
 582     ctx->parser = prev_parser;
 583
 584     if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
 585         FIXME("wrong rt %d\n", rt.type);
 586         hres = E_FAIL;
 587     }
 588
 589     *ei = rt.ei;
 590     if(FAILED(hres)) {
 591         VariantClear(&val);
 592         return hres;
 593     }
 594
 595     if(!retv || (!from_eval && rt.type != RT_RETURN))
 596         VariantClear(&val);
 597     if(retv)
 598         *retv = val;
 599     return S_OK;
 600 }
 601
 602 /* ECMA-262 3rd Edition    10.1.4 */
 603 static HRESULT identifier_eval(script_ctx_t *ctx, BSTR identifier, DWORD flags, jsexcept_t *ei, exprval_t *ret)
 604 {
 605     scope_chain_t *scope;
 606     named_item_t *item;
 607     DISPID id = 0;
 608     HRESULT hres;
 609
 610     TRACE("%s\n", debugstr_w(identifier));
 611
 612     for(scope = ctx->exec_ctx->scope_chain; scope; scope = scope->next) {
 613         hres = jsdisp_get_id(scope->obj, identifier, 0, &id);
 614         if(SUCCEEDED(hres)) {
 615             exprval_set_idref(ret, to_disp(scope->obj), id);
 616             return S_OK;
 617         }
 618     }
 619
 620     hres = jsdisp_get_id(ctx->global, identifier, 0, &id);
 621     if(SUCCEEDED(hres)) {
 622         exprval_set_idref(ret, to_disp(ctx->global), id);
 623         return S_OK;
 624     }
 625
 626     for(item = ctx->named_items; item; item = item->next) {
 627         if((item->flags & SCRIPTITEM_ISVISIBLE) && !strcmpW(item->name, identifier)) {
 628             if(!item->disp) {
 629                 IUnknown *unk;
 630
 631                 if(!ctx->site)
 632                     break;
 633
 634                 hres = IActiveScriptSite_GetItemInfo(ctx->site, identifier,
 635                                                      SCRIPTINFO_IUNKNOWN, &unk, NULL);
 636                 if(FAILED(hres)) {
 637                     WARN("GetItemInfo failed: %08x\n", hres);
 638                     break;
 639                 }
 640
 641                 hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&item->disp);
 642                 IUnknown_Release(unk);
 643                 if(FAILED(hres)) {
 644                     WARN("object does not implement IDispatch\n");
 645                     break;
 646                 }
 647             }
 648
 649             ret->type = EXPRVAL_VARIANT;
 650             V_VT(&ret->u.var) = VT_DISPATCH;
 651             V_DISPATCH(&ret->u.var) = item->disp;
 652             IDispatch_AddRef(item->disp);
 653             return S_OK;
 654         }
 655     }
 656
 657     if(lookup_global_members(ctx, identifier, ret))
 658         return S_OK;
 659
 660     if(flags & EXPR_NEWREF) {
 661         hres = jsdisp_get_id(ctx->global, identifier, fdexNameEnsure, &id);
 662         if(FAILED(hres))
 663             return hres;
 664
 665         exprval_set_idref(ret, to_disp(ctx->global), id);
 666         return S_OK;
 667     }
 668
 669     ret->type = EXPRVAL_INVALID;
 670     ret->u.identifier = SysAllocString(identifier);
 671     if(!ret->u.identifier)
 672         return E_OUTOFMEMORY;
 673
 674     return S_OK;
 675 }
 676
 677 /* ECMA-262 3rd Edition    12.1 */
 678 HRESULT block_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 679 {
 680     block_statement_t *stat = (block_statement_t*)_stat;
 681     VARIANT val, tmp;
 682     statement_t *iter;
 683     HRESULT hres = S_OK;
 684
 685     TRACE("\n");
 686
 687     V_VT(&val) = VT_EMPTY;
 688     for(iter = stat->stat_list; iter; iter = iter->next) {
 689         hres = stat_eval(ctx, iter, rt, &tmp);
 690         if(FAILED(hres))
 691             break;
 692
 693         VariantClear(&val);
 694         val = tmp;
 695         if(rt->type != RT_NORMAL)
 696             break;
 697     }
 698
 699     if(FAILED(hres)) {
 700         VariantClear(&val);
 701         return hres;
 702     }
 703
 704     *ret = val;
 705     return S_OK;
 706 }
 707
 708 /* ECMA-262 3rd Edition    12.2 */
 709 static HRESULT variable_list_eval(script_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
 710 {
 711     variable_declaration_t *iter;
 712     HRESULT hres = S_OK;
 713
 714     for(iter = var_list; iter; iter = iter->next) {
 715         exprval_t exprval;
 716         VARIANT val;
 717
 718         if(!iter->expr)
 719             continue;
 720
 721         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
 722         if(FAILED(hres))
 723             break;
 724
 725         hres = exprval_to_value(ctx, &exprval, ei, &val);
 726         exprval_release(&exprval);
 727         if(FAILED(hres))
 728             break;
 729
 730         hres = jsdisp_propput_name(ctx->exec_ctx->var_disp, iter->identifier, &val, ei, NULL/*FIXME*/);
 731         VariantClear(&val);
 732         if(FAILED(hres))
 733             break;
 734     }
 735
 736     return hres;
 737 }
 738
 739 /* ECMA-262 3rd Edition    12.2 */
 740 HRESULT var_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 741 {
 742     var_statement_t *stat = (var_statement_t*)_stat;
 743     HRESULT hres;
 744
 745     TRACE("\n");
 746
 747     hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
 748     if(FAILED(hres))
 749         return hres;
 750
 751     V_VT(ret) = VT_EMPTY;
 752     return S_OK;
 753 }
 754
 755 /* ECMA-262 3rd Edition    12.3 */
 756 HRESULT empty_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 757 {
 758     TRACE("\n");
 759
 760     V_VT(ret) = VT_EMPTY;
 761     return S_OK;
 762 }
 763
 764 /* ECMA-262 3rd Edition    12.4 */
 765 HRESULT expression_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 766 {
 767     expression_statement_t *stat = (expression_statement_t*)_stat;
 768     exprval_t exprval;
 769     VARIANT val;
 770     HRESULT hres;
 771
 772     TRACE("\n");
 773
 774     hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
 775     if(FAILED(hres))
 776         return hres;
 777
 778     hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
 779     exprval_release(&exprval);
 780     if(FAILED(hres))
 781         return hres;
 782
 783     *ret = val;
 784     TRACE("= %s\n", debugstr_variant(ret));
 785     return S_OK;
 786 }
 787
 788 /* ECMA-262 3rd Edition    12.5 */
 789 HRESULT if_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 790 {
 791     if_statement_t *stat = (if_statement_t*)_stat;
 792     exprval_t exprval;
 793     VARIANT_BOOL b;
 794     HRESULT hres;
 795
 796     TRACE("\n");
 797
 798     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 799     if(FAILED(hres))
 800         return hres;
 801
 802     hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
 803     exprval_release(&exprval);
 804     if(FAILED(hres))
 805         return hres;
 806
 807     if(b)
 808         hres = stat_eval(ctx, stat->if_stat, rt, ret);
 809     else if(stat->else_stat)
 810         hres = stat_eval(ctx, stat->else_stat, rt, ret);
 811     else
 812         V_VT(ret) = VT_EMPTY;
 813
 814     return hres;
 815 }
 816
 817 /* ECMA-262 3rd Edition    12.6.2 */
 818 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 819 {
 820     while_statement_t *stat = (while_statement_t*)_stat;
 821     exprval_t exprval;
 822     VARIANT val, tmp;
 823     VARIANT_BOOL b;
 824     BOOL test_expr;
 825     HRESULT hres;
 826
 827     TRACE("\n");
 828
 829     V_VT(&val) = VT_EMPTY;
 830     test_expr = !stat->do_while;
 831
 832     while(1) {
 833         if(test_expr) {
 834             hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 835             if(FAILED(hres))
 836                 break;
 837
 838             hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
 839             exprval_release(&exprval);
 840             if(FAILED(hres) || !b)
 841                 break;
 842         }else {
 843             test_expr = TRUE;
 844         }
 845
 846         hres = stat_eval(ctx, stat->statement, rt, &tmp);
 847         if(FAILED(hres))
 848             break;
 849
 850         VariantClear(&val);
 851         val = tmp;
 852
 853         if(rt->type == RT_CONTINUE)
 854             rt->type = RT_NORMAL;
 855         if(rt->type != RT_NORMAL)
 856             break;
 857     }
 858
 859     if(FAILED(hres)) {
 860         VariantClear(&val);
 861         return hres;
 862     }
 863
 864     if(rt->type == RT_BREAK)
 865         rt->type = RT_NORMAL;
 866
 867     *ret = val;
 868     return S_OK;
 869 }
 870
 871 /* ECMA-262 3rd Edition    12.6.3 */
 872 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 873 {
 874     for_statement_t *stat = (for_statement_t*)_stat;
 875     VARIANT val, tmp, retv;
 876     exprval_t exprval;
 877     VARIANT_BOOL b;
 878     HRESULT hres;
 879
 880     TRACE("\n");
 881
 882     if(stat->variable_list) {
 883         hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
 884         if(FAILED(hres))
 885             return hres;
 886     }else if(stat->begin_expr) {
 887         hres = expr_eval(ctx, stat->begin_expr, EXPR_NEWREF, &rt->ei, &exprval);
 888         if(FAILED(hres))
 889             return hres;
 890
 891         hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
 892         exprval_release(&exprval);
 893         if(FAILED(hres))
 894             return hres;
 895
 896         VariantClear(&val);
 897     }
 898
 899     V_VT(&retv) = VT_EMPTY;
 900
 901     while(1) {
 902         if(stat->expr) {
 903             hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 904             if(FAILED(hres))
 905                 break;
 906
 907             hres = exprval_to_boolean(ctx, &exprval, &rt->ei, &b);
 908             exprval_release(&exprval);
 909             if(FAILED(hres) || !b)
 910                 break;
 911         }
 912
 913         hres = stat_eval(ctx, stat->statement, rt, &tmp);
 914         if(FAILED(hres))
 915             break;
 916
 917         VariantClear(&retv);
 918         retv = tmp;
 919
 920         if(rt->type == RT_CONTINUE)
 921             rt->type = RT_NORMAL;
 922         else if(rt->type != RT_NORMAL)
 923             break;
 924
 925         if(stat->end_expr) {
 926             hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &exprval);
 927             if(FAILED(hres))
 928                 break;
 929
 930             hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
 931             exprval_release(&exprval);
 932             if(FAILED(hres))
 933                 break;
 934
 935             VariantClear(&val);
 936         }
 937     }
 938
 939     if(FAILED(hres)) {
 940         VariantClear(&retv);
 941         return hres;
 942     }
 943
 944     if(rt->type == RT_BREAK)
 945         rt->type = RT_NORMAL;
 946
 947     *ret = retv;
 948     return S_OK;
 949 }
 950
 951 /* ECMA-262 3rd Edition    12.6.4 */
 952 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 953 {
 954     forin_statement_t *stat = (forin_statement_t*)_stat;
 955     VARIANT val, name, retv, tmp;
 956     DISPID id = DISPID_STARTENUM;
 957     BSTR str, identifier = NULL;
 958     IDispatchEx *in_obj;
 959     exprval_t exprval;
 960     HRESULT hres;
 961
 962     TRACE("\n");
 963
 964     if(stat->variable) {
 965         hres = variable_list_eval(ctx, stat->variable, &rt->ei);
 966         if(FAILED(hres))
 967             return hres;
 968     }
 969
 970     hres = expr_eval(ctx, stat->in_expr, EXPR_NEWREF, &rt->ei, &exprval);
 971     if(FAILED(hres))
 972         return hres;
 973
 974     hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
 975     exprval_release(&exprval);
 976     if(FAILED(hres))
 977         return hres;
 978
 979     if(V_VT(&val) != VT_DISPATCH) {
 980         TRACE("in vt %d\n", V_VT(&val));
 981         VariantClear(&val);
 982         V_VT(ret) = VT_EMPTY;
 983         return S_OK;
 984     }
 985
 986     hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
 987     IDispatch_Release(V_DISPATCH(&val));
 988     if(FAILED(hres)) {
 989         TRACE("Object doesn't support IDispatchEx\n");
 990         V_VT(ret) = VT_EMPTY;
 991         return S_OK;
 992     }
 993
 994     V_VT(&retv) = VT_EMPTY;
 995
 996     if(stat->variable)
 997         identifier = SysAllocString(stat->variable->identifier);
 998
 999     while(1) {
1000         hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
1001         if(FAILED(hres) || hres == S_FALSE)
1002             break;
1003
1004         hres = IDispatchEx_GetMemberName(in_obj, id, &str);
1005         if(FAILED(hres))
1006             break;
1007
1008         TRACE("iter %s\n", debugstr_w(str));
1009
1010         if(stat->variable)
1011             hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
1012         else
1013             hres = expr_eval(ctx, stat->expr, EXPR_NEWREF, &rt->ei, &exprval);
1014         if(SUCCEEDED(hres)) {
1015             V_VT(&name) = VT_BSTR;
1016             V_BSTR(&name) = str;
1017             hres = put_value(ctx, &exprval, &name, &rt->ei);
1018             exprval_release(&exprval);
1019         }
1020         SysFreeString(str);
1021         if(FAILED(hres))
1022             break;
1023
1024         hres = stat_eval(ctx, stat->statement, rt, &tmp);
1025         if(FAILED(hres))
1026             break;
1027
1028         VariantClear(&retv);
1029         retv = tmp;
1030
1031         if(rt->type == RT_CONTINUE)
1032             rt->type = RT_NORMAL;
1033         else if(rt->type != RT_NORMAL)
1034             break;
1035     }
1036
1037     SysFreeString(identifier);
1038     IDispatchEx_Release(in_obj);
1039     if(FAILED(hres)) {
1040         VariantClear(&retv);
1041         return hres;
1042     }
1043
1044     if(rt->type == RT_BREAK)
1045         rt->type = RT_NORMAL;
1046
1047     *ret = retv;
1048     return S_OK;
1049 }
1050
1051 /* ECMA-262 3rd Edition    12.7 */
1052 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1053 {
1054     branch_statement_t *stat = (branch_statement_t*)_stat;
1055
1056     TRACE("\n");
1057
1058     if(stat->identifier) {
1059         FIXME("indentifier not implemented\n");
1060         return E_NOTIMPL;
1061     }
1062
1063     rt->type = RT_CONTINUE;
1064     V_VT(ret) = VT_EMPTY;
1065     return S_OK;
1066 }
1067
1068 /* ECMA-262 3rd Edition    12.8 */
1069 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1070 {
1071     branch_statement_t *stat = (branch_statement_t*)_stat;
1072
1073     TRACE("\n");
1074
1075     if(stat->identifier) {
1076         FIXME("indentifier not implemented\n");
1077         return E_NOTIMPL;
1078     }
1079
1080     rt->type = RT_BREAK;
1081     V_VT(ret) = VT_EMPTY;
1082     return S_OK;
1083 }
1084
1085 /* ECMA-262 3rd Edition    12.9 */
1086 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1087 {
1088     expression_statement_t *stat = (expression_statement_t*)_stat;
1089     HRESULT hres;
1090
1091     TRACE("\n");
1092
1093     if(stat->expr) {
1094         exprval_t exprval;
1095
1096         hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1097         if(FAILED(hres))
1098             return hres;
1099
1100         hres = exprval_to_value(ctx, &exprval, &rt->ei, ret);
1101         exprval_release(&exprval);
1102         if(FAILED(hres))
1103             return hres;
1104     }else {
1105         V_VT(ret) = VT_EMPTY;
1106     }
1107
1108     TRACE("= %s\n", debugstr_variant(ret));
1109     rt->type = RT_RETURN;
1110     return S_OK;
1111 }
1112
1113 /* ECMA-262 3rd Edition    12.10 */
1114 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1115 {
1116     with_statement_t *stat = (with_statement_t*)_stat;
1117     exprval_t exprval;
1118     IDispatch *disp;
1119     jsdisp_t *obj;
1120     VARIANT val;
1121     HRESULT hres;
1122
1123     TRACE("\n");
1124
1125     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1126     if(FAILED(hres))
1127         return hres;
1128
1129     hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1130     exprval_release(&exprval);
1131     if(FAILED(hres))
1132         return hres;
1133
1134     hres = to_object(ctx, &val, &disp);
1135     VariantClear(&val);
1136     if(FAILED(hres))
1137         return hres;
1138
1139     obj = iface_to_jsdisp((IUnknown*)disp);
1140     IDispatch_Release(disp);
1141     if(!obj) {
1142         FIXME("disp id not jsdisp\n");
1143         return E_NOTIMPL;
1144     }
1145
1146     hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1147     jsdisp_release(obj);
1148     if(FAILED(hres))
1149         return hres;
1150
1151     hres = stat_eval(ctx, stat->statement, rt, ret);
1152
1153     scope_pop(&ctx->exec_ctx->scope_chain);
1154     return hres;
1155 }
1156
1157 /* ECMA-262 3rd Edition    12.12 */
1158 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1159 {
1160     FIXME("\n");
1161     return E_NOTIMPL;
1162 }
1163
1164 /* ECMA-262 3rd Edition    12.13 */
1165 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1166 {
1167     switch_statement_t *stat = (switch_statement_t*)_stat;
1168     case_clausule_t *iter, *default_clausule = NULL;
1169     statement_t *stat_iter;
1170     VARIANT val, cval;
1171     exprval_t exprval;
1172     BOOL b;
1173     HRESULT hres;
1174
1175     TRACE("\n");
1176
1177     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1178     if(FAILED(hres))
1179         return hres;
1180
1181     hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1182     exprval_release(&exprval);
1183     if(FAILED(hres))
1184         return hres;
1185
1186     for(iter = stat->case_list; iter; iter = iter->next) {
1187         if(!iter->expr) {
1188             default_clausule = iter;
1189             continue;
1190         }
1191
1192         hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
1193         if(FAILED(hres))
1194             break;
1195
1196         hres = exprval_to_value(ctx, &exprval, &rt->ei, &cval);
1197         exprval_release(&exprval);
1198         if(FAILED(hres))
1199             break;
1200
1201         hres = equal2_values(&val, &cval, &b);
1202         VariantClear(&cval);
1203         if(FAILED(hres) || b)
1204             break;
1205     }
1206
1207     VariantClear(&val);
1208     if(FAILED(hres))
1209         return hres;
1210
1211     if(!iter)
1212         iter = default_clausule;
1213
1214     V_VT(&val) = VT_EMPTY;
1215     if(iter) {
1216         VARIANT tmp;
1217
1218         for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1219             hres = stat_eval(ctx, stat_iter, rt, &tmp);
1220             if(FAILED(hres))
1221                 break;
1222
1223             VariantClear(&val);
1224             val = tmp;
1225
1226             if(rt->type != RT_NORMAL)
1227                 break;
1228         }
1229     }
1230
1231     if(FAILED(hres)) {
1232         VariantClear(&val);
1233         return hres;
1234     }
1235
1236     if(rt->type == RT_BREAK)
1237         rt->type = RT_NORMAL;
1238
1239     *ret = val;
1240     return S_OK;
1241 }
1242
1243 /* ECMA-262 3rd Edition    12.13 */
1244 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1245 {
1246     expression_statement_t *stat = (expression_statement_t*)_stat;
1247     exprval_t exprval;
1248     VARIANT val;
1249     HRESULT hres;
1250
1251     TRACE("\n");
1252
1253     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1254     if(FAILED(hres))
1255         return hres;
1256
1257     hres = exprval_to_value(ctx, &exprval, &rt->ei, &val);
1258     exprval_release(&exprval);
1259     if(FAILED(hres))
1260         return hres;
1261
1262     rt->ei.var = val;
1263     return DISP_E_EXCEPTION;
1264 }
1265
1266 /* ECMA-262 3rd Edition    12.14 */
1267 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1268 {
1269     jsdisp_t *var_disp;
1270     VARIANT ex, val;
1271     HRESULT hres;
1272
1273     ex = rt->ei.var;
1274     memset(&rt->ei, 0, sizeof(jsexcept_t));
1275
1276     hres = create_dispex(ctx, NULL, NULL, &var_disp);
1277     if(SUCCEEDED(hres)) {
1278         hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1279         if(SUCCEEDED(hres)) {
1280             hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1281             if(SUCCEEDED(hres)) {
1282                 hres = stat_eval(ctx, block->statement, rt, &val);
1283                 scope_pop(&ctx->exec_ctx->scope_chain);
1284             }
1285         }
1286
1287         jsdisp_release(var_disp);
1288     }
1289
1290     VariantClear(&ex);
1291     if(FAILED(hres))
1292         return hres;
1293
1294     *ret = val;
1295     return S_OK;
1296 }
1297
1298 /* ECMA-262 3rd Edition    12.14 */
1299 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1300 {
1301     try_statement_t *stat = (try_statement_t*)_stat;
1302     VARIANT val;
1303     HRESULT hres;
1304
1305     TRACE("\n");
1306
1307     hres = stat_eval(ctx, stat->try_statement, rt, &val);
1308     if(FAILED(hres)) {
1309         TRACE("EXCEPTION\n");
1310         if(!stat->catch_block)
1311             return hres;
1312
1313         hres = catch_eval(ctx, stat->catch_block, rt, &val);
1314         if(FAILED(hres))
1315             return hres;
1316     }
1317
1318     if(stat->finally_statement) {
1319         VariantClear(&val);
1320         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1321         if(FAILED(hres))
1322             return hres;
1323     }
1324
1325     *ret = val;
1326     return S_OK;
1327 }
1328
1329 static HRESULT return_bool(exprval_t *ret, DWORD b)
1330 {
1331     ret->type = EXPRVAL_VARIANT;
1332     V_VT(&ret->u.var) = VT_BOOL;
1333     V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1334
1335     return S_OK;
1336 }
1337
1338 static HRESULT get_binary_expr_values(script_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
1339 {
1340     exprval_t exprval;
1341     HRESULT hres;
1342
1343     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1344     if(FAILED(hres))
1345         return hres;
1346
1347     hres = exprval_to_value(ctx, &exprval, ei, lval);
1348     exprval_release(&exprval);
1349     if(FAILED(hres))
1350         return hres;
1351
1352     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1353     if(SUCCEEDED(hres)) {
1354         hres = exprval_to_value(ctx, &exprval, ei, rval);
1355         exprval_release(&exprval);
1356     }
1357
1358     if(FAILED(hres)) {
1359         VariantClear(lval);
1360         return hres;
1361     }
1362
1363     return S_OK;
1364 }
1365
1366 typedef HRESULT (*oper_t)(script_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
1367
1368 static HRESULT binary_expr_eval(script_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
1369         exprval_t *ret)
1370 {
1371     VARIANT lval, rval, retv;
1372     HRESULT hres;
1373
1374     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1375     if(FAILED(hres))
1376         return hres;
1377
1378     hres = oper(ctx, &lval, &rval, ei, &retv);
1379     VariantClear(&lval);
1380     VariantClear(&rval);
1381     if(FAILED(hres))
1382         return hres;
1383
1384     ret->type = EXPRVAL_VARIANT;
1385     ret->u.var = retv;
1386     return S_OK;
1387 }
1388
1389 /* ECMA-262 3rd Edition    11.13.2 */
1390 static HRESULT assign_oper_eval(script_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1391                                 jsexcept_t *ei, exprval_t *ret)
1392 {
1393     VARIANT retv, lval, rval;
1394     exprval_t exprval, exprvalr;
1395     HRESULT hres;
1396
1397     hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1398     if(FAILED(hres))
1399         return hres;
1400
1401     hres = exprval_value(ctx, &exprval, ei, &lval);
1402     if(SUCCEEDED(hres)) {
1403         hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1404         if(SUCCEEDED(hres)) {
1405             hres = exprval_value(ctx, &exprvalr, ei, &rval);
1406             exprval_release(&exprvalr);
1407         }
1408         if(SUCCEEDED(hres)) {
1409             hres = oper(ctx, &lval, &rval, ei, &retv);
1410             VariantClear(&rval);
1411         }
1412         VariantClear(&lval);
1413     }
1414
1415     if(SUCCEEDED(hres)) {
1416         hres = put_value(ctx, &exprval, &retv, ei);
1417         if(FAILED(hres))
1418             VariantClear(&retv);
1419     }
1420     exprval_release(&exprval);
1421
1422     if(FAILED(hres))
1423         return hres;
1424
1425     ret->type = EXPRVAL_VARIANT;
1426     ret->u.var = retv;
1427     return S_OK;
1428 }
1429
1430 /* ECMA-262 3rd Edition    13 */
1431 HRESULT function_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1432 {
1433     function_expression_t *expr = (function_expression_t*)_expr;
1434     VARIANT var;
1435     HRESULT hres;
1436
1437     TRACE("\n");
1438
1439     if(expr->identifier) {
1440         hres = jsdisp_propget_name(ctx->exec_ctx->var_disp, expr->identifier, &var, ei, NULL/*FIXME*/);
1441         if(FAILED(hres))
1442             return hres;
1443     }else {
1444         jsdisp_t *dispex;
1445
1446         hres = create_source_function(ctx->exec_ctx->parser, expr->parameter_list, expr->source_elements, ctx->exec_ctx->scope_chain,
1447                 expr->src_str, expr->src_len, &dispex);
1448         if(FAILED(hres))
1449             return hres;
1450
1451         var_set_jsdisp(&var, dispex);
1452     }
1453
1454     ret->type = EXPRVAL_VARIANT;
1455     ret->u.var = var;
1456     return S_OK;
1457 }
1458
1459 /* ECMA-262 3rd Edition    11.2.1 */
1460 HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1461 {
1462     array_expression_t *expr = (array_expression_t*)_expr;
1463     exprval_t exprval;
1464     VARIANT member, val;
1465     DISPID id;
1466     BSTR str;
1467     IDispatch *obj = NULL;
1468     HRESULT hres;
1469
1470     TRACE("\n");
1471
1472     hres = expr_eval(ctx, expr->member_expr, 0, ei, &exprval);
1473     if(FAILED(hres))
1474         return hres;
1475
1476     hres = exprval_to_value(ctx, &exprval, ei, &member);
1477     exprval_release(&exprval);
1478     if(FAILED(hres))
1479         return hres;
1480
1481     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1482     if(SUCCEEDED(hres)) {
1483         hres = exprval_to_value(ctx, &exprval, ei, &val);
1484         exprval_release(&exprval);
1485     }
1486
1487     if(SUCCEEDED(hres)) {
1488         hres = to_object(ctx, &member, &obj);
1489         if(FAILED(hres))
1490             VariantClear(&val);
1491     }
1492     VariantClear(&member);
1493     if(SUCCEEDED(hres)) {
1494         hres = to_string(ctx, &val, ei, &str);
1495         VariantClear(&val);
1496         if(SUCCEEDED(hres)) {
1497             if(flags & EXPR_STRREF) {
1498                 ret->type = EXPRVAL_NAMEREF;
1499                 ret->u.nameref.disp = obj;
1500                 ret->u.nameref.name = str;
1501                 return S_OK;
1502             }
1503
1504             hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1505             SysFreeString(str);
1506         }
1507
1508         if(SUCCEEDED(hres)) {
1509             exprval_set_idref(ret, obj, id);
1510         }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1511             exprval_init(ret);
1512             hres = S_OK;
1513         }
1514
1515         IDispatch_Release(obj);
1516     }
1517
1518     return hres;
1519 }
1520
1521 /* ECMA-262 3rd Edition    11.2.1 */
1522 HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1523 {
1524     member_expression_t *expr = (member_expression_t*)_expr;
1525     IDispatch *obj = NULL;
1526     exprval_t exprval;
1527     VARIANT member;
1528     DISPID id;
1529     BSTR str;
1530     HRESULT hres;
1531
1532     TRACE("\n");
1533
1534     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1535     if(FAILED(hres))
1536         return hres;
1537
1538     hres = exprval_to_value(ctx, &exprval, ei, &member);
1539     exprval_release(&exprval);
1540     if(FAILED(hres))
1541         return hres;
1542
1543     hres = to_object(ctx, &member, &obj);
1544     VariantClear(&member);
1545     if(FAILED(hres))
1546         return hres;
1547
1548     str = SysAllocString(expr->identifier);
1549     if(flags & EXPR_STRREF) {
1550         ret->type = EXPRVAL_NAMEREF;
1551         ret->u.nameref.disp = obj;
1552         ret->u.nameref.name = str;
1553         return S_OK;
1554     }
1555
1556     hres = disp_get_id(ctx, obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1557     SysFreeString(str);
1558     if(SUCCEEDED(hres)) {
1559         exprval_set_idref(ret, obj, id);
1560     }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1561         exprval_init(ret);
1562         hres = S_OK;
1563     }
1564
1565     IDispatch_Release(obj);
1566     return hres;
1567 }
1568
1569 static void free_dp(DISPPARAMS *dp)
1570 {
1571     DWORD i;
1572
1573     for(i=0; i < dp->cArgs; i++)
1574         VariantClear(dp->rgvarg+i);
1575     heap_free(dp->rgvarg);
1576 }
1577
1578 static HRESULT args_to_param(script_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1579 {
1580     VARIANTARG *vargs;
1581     exprval_t exprval;
1582     argument_t *iter;
1583     DWORD cnt = 0, i;
1584     HRESULT hres = S_OK;
1585
1586     memset(dp, 0, sizeof(*dp));
1587     if(!args)
1588         return S_OK;
1589
1590     for(iter = args; iter; iter = iter->next)
1591         cnt++;
1592
1593     vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1594     if(!vargs)
1595         return E_OUTOFMEMORY;
1596
1597     for(i = cnt, iter = args; iter; iter = iter->next) {
1598         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1599         if(FAILED(hres))
1600             break;
1601
1602         hres = exprval_to_value(ctx, &exprval, ei, vargs + (--i));
1603         exprval_release(&exprval);
1604         if(FAILED(hres))
1605             break;
1606     }
1607
1608     if(FAILED(hres)) {
1609         free_dp(dp);
1610         return hres;
1611     }
1612
1613     dp->rgvarg = vargs;
1614     dp->cArgs = cnt;
1615     return S_OK;
1616 }
1617
1618 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1619 {
1620     VARIANT tmp;
1621     unsigned i;
1622
1623     dp->cArgs = arg_cnt;
1624     dp->rgdispidNamedArgs = NULL;
1625     dp->cNamedArgs = 0;
1626
1627     assert(ctx->top >= arg_cnt);
1628
1629     for(i=1; i*2 <= arg_cnt; i++) {
1630         tmp = ctx->stack[ctx->top-i];
1631         ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1632         ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1633     }
1634
1635     dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1636 }
1637
1638 /* ECMA-262 3rd Edition    11.2.2 */
1639 static HRESULT interp_new(exec_ctx_t *ctx)
1640 {
1641     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1642     VARIANT *constr, v;
1643     DISPPARAMS dp;
1644     HRESULT hres;
1645
1646     TRACE("%d\n", arg);
1647
1648     constr = stack_topn(ctx, arg);
1649
1650     /* NOTE: Should use to_object here */
1651
1652     if(V_VT(constr) == VT_NULL)
1653         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1654     else if(V_VT(constr) != VT_DISPATCH)
1655         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1656     else if(!V_DISPATCH(constr))
1657         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1658
1659     jsstack_to_dp(ctx, arg, &dp);
1660     hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1661             DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1662     if(FAILED(hres))
1663         return hres;
1664
1665     stack_popn(ctx, arg+1);
1666     return stack_push(ctx, &v);
1667 }
1668
1669 /* ECMA-262 3rd Edition    11.2.3 */
1670 HRESULT call_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1671 {
1672     call_expression_t *expr = (call_expression_t*)_expr;
1673     VARIANT var;
1674     exprval_t exprval;
1675     DISPPARAMS dp;
1676     HRESULT hres;
1677
1678     TRACE("\n");
1679
1680     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1681     if(FAILED(hres))
1682         return hres;
1683
1684     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1685     if(SUCCEEDED(hres)) {
1686         switch(exprval.type) {
1687         case EXPRVAL_VARIANT:
1688             if(V_VT(&exprval.u.var) == VT_DISPATCH)
1689                 hres = disp_call(ctx, V_DISPATCH(&exprval.u.var), DISPID_VALUE,
1690                         DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1691             else
1692                 hres = throw_type_error(ctx, ei, JS_E_INVALID_PROPERTY, NULL);
1693             break;
1694         case EXPRVAL_IDREF:
1695             hres = disp_call(ctx, exprval.u.idref.disp, exprval.u.idref.id,
1696                     DISPATCH_METHOD, &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1697             break;
1698         case EXPRVAL_INVALID:
1699             hres = throw_type_error(ctx, ei, JS_E_OBJECT_EXPECTED, NULL);
1700             break;
1701         default:
1702             FIXME("unimplemented type %d\n", exprval.type);
1703             hres = E_NOTIMPL;
1704         }
1705
1706         free_dp(&dp);
1707     }
1708
1709     exprval_release(&exprval);
1710     if(FAILED(hres))
1711         return hres;
1712
1713     ret->type = EXPRVAL_VARIANT;
1714     if(flags & EXPR_NOVAL) {
1715         V_VT(&ret->u.var) = VT_EMPTY;
1716     }else {
1717         TRACE("= %s\n", debugstr_variant(&var));
1718         ret->u.var = var;
1719     }
1720     return S_OK;
1721 }
1722
1723 /* ECMA-262 3rd Edition    11.1.1 */
1724 static HRESULT interp_this(exec_ctx_t *ctx)
1725 {
1726     VARIANT v;
1727
1728     TRACE("\n");
1729
1730     V_VT(&v) = VT_DISPATCH;
1731     V_DISPATCH(&v) = ctx->this_obj;
1732     IDispatch_AddRef(ctx->this_obj);
1733     return stack_push(ctx, &v);
1734 }
1735
1736 /* ECMA-262 3rd Edition    10.1.4 */
1737 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1738 {
1739     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1740     BSTR identifier;
1741     HRESULT hres;
1742
1743     TRACE("\n");
1744
1745     identifier = SysAllocString(expr->identifier);
1746     if(!identifier)
1747         return E_OUTOFMEMORY;
1748
1749     hres = identifier_eval(ctx, identifier, flags, ei, ret);
1750
1751     SysFreeString(identifier);
1752     return hres;
1753 }
1754
1755 /* ECMA-262 3rd Edition    10.1.4 */
1756 static HRESULT interp_ident(exec_ctx_t *ctx)
1757 {
1758     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1759     exprval_t exprval;
1760     VARIANT v;
1761     HRESULT hres;
1762
1763     TRACE("%s\n", debugstr_w(arg));
1764
1765     hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1766     if(FAILED(hres))
1767         return hres;
1768
1769     hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1770     exprval_release(&exprval);
1771     if(FAILED(hres))
1772         return hres;
1773
1774     return stack_push(ctx, &v);
1775 }
1776
1777 /* ECMA-262 3rd Edition    7.8.1 */
1778 static HRESULT interp_null(exec_ctx_t *ctx)
1779 {
1780     VARIANT v;
1781
1782     TRACE("\n");
1783
1784     V_VT(&v) = VT_NULL;
1785     return stack_push(ctx, &v);
1786 }
1787
1788 /* ECMA-262 3rd Edition    7.8.2 */
1789 static HRESULT interp_bool(exec_ctx_t *ctx)
1790 {
1791     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1792
1793     TRACE("%s\n", arg ? "true" : "false");
1794
1795     return stack_push_bool(ctx, arg);
1796 }
1797
1798 /* ECMA-262 3rd Edition    7.8.3 */
1799 static HRESULT interp_int(exec_ctx_t *ctx)
1800 {
1801     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1802     VARIANT v;
1803
1804     TRACE("%d\n", arg);
1805
1806     V_VT(&v) = VT_I4;
1807     V_I4(&v) = arg;
1808     return stack_push(ctx, &v);
1809 }
1810
1811 /* ECMA-262 3rd Edition    7.8.3 */
1812 static HRESULT interp_double(exec_ctx_t *ctx)
1813 {
1814     const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1815     VARIANT v;
1816
1817     TRACE("%lf\n", arg);
1818
1819     V_VT(&v) = VT_R8;
1820     V_R8(&v) = arg;
1821     return stack_push(ctx, &v);
1822 }
1823
1824 /* ECMA-262 3rd Edition    7.8.4 */
1825 static HRESULT interp_str(exec_ctx_t *ctx)
1826 {
1827     const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1828     VARIANT v;
1829
1830     TRACE("%s\n", debugstr_w(str));
1831
1832     V_VT(&v) = VT_BSTR;
1833     V_BSTR(&v) = SysAllocString(str);
1834     if(!V_BSTR(&v))
1835         return E_OUTOFMEMORY;
1836
1837     return stack_push(ctx, &v);
1838 }
1839
1840 /* ECMA-262 3rd Edition    7.8 */
1841 static HRESULT interp_regexp(exec_ctx_t *ctx)
1842 {
1843     const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1844     const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1845     jsdisp_t *regexp;
1846     VARIANT v;
1847     HRESULT hres;
1848
1849     TRACE("%s %x\n", debugstr_w(source), flags);
1850
1851     hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, &regexp);
1852     if(FAILED(hres))
1853         return hres;
1854
1855     var_set_jsdisp(&v, regexp);
1856     return stack_push(ctx, &v);
1857 }
1858
1859 /* ECMA-262 3rd Edition    11.1.4 */
1860 HRESULT array_literal_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1861 {
1862     array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
1863     DWORD length = 0, i = 0;
1864     array_element_t *elem;
1865     jsdisp_t *array;
1866     exprval_t exprval;
1867     VARIANT val;
1868     HRESULT hres;
1869
1870     TRACE("\n");
1871
1872     for(elem = expr->element_list; elem; elem = elem->next)
1873         length += elem->elision+1;
1874     length += expr->length;
1875
1876     hres = create_array(ctx, length, &array);
1877     if(FAILED(hres))
1878         return hres;
1879
1880     for(elem = expr->element_list; elem; elem = elem->next) {
1881         i += elem->elision;
1882
1883         hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
1884         if(FAILED(hres))
1885             break;
1886
1887         hres = exprval_to_value(ctx, &exprval, ei, &val);
1888         exprval_release(&exprval);
1889         if(FAILED(hres))
1890             break;
1891
1892         hres = jsdisp_propput_idx(array, i, &val, ei, NULL/*FIXME*/);
1893         VariantClear(&val);
1894         if(FAILED(hres))
1895             break;
1896
1897         i++;
1898     }
1899
1900     if(FAILED(hres)) {
1901         jsdisp_release(array);
1902         return hres;
1903     }
1904
1905     ret->type = EXPRVAL_VARIANT;
1906     var_set_jsdisp(&ret->u.var, array);
1907     return S_OK;
1908 }
1909
1910 /* ECMA-262 3rd Edition    11.1.5 */
1911 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1912 {
1913     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1914     VARIANT val, tmp;
1915     jsdisp_t *obj;
1916     prop_val_t *iter;
1917     exprval_t exprval;
1918     BSTR name;
1919     HRESULT hres;
1920
1921     TRACE("\n");
1922
1923     hres = create_object(ctx, NULL, &obj);
1924     if(FAILED(hres))
1925         return hres;
1926
1927     for(iter = expr->property_list; iter; iter = iter->next) {
1928         hres = literal_to_var(ctx, iter->name, &tmp);
1929         if(FAILED(hres))
1930             break;
1931
1932         hres = to_string(ctx, &tmp, ei, &name);
1933         VariantClear(&tmp);
1934         if(FAILED(hres))
1935             break;
1936
1937         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1938         if(SUCCEEDED(hres)) {
1939             hres = exprval_to_value(ctx, &exprval, ei, &val);
1940             exprval_release(&exprval);
1941             if(SUCCEEDED(hres)) {
1942                 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
1943                 VariantClear(&val);
1944             }
1945         }
1946
1947         SysFreeString(name);
1948         if(FAILED(hres))
1949             break;
1950     }
1951
1952     if(FAILED(hres)) {
1953         jsdisp_release(obj);
1954         return hres;
1955     }
1956
1957     ret->type = EXPRVAL_VARIANT;
1958     var_set_jsdisp(&ret->u.var, obj);
1959     return S_OK;
1960 }
1961
1962 /* ECMA-262 3rd Edition    11.11 */
1963 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
1964 {
1965     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1966     VARIANT_BOOL b;
1967     HRESULT hres;
1968
1969     TRACE("\n");
1970
1971     hres = to_boolean(stack_top(ctx), &b);
1972     if(FAILED(hres))
1973         return hres;
1974
1975     if(b) {
1976         ctx->ip = arg;
1977     }else {
1978         stack_popn(ctx, 1);
1979         ctx->ip++;
1980     }
1981     return S_OK;
1982 }
1983
1984 /* ECMA-262 3rd Edition    11.11 */
1985 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
1986 {
1987     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1988     VARIANT_BOOL b;
1989     HRESULT hres;
1990
1991     TRACE("\n");
1992
1993     hres = to_boolean(stack_top(ctx), &b);
1994     if(FAILED(hres))
1995         return hres;
1996
1997     if(b) {
1998         stack_popn(ctx, 1);
1999         ctx->ip++;
2000     }else {
2001         ctx->ip = arg;
2002     }
2003     return S_OK;
2004 }
2005
2006 /* ECMA-262 3rd Edition    11.10 */
2007 static HRESULT bitor_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2008 {
2009     INT li, ri;
2010     HRESULT hres;
2011
2012     hres = to_int32(ctx, lval, ei, &li);
2013     if(FAILED(hres))
2014         return hres;
2015
2016     hres = to_int32(ctx, rval, ei, &ri);
2017     if(FAILED(hres))
2018         return hres;
2019
2020     V_VT(retv) = VT_I4;
2021     V_I4(retv) = li|ri;
2022     return S_OK;
2023 }
2024
2025 /* ECMA-262 3rd Edition    11.10 */
2026 static HRESULT interp_or(exec_ctx_t *ctx)
2027 {
2028     INT l, r;
2029     HRESULT hres;
2030
2031     TRACE("\n");
2032
2033     hres = stack_pop_int(ctx, &r);
2034     if(FAILED(hres))
2035         return hres;
2036
2037     hres = stack_pop_int(ctx, &l);
2038     if(FAILED(hres))
2039         return hres;
2040
2041     return stack_push_int(ctx, l|r);
2042 }
2043
2044 /* ECMA-262 3rd Edition    11.10 */
2045 static HRESULT xor_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2046 {
2047     INT li, ri;
2048     HRESULT hres;
2049
2050     hres = to_int32(ctx, lval, ei, &li);
2051     if(FAILED(hres))
2052         return hres;
2053
2054     hres = to_int32(ctx, rval, ei, &ri);
2055     if(FAILED(hres))
2056         return hres;
2057
2058     V_VT(retv) = VT_I4;
2059     V_I4(retv) = li^ri;
2060     return S_OK;
2061 }
2062
2063 /* ECMA-262 3rd Edition    11.10 */
2064 static HRESULT interp_xor(exec_ctx_t *ctx)
2065 {
2066     INT l, r;
2067     HRESULT hres;
2068
2069     TRACE("\n");
2070
2071     hres = stack_pop_int(ctx, &r);
2072     if(FAILED(hres))
2073         return hres;
2074
2075     hres = stack_pop_int(ctx, &l);
2076     if(FAILED(hres))
2077         return hres;
2078
2079     return stack_push_int(ctx, l^r);
2080 }
2081
2082 /* ECMA-262 3rd Edition    11.10 */
2083 static HRESULT bitand_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2084 {
2085     INT li, ri;
2086     HRESULT hres;
2087
2088     hres = to_int32(ctx, lval, ei, &li);
2089     if(FAILED(hres))
2090         return hres;
2091
2092     hres = to_int32(ctx, rval, ei, &ri);
2093     if(FAILED(hres))
2094         return hres;
2095
2096     V_VT(retv) = VT_I4;
2097     V_I4(retv) = li&ri;
2098     return S_OK;
2099 }
2100
2101 /* ECMA-262 3rd Edition    11.10 */
2102 HRESULT binary_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2103 {
2104     binary_expression_t *expr = (binary_expression_t*)_expr;
2105
2106     TRACE("\n");
2107
2108     return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
2109 }
2110
2111 /* ECMA-262 3rd Edition    11.8.6 */
2112 static HRESULT instanceof_eval(script_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
2113 {
2114     jsdisp_t *obj, *iter, *tmp = NULL;
2115     VARIANT_BOOL ret = VARIANT_FALSE;
2116     BOOL b;
2117     VARIANT var;
2118     HRESULT hres;
2119
2120     static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2121
2122     if(V_VT(objv) != VT_DISPATCH || !V_DISPATCH(objv))
2123         return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2124
2125     obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
2126     if(!obj) {
2127         FIXME("non-jsdisp objects not supported\n");
2128         return E_FAIL;
2129     }
2130
2131     if(is_class(obj, JSCLASS_FUNCTION)) {
2132         hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
2133     }else {
2134         hres = throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2135     }
2136     jsdisp_release(obj);
2137     if(FAILED(hres))
2138         return hres;
2139
2140     if(V_VT(&var) == VT_DISPATCH) {
2141         if(V_VT(inst) == VT_DISPATCH)
2142             tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
2143         for(iter = tmp; iter; iter = iter->prototype) {
2144             hres = disp_cmp(V_DISPATCH(&var), to_disp(iter), &b);
2145             if(FAILED(hres))
2146                 break;
2147             if(b) {
2148                 ret = VARIANT_TRUE;
2149                 break;
2150             }
2151         }
2152
2153         if(tmp)
2154             jsdisp_release(tmp);
2155     }else {
2156         FIXME("prototype is not an object\n");
2157         hres = E_FAIL;
2158     }
2159
2160     VariantClear(&var);
2161     if(FAILED(hres))
2162         return hres;
2163
2164     V_VT(retv) = VT_BOOL;
2165     V_BOOL(retv) = ret;
2166     return S_OK;
2167 }
2168
2169 /* ECMA-262 3rd Edition    11.8.6 */
2170 HRESULT instanceof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2171 {
2172     binary_expression_t *expr = (binary_expression_t*)_expr;
2173
2174     TRACE("\n");
2175
2176     return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
2177 }
2178
2179 /* ECMA-262 3rd Edition    11.8.7 */
2180 static HRESULT interp_in(exec_ctx_t *ctx)
2181 {
2182     VARIANT *obj, *v;
2183     DISPID id = 0;
2184     BOOL ret;
2185     BSTR str;
2186     HRESULT hres;
2187
2188     TRACE("\n");
2189
2190     obj = stack_pop(ctx);
2191     v = stack_pop(ctx);
2192
2193     if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2194         VariantClear(obj);
2195         VariantClear(v);
2196         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2197     }
2198
2199     hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2200     VariantClear(v);
2201     if(FAILED(hres)) {
2202         IDispatch_Release(V_DISPATCH(obj));
2203         return hres;
2204     }
2205
2206     hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2207     IDispatch_Release(V_DISPATCH(obj));
2208     SysFreeString(str);
2209     if(SUCCEEDED(hres))
2210         ret = TRUE;
2211     else if(hres == DISP_E_UNKNOWNNAME)
2212         ret = FALSE;
2213     else
2214         return hres;
2215
2216     return stack_push_bool(ctx, ret);
2217 }
2218
2219 /* ECMA-262 3rd Edition    11.6.1 */
2220 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2221 {
2222     VARIANT r, l;
2223     HRESULT hres;
2224
2225     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2226     if(FAILED(hres))
2227         return hres;
2228
2229     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2230     if(FAILED(hres)) {
2231         VariantClear(&l);
2232         return hres;
2233     }
2234
2235     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2236         BSTR lstr = NULL, rstr = NULL;
2237
2238         if(V_VT(&l) == VT_BSTR)
2239             lstr = V_BSTR(&l);
2240         else
2241             hres = to_string(ctx, &l, ei, &lstr);
2242
2243         if(SUCCEEDED(hres)) {
2244             if(V_VT(&r) == VT_BSTR)
2245                 rstr = V_BSTR(&r);
2246             else
2247                 hres = to_string(ctx, &r, ei, &rstr);
2248         }
2249
2250         if(SUCCEEDED(hres)) {
2251             int len1, len2;
2252
2253             len1 = SysStringLen(lstr);
2254             len2 = SysStringLen(rstr);
2255
2256             V_VT(retv) = VT_BSTR;
2257             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2258             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2259             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2260         }
2261
2262         if(V_VT(&l) != VT_BSTR)
2263             SysFreeString(lstr);
2264         if(V_VT(&r) != VT_BSTR)
2265             SysFreeString(rstr);
2266     }else {
2267         VARIANT nl, nr;
2268
2269         hres = to_number(ctx, &l, ei, &nl);
2270         if(SUCCEEDED(hres)) {
2271             hres = to_number(ctx, &r, ei, &nr);
2272             if(SUCCEEDED(hres))
2273                 num_set_val(retv, num_val(&nl) + num_val(&nr));
2274         }
2275     }
2276
2277     VariantClear(&r);
2278     VariantClear(&l);
2279     return hres;
2280 }
2281
2282 /* ECMA-262 3rd Edition    11.6.1 */
2283 static HRESULT interp_add(exec_ctx_t *ctx)
2284 {
2285     VARIANT *l, *r, ret;
2286     HRESULT hres;
2287
2288     r = stack_pop(ctx);
2289     l = stack_pop(ctx);
2290
2291     TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2292
2293     hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2294     VariantClear(l);
2295     VariantClear(r);
2296     if(FAILED(hres))
2297         return hres;
2298
2299     return stack_push(ctx, &ret);
2300 }
2301
2302 /* ECMA-262 3rd Edition    11.6.2 */
2303 static HRESULT sub_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2304 {
2305     VARIANT lnum, rnum;
2306     HRESULT hres;
2307
2308     hres = to_number(ctx, lval, ei, &lnum);
2309     if(FAILED(hres))
2310         return hres;
2311
2312     hres = to_number(ctx, rval, ei, &rnum);
2313     if(FAILED(hres))
2314         return hres;
2315
2316     num_set_val(retv, num_val(&lnum) - num_val(&rnum));
2317     return S_OK;
2318 }
2319
2320 /* ECMA-262 3rd Edition    11.6.2 */
2321 static HRESULT interp_sub(exec_ctx_t *ctx)
2322 {
2323     VARIANT l, r;
2324     HRESULT hres;
2325
2326     TRACE("\n");
2327
2328     hres = stack_pop_number(ctx, &r);
2329     if(FAILED(hres))
2330         return hres;
2331
2332     hres = stack_pop_number(ctx, &l);
2333     if(FAILED(hres))
2334         return hres;
2335
2336     return stack_push_number(ctx, num_val(&l)-num_val(&r));
2337 }
2338
2339 /* ECMA-262 3rd Edition    11.5.1 */
2340 static HRESULT mul_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2341 {
2342     VARIANT lnum, rnum;
2343     HRESULT hres;
2344
2345     hres = to_number(ctx, lval, ei, &lnum);
2346     if(FAILED(hres))
2347         return hres;
2348
2349     hres = to_number(ctx, rval, ei, &rnum);
2350     if(FAILED(hres))
2351         return hres;
2352
2353     num_set_val(retv, num_val(&lnum) * num_val(&rnum));
2354     return S_OK;
2355 }
2356
2357 /* ECMA-262 3rd Edition    11.5.1 */
2358 static HRESULT interp_mul(exec_ctx_t *ctx)
2359 {
2360     VARIANT l, r;
2361     HRESULT hres;
2362
2363     TRACE("\n");
2364
2365     hres = stack_pop_number(ctx, &r);
2366     if(FAILED(hres))
2367         return hres;
2368
2369     hres = stack_pop_number(ctx, &l);
2370     if(FAILED(hres))
2371         return hres;
2372
2373     return stack_push_number(ctx, num_val(&l)*num_val(&r));
2374 }
2375
2376 /* ECMA-262 3rd Edition    11.5.2 */
2377 static HRESULT div_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2378 {
2379     VARIANT lnum, rnum;
2380     HRESULT hres;
2381
2382     hres = to_number(ctx, lval, ei, &lnum);
2383     if(FAILED(hres))
2384         return hres;
2385
2386     hres = to_number(ctx, rval, ei, &rnum);
2387     if(FAILED(hres))
2388         return hres;
2389
2390     num_set_val(retv, num_val(&lnum) / num_val(&rnum));
2391     return S_OK;
2392 }
2393
2394 /* ECMA-262 3rd Edition    11.5.2 */
2395 static HRESULT interp_div(exec_ctx_t *ctx)
2396 {
2397     VARIANT l, r;
2398     HRESULT hres;
2399
2400     TRACE("\n");
2401
2402     hres = stack_pop_number(ctx, &r);
2403     if(FAILED(hres))
2404         return hres;
2405
2406     hres = stack_pop_number(ctx, &l);
2407     if(FAILED(hres))
2408         return hres;
2409
2410     return stack_push_number(ctx, num_val(&l)/num_val(&r));
2411 }
2412
2413 /* ECMA-262 3rd Edition    11.5.3 */
2414 static HRESULT mod_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2415 {
2416     VARIANT lnum, rnum;
2417     HRESULT hres;
2418
2419     hres = to_number(ctx, lval, ei, &lnum);
2420     if(FAILED(hres))
2421         return hres;
2422
2423     hres = to_number(ctx, rval, ei, &rnum);
2424     if(FAILED(hres))
2425         return hres;
2426
2427     num_set_val(retv, fmod(num_val(&lnum), num_val(&rnum)));
2428     return S_OK;
2429 }
2430
2431 /* ECMA-262 3rd Edition    11.5.3 */
2432 static HRESULT interp_mod(exec_ctx_t *ctx)
2433 {
2434     VARIANT l, r;
2435     HRESULT hres;
2436
2437     TRACE("\n");
2438
2439     hres = stack_pop_number(ctx, &r);
2440     if(FAILED(hres))
2441         return hres;
2442
2443     hres = stack_pop_number(ctx, &l);
2444     if(FAILED(hres))
2445         return hres;
2446
2447     return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2448 }
2449
2450 /* ECMA-262 3rd Edition    11.4.2 */
2451 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2452 {
2453     unary_expression_t *expr = (unary_expression_t*)_expr;
2454     VARIANT_BOOL b = VARIANT_FALSE;
2455     exprval_t exprval;
2456     HRESULT hres;
2457
2458     TRACE("\n");
2459
2460     hres = expr_eval(ctx, expr->expression, EXPR_STRREF, ei, &exprval);
2461     if(FAILED(hres))
2462         return hres;
2463
2464     switch(exprval.type) {
2465     case EXPRVAL_IDREF: {
2466         IDispatchEx *dispex;
2467
2468         hres = IDispatch_QueryInterface(exprval.u.nameref.disp, &IID_IDispatchEx, (void**)&dispex);
2469         if(SUCCEEDED(hres)) {
2470             hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2471             b = VARIANT_TRUE;
2472             IDispatchEx_Release(dispex);
2473         }
2474         break;
2475     }
2476     case EXPRVAL_NAMEREF: {
2477         IDispatchEx *dispex;
2478
2479         hres = IDispatch_QueryInterface(exprval.u.nameref.disp, &IID_IDispatchEx, (void**)&dispex);
2480         if(SUCCEEDED(hres)) {
2481             hres = IDispatchEx_DeleteMemberByName(dispex, exprval.u.nameref.name,
2482                     make_grfdex(ctx, fdexNameCaseSensitive));
2483             b = VARIANT_TRUE;
2484             IDispatchEx_Release(dispex);
2485         }
2486         break;
2487     }
2488     default:
2489         FIXME("unsupported type %d\n", exprval.type);
2490         hres = E_NOTIMPL;
2491     }
2492
2493     exprval_release(&exprval);
2494     if(FAILED(hres))
2495         return hres;
2496
2497     return return_bool(ret, b);
2498 }
2499
2500 /* ECMA-262 3rd Edition    11.4.2 */
2501 static HRESULT interp_delete(exec_ctx_t *ctx)
2502 {
2503     VARIANT *obj_var, *name_var;
2504     IDispatchEx *dispex;
2505     IDispatch *obj;
2506     BSTR name;
2507     BOOL ret;
2508     HRESULT hres;
2509
2510     TRACE("\n");
2511
2512     name_var = stack_pop(ctx);
2513     obj_var = stack_pop(ctx);
2514
2515     hres = to_object(ctx->parser->script, obj_var, &obj);
2516     VariantClear(obj_var);
2517     if(FAILED(hres)) {
2518         VariantClear(name_var);
2519         return hres;
2520     }
2521
2522     hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2523     VariantClear(name_var);
2524     if(FAILED(hres)) {
2525         IDispatch_Release(obj);
2526         return hres;
2527     }
2528
2529     hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2530     if(SUCCEEDED(hres)) {
2531         hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2532         ret = TRUE;
2533         IDispatchEx_Release(dispex);
2534     }else {
2535         hres = S_OK;
2536         ret = FALSE;
2537     }
2538
2539     IDispatch_Release(obj);
2540     SysFreeString(name);
2541     if(FAILED(hres))
2542         return hres;
2543
2544     return stack_push_bool(ctx, ret);
2545 }
2546
2547 /* ECMA-262 3rd Edition    11.4.2 */
2548 static HRESULT interp_void(exec_ctx_t *ctx)
2549 {
2550     VARIANT v;
2551
2552     TRACE("\n");
2553
2554     stack_popn(ctx, 1);
2555
2556     V_VT(&v) = VT_EMPTY;
2557     return stack_push(ctx, &v);
2558 }
2559
2560 /* ECMA-262 3rd Edition    11.4.3 */
2561 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2562 {
2563     VARIANT val;
2564     HRESULT hres;
2565
2566     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2567     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2568     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2569     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2570     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2571     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2572     static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2573
2574     if(exprval->type == EXPRVAL_INVALID) {
2575         *ret = undefinedW;
2576         return S_OK;
2577     }
2578
2579     hres = exprval_to_value(ctx, exprval, ei, &val);
2580     if(FAILED(hres)) {
2581         if(exprval->type == EXPRVAL_IDREF) {
2582             *ret = unknownW;
2583             return S_OK;
2584         }
2585         return hres;
2586     }
2587
2588     switch(V_VT(&val)) {
2589     case VT_EMPTY:
2590         *ret = undefinedW;
2591         break;
2592     case VT_NULL:
2593         *ret = objectW;
2594         break;
2595     case VT_BOOL:
2596         *ret = booleanW;
2597         break;
2598     case VT_I4:
2599     case VT_R8:
2600         *ret = numberW;
2601         break;
2602     case VT_BSTR:
2603         *ret = stringW;
2604         break;
2605     case VT_DISPATCH: {
2606         jsdisp_t *dispex;
2607
2608         if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2609             *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2610             jsdisp_release(dispex);
2611         }else {
2612             *ret = objectW;
2613         }
2614         break;
2615     }
2616     default:
2617         FIXME("unhandled vt %d\n", V_VT(&val));
2618         hres = E_NOTIMPL;
2619     }
2620
2621     VariantClear(&val);
2622     return hres;
2623 }
2624
2625 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2626 {
2627     unary_expression_t *expr = (unary_expression_t*)_expr;
2628     const WCHAR *str = NULL;
2629     exprval_t exprval;
2630     HRESULT hres;
2631
2632     TRACE("\n");
2633
2634     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2635     if(FAILED(hres))
2636         return hres;
2637
2638     hres = typeof_exprval(ctx, &exprval, ei, &str);
2639     exprval_release(&exprval);
2640     if(FAILED(hres))
2641         return hres;
2642
2643     ret->type = EXPRVAL_VARIANT;
2644     V_VT(&ret->u.var) = VT_BSTR;
2645     V_BSTR(&ret->u.var) = SysAllocString(str);
2646     if(!V_BSTR(&ret->u.var))
2647         return E_OUTOFMEMORY;
2648
2649     return S_OK;
2650 }
2651
2652 /* ECMA-262 3rd Edition    11.4.7 */
2653 static HRESULT interp_minus(exec_ctx_t *ctx)
2654 {
2655     VARIANT n;
2656     HRESULT hres;
2657
2658     TRACE("\n");
2659
2660     hres = stack_pop_number(ctx, &n);
2661     if(FAILED(hres))
2662         return hres;
2663
2664     return stack_push_number(ctx, -num_val(&n));
2665 }
2666
2667 /* ECMA-262 3rd Edition    11.4.6 */
2668 static HRESULT interp_tonum(exec_ctx_t *ctx)
2669 {
2670     VARIANT *v, num;
2671     HRESULT hres;
2672
2673     TRACE("\n");
2674
2675     v = stack_pop(ctx);
2676     hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2677     VariantClear(v);
2678     if(FAILED(hres))
2679         return hres;
2680
2681     return stack_push(ctx, &num);
2682 }
2683
2684 /* ECMA-262 3rd Edition    11.3.1 */
2685 HRESULT post_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2686 {
2687     unary_expression_t *expr = (unary_expression_t*)_expr;
2688     VARIANT val, num;
2689     exprval_t exprval;
2690     HRESULT hres;
2691
2692     TRACE("\n");
2693
2694     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2695     if(FAILED(hres))
2696         return hres;
2697
2698     hres = exprval_value(ctx, &exprval, ei, &val);
2699     if(SUCCEEDED(hres)) {
2700         hres = to_number(ctx, &val, ei, &num);
2701         VariantClear(&val);
2702     }
2703
2704     if(SUCCEEDED(hres)) {
2705         VARIANT inc;
2706         num_set_val(&inc, num_val(&num)+1.0);
2707         hres = put_value(ctx, &exprval, &inc, ei);
2708     }
2709
2710     exprval_release(&exprval);
2711     if(FAILED(hres))
2712         return hres;
2713
2714     ret->type = EXPRVAL_VARIANT;
2715     ret->u.var = num;
2716     return S_OK;
2717 }
2718
2719 /* ECMA-262 3rd Edition    11.3.2 */
2720 HRESULT post_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2721 {
2722     unary_expression_t *expr = (unary_expression_t*)_expr;
2723     VARIANT val, num;
2724     exprval_t exprval;
2725     HRESULT hres;
2726
2727     TRACE("\n");
2728
2729     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2730     if(FAILED(hres))
2731         return hres;
2732
2733     hres = exprval_value(ctx, &exprval, ei, &val);
2734     if(SUCCEEDED(hres)) {
2735         hres = to_number(ctx, &val, ei, &num);
2736         VariantClear(&val);
2737     }
2738
2739     if(SUCCEEDED(hres)) {
2740         VARIANT dec;
2741         num_set_val(&dec, num_val(&num)-1.0);
2742         hres = put_value(ctx, &exprval, &dec, ei);
2743     }
2744
2745     exprval_release(&exprval);
2746     if(FAILED(hres))
2747         return hres;
2748
2749     ret->type = EXPRVAL_VARIANT;
2750     ret->u.var = num;
2751     return S_OK;
2752 }
2753
2754 /* ECMA-262 3rd Edition    11.4.4 */
2755 HRESULT pre_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2756 {
2757     unary_expression_t *expr = (unary_expression_t*)_expr;
2758     VARIANT val, num;
2759     exprval_t exprval;
2760     HRESULT hres;
2761
2762     TRACE("\n");
2763
2764     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2765     if(FAILED(hres))
2766         return hres;
2767
2768     hres = exprval_value(ctx, &exprval, ei, &val);
2769     if(SUCCEEDED(hres)) {
2770         hres = to_number(ctx, &val, ei, &num);
2771         VariantClear(&val);
2772     }
2773
2774     if(SUCCEEDED(hres)) {
2775         num_set_val(&val, num_val(&num)+1.0);
2776         hres = put_value(ctx, &exprval, &val, ei);
2777     }
2778
2779     exprval_release(&exprval);
2780     if(FAILED(hres))
2781         return hres;
2782
2783     ret->type = EXPRVAL_VARIANT;
2784     ret->u.var = val;
2785     return S_OK;
2786 }
2787
2788 /* ECMA-262 3rd Edition    11.4.5 */
2789 HRESULT pre_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2790 {
2791     unary_expression_t *expr = (unary_expression_t*)_expr;
2792     VARIANT val, num;
2793     exprval_t exprval;
2794     HRESULT hres;
2795
2796     TRACE("\n");
2797
2798     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2799     if(FAILED(hres))
2800         return hres;
2801
2802     hres = exprval_value(ctx, &exprval, ei, &val);
2803     if(SUCCEEDED(hres)) {
2804         hres = to_number(ctx, &val, ei, &num);
2805         VariantClear(&val);
2806     }
2807
2808     if(SUCCEEDED(hres)) {
2809         num_set_val(&val, num_val(&num)-1.0);
2810         hres = put_value(ctx, &exprval, &val, ei);
2811     }
2812
2813     exprval_release(&exprval);
2814     if(FAILED(hres))
2815         return hres;
2816
2817     ret->type = EXPRVAL_VARIANT;
2818     ret->u.var = val;
2819     return S_OK;
2820 }
2821
2822 /* ECMA-262 3rd Edition    11.9.3 */
2823 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2824 {
2825     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2826        return equal2_values(lval, rval, ret);
2827
2828     /* FIXME: NULL disps should be handled in more general way */
2829     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2830         VARIANT v;
2831         V_VT(&v) = VT_NULL;
2832         return equal_values(ctx, &v, rval, ei, ret);
2833     }
2834
2835     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2836         VARIANT v;
2837         V_VT(&v) = VT_NULL;
2838         return equal_values(ctx, lval, &v, ei, ret);
2839     }
2840
2841     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2842        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2843         *ret = TRUE;
2844         return S_OK;
2845     }
2846
2847     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2848         VARIANT v;
2849         HRESULT hres;
2850
2851         hres = to_number(ctx, lval, ei, &v);
2852         if(FAILED(hres))
2853             return hres;
2854
2855         return equal_values(ctx, &v, rval, ei, ret);
2856     }
2857
2858     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2859         VARIANT v;
2860         HRESULT hres;
2861
2862         hres = to_number(ctx, rval, ei, &v);
2863         if(FAILED(hres))
2864             return hres;
2865
2866         return equal_values(ctx, lval, &v, ei, ret);
2867     }
2868
2869     if(V_VT(rval) == VT_BOOL) {
2870         VARIANT v;
2871
2872         V_VT(&v) = VT_I4;
2873         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2874         return equal_values(ctx, lval, &v, ei, ret);
2875     }
2876
2877     if(V_VT(lval) == VT_BOOL) {
2878         VARIANT v;
2879
2880         V_VT(&v) = VT_I4;
2881         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2882         return equal_values(ctx, &v, rval, ei, ret);
2883     }
2884
2885
2886     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2887         VARIANT v;
2888         HRESULT hres;
2889
2890         hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2891         if(FAILED(hres))
2892             return hres;
2893
2894         hres = equal_values(ctx, lval, &v, ei, ret);
2895
2896         VariantClear(&v);
2897         return hres;
2898     }
2899
2900
2901     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2902         VARIANT v;
2903         HRESULT hres;
2904
2905         hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2906         if(FAILED(hres))
2907             return hres;
2908
2909         hres = equal_values(ctx, &v, rval, ei, ret);
2910
2911         VariantClear(&v);
2912         return hres;
2913     }
2914
2915
2916     *ret = FALSE;
2917     return S_OK;
2918 }
2919
2920 /* ECMA-262 3rd Edition    11.9.1 */
2921 static HRESULT interp_eq(exec_ctx_t *ctx)
2922 {
2923     VARIANT *l, *r;
2924     BOOL b;
2925     HRESULT hres;
2926
2927     r = stack_pop(ctx);
2928     l = stack_pop(ctx);
2929
2930     TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2931
2932     hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2933     VariantClear(l);
2934     VariantClear(r);
2935     if(FAILED(hres))
2936         return hres;
2937
2938     return stack_push_bool(ctx, b);
2939 }
2940
2941 /* ECMA-262 3rd Edition    11.9.2 */
2942 static HRESULT interp_neq(exec_ctx_t *ctx)
2943 {
2944     VARIANT *l, *r;
2945     BOOL b;
2946     HRESULT hres;
2947
2948     r = stack_pop(ctx);
2949     l = stack_pop(ctx);
2950
2951     TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2952
2953     hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2954     VariantClear(l);
2955     VariantClear(r);
2956     if(FAILED(hres))
2957         return hres;
2958
2959     return stack_push_bool(ctx, !b);
2960 }
2961
2962 /* ECMA-262 3rd Edition    11.9.4 */
2963 static HRESULT interp_eq2(exec_ctx_t *ctx)
2964 {
2965     VARIANT *l, *r;
2966     BOOL b;
2967     HRESULT hres;
2968
2969     TRACE("\n");
2970
2971     r = stack_pop(ctx);
2972     l = stack_pop(ctx);
2973
2974     hres = equal2_values(r, l, &b);
2975     VariantClear(l);
2976     VariantClear(r);
2977     if(FAILED(hres))
2978         return hres;
2979
2980     return stack_push_bool(ctx, b);
2981 }
2982
2983 /* ECMA-262 3rd Edition    11.9.5 */
2984 static HRESULT interp_neq2(exec_ctx_t *ctx)
2985 {
2986     VARIANT *l, *r;
2987     BOOL b;
2988     HRESULT hres;
2989
2990     TRACE("\n");
2991
2992     r = stack_pop(ctx);
2993     l = stack_pop(ctx);
2994
2995     hres = equal2_values(r, l, &b);
2996     VariantClear(l);
2997     VariantClear(r);
2998     if(FAILED(hres))
2999         return hres;
3000
3001     return stack_push_bool(ctx, !b);
3002 }
3003
3004 /* ECMA-262 3rd Edition    11.8.5 */
3005 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
3006 {
3007     VARIANT l, r, ln, rn;
3008     HRESULT hres;
3009
3010     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
3011     if(FAILED(hres))
3012         return hres;
3013
3014     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
3015     if(FAILED(hres)) {
3016         VariantClear(&l);
3017         return hres;
3018     }
3019
3020     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
3021         *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
3022         SysFreeString(V_BSTR(&l));
3023         SysFreeString(V_BSTR(&r));
3024         return S_OK;
3025     }
3026
3027     hres = to_number(ctx, &l, ei, &ln);
3028     VariantClear(&l);
3029     if(SUCCEEDED(hres))
3030         hres = to_number(ctx, &r, ei, &rn);
3031     VariantClear(&r);
3032     if(FAILED(hres))
3033         return hres;
3034
3035     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
3036         *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
3037     }else  {
3038         DOUBLE ld = num_val(&ln);
3039         DOUBLE rd = num_val(&rn);
3040
3041         *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
3042     }
3043
3044     return S_OK;
3045 }
3046
3047 /* ECMA-262 3rd Edition    11.8.1 */
3048 HRESULT less_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3049 {
3050     binary_expression_t *expr = (binary_expression_t*)_expr;
3051     VARIANT rval, lval;
3052     BOOL b;
3053     HRESULT hres;
3054
3055     TRACE("\n");
3056
3057     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
3058     if(FAILED(hres))
3059         return hres;
3060
3061     hres = less_eval(ctx, &lval, &rval, FALSE, ei, &b);
3062     VariantClear(&lval);
3063     VariantClear(&rval);
3064     if(FAILED(hres))
3065         return hres;
3066
3067     return return_bool(ret, b);
3068 }
3069
3070 /* ECMA-262 3rd Edition    11.8.3 */
3071 HRESULT lesseq_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3072 {
3073     binary_expression_t *expr = (binary_expression_t*)_expr;
3074     VARIANT rval, lval;
3075     BOOL b;
3076     HRESULT hres;
3077
3078     TRACE("\n");
3079
3080     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
3081     if(FAILED(hres))
3082         return hres;
3083
3084     hres = less_eval(ctx, &rval, &lval, TRUE, ei, &b);
3085     VariantClear(&lval);
3086     VariantClear(&rval);
3087     if(FAILED(hres))
3088         return hres;
3089
3090     return return_bool(ret, b);
3091 }
3092
3093 /* ECMA-262 3rd Edition    11.8.2 */
3094 HRESULT greater_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3095 {
3096     binary_expression_t *expr = (binary_expression_t*)_expr;
3097     VARIANT rval, lval;
3098     BOOL b;
3099     HRESULT hres;
3100
3101     TRACE("\n");
3102
3103     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
3104     if(FAILED(hres))
3105         return hres;
3106
3107     hres = less_eval(ctx, &rval, &lval, FALSE, ei, &b);
3108     VariantClear(&lval);
3109     VariantClear(&rval);
3110     if(FAILED(hres))
3111         return hres;
3112
3113     return return_bool(ret, b);
3114 }
3115
3116 /* ECMA-262 3rd Edition    11.8.4 */
3117 HRESULT greatereq_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3118 {
3119     binary_expression_t *expr = (binary_expression_t*)_expr;
3120     VARIANT rval, lval;
3121     BOOL b;
3122     HRESULT hres;
3123
3124     TRACE("\n");
3125
3126     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
3127     if(FAILED(hres))
3128         return hres;
3129
3130     hres = less_eval(ctx, &lval, &rval, TRUE, ei, &b);
3131     VariantClear(&lval);
3132     VariantClear(&rval);
3133     if(FAILED(hres))
3134         return hres;
3135
3136     return return_bool(ret, b);
3137 }
3138
3139 /* ECMA-262 3rd Edition    11.4.8 */
3140 static HRESULT interp_bneg(exec_ctx_t *ctx)
3141 {
3142     VARIANT *v, r;
3143     INT i;
3144     HRESULT hres;
3145
3146     TRACE("\n");
3147
3148     v = stack_pop(ctx);
3149     hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3150     VariantClear(v);
3151     if(FAILED(hres))
3152         return hres;
3153
3154     V_VT(&r) = VT_I4;
3155     V_I4(&r) = ~i;
3156     return stack_push(ctx, &r);
3157 }
3158
3159 /* ECMA-262 3rd Edition    11.4.9 */
3160 static HRESULT interp_neg(exec_ctx_t *ctx)
3161 {
3162     VARIANT *v;
3163     VARIANT_BOOL b;
3164     HRESULT hres;
3165
3166     TRACE("\n");
3167
3168     v = stack_pop(ctx);
3169     hres = to_boolean(v, &b);
3170     VariantClear(v);
3171     if(FAILED(hres))
3172         return hres;
3173
3174     return stack_push_bool(ctx, !b);
3175 }
3176
3177 /* ECMA-262 3rd Edition    11.7.1 */
3178 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3179 {
3180     DWORD ri;
3181     INT li;
3182     HRESULT hres;
3183
3184     hres = to_int32(ctx, lval, ei, &li);
3185     if(FAILED(hres))
3186         return hres;
3187
3188     hres = to_uint32(ctx, rval, ei, &ri);
3189     if(FAILED(hres))
3190         return hres;
3191
3192     V_VT(retv) = VT_I4;
3193     V_I4(retv) = li << (ri&0x1f);
3194     return S_OK;
3195 }
3196
3197 /* ECMA-262 3rd Edition    11.7.1 */
3198 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3199 {
3200     binary_expression_t *expr = (binary_expression_t*)_expr;
3201
3202     TRACE("\n");
3203
3204     return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3205 }
3206
3207 /* ECMA-262 3rd Edition    11.7.2 */
3208 static HRESULT rshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3209 {
3210     DWORD ri;
3211     INT li;
3212     HRESULT hres;
3213
3214     hres = to_int32(ctx, lval, ei, &li);
3215     if(FAILED(hres))
3216         return hres;
3217
3218     hres = to_uint32(ctx, rval, ei, &ri);
3219     if(FAILED(hres))
3220         return hres;
3221
3222     V_VT(retv) = VT_I4;
3223     V_I4(retv) = li >> (ri&0x1f);
3224     return S_OK;
3225 }
3226
3227 /* ECMA-262 3rd Edition    11.7.2 */
3228 HRESULT right_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3229 {
3230     binary_expression_t *expr = (binary_expression_t*)_expr;
3231
3232     TRACE("\n");
3233
3234     return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
3235 }
3236
3237 /* ECMA-262 3rd Edition    11.7.3 */
3238 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3239 {
3240     DWORD li, ri;
3241     HRESULT hres;
3242
3243     hres = to_uint32(ctx, lval, ei, &li);
3244     if(FAILED(hres))
3245         return hres;
3246
3247     hres = to_uint32(ctx, rval, ei, &ri);
3248     if(FAILED(hres))
3249         return hres;
3250
3251     V_VT(retv) = VT_I4;
3252     V_I4(retv) = li >> (ri&0x1f);
3253     return S_OK;
3254 }
3255
3256 /* ECMA-262 3rd Edition    11.7.3 */
3257 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3258 {
3259     binary_expression_t *expr = (binary_expression_t*)_expr;
3260
3261     TRACE("\n");
3262
3263     return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3264 }
3265
3266 /* ECMA-262 3rd Edition    11.13.1 */
3267 HRESULT assign_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3268 {
3269     binary_expression_t *expr = (binary_expression_t*)_expr;
3270     exprval_t exprval, exprvalr;
3271     VARIANT rval;
3272     HRESULT hres;
3273
3274     TRACE("\n");
3275
3276     hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
3277     if(FAILED(hres))
3278         return hres;
3279
3280     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
3281     if(SUCCEEDED(hres)) {
3282         hres = exprval_to_value(ctx, &exprvalr, ei, &rval);
3283         exprval_release(&exprvalr);
3284     }
3285
3286     if(SUCCEEDED(hres)) {
3287         hres = put_value(ctx, &exprval, &rval, ei);
3288         if(FAILED(hres))
3289             VariantClear(&rval);
3290     }
3291
3292     exprval_release(&exprval);
3293     if(FAILED(hres))
3294         return hres;
3295
3296     ret->type = EXPRVAL_VARIANT;
3297     ret->u.var = rval;
3298     return S_OK;
3299 }
3300
3301 /* ECMA-262 3rd Edition    11.13.2 */
3302 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3303 {
3304     binary_expression_t *expr = (binary_expression_t*)_expr;
3305
3306     TRACE("\n");
3307
3308     return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3309 }
3310
3311 /* ECMA-262 3rd Edition    11.13.2 */
3312 HRESULT assign_rshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3313 {
3314     binary_expression_t *expr = (binary_expression_t*)_expr;
3315
3316     TRACE("\n");
3317
3318     return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
3319 }
3320
3321 /* ECMA-262 3rd Edition    11.13.2 */
3322 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3323 {
3324     binary_expression_t *expr = (binary_expression_t*)_expr;
3325
3326     TRACE("\n");
3327
3328     return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3329 }
3330
3331 /* ECMA-262 3rd Edition    11.13.2 */
3332 HRESULT assign_add_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3333 {
3334     binary_expression_t *expr = (binary_expression_t*)_expr;
3335
3336     TRACE("\n");
3337
3338     return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
3339 }
3340
3341 /* ECMA-262 3rd Edition    11.13.2 */
3342 HRESULT assign_sub_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3343 {
3344     binary_expression_t *expr = (binary_expression_t*)_expr;
3345
3346     TRACE("\n");
3347
3348     return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
3349 }
3350
3351 /* ECMA-262 3rd Edition    11.13.2 */
3352 HRESULT assign_mul_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3353 {
3354     binary_expression_t *expr = (binary_expression_t*)_expr;
3355
3356     TRACE("\n");
3357
3358     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
3359 }
3360
3361 /* ECMA-262 3rd Edition    11.13.2 */
3362 HRESULT assign_div_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3363 {
3364     binary_expression_t *expr = (binary_expression_t*)_expr;
3365
3366     TRACE("\n");
3367
3368     return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
3369 }
3370
3371 /* ECMA-262 3rd Edition    11.13.2 */
3372 HRESULT assign_mod_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3373 {
3374     binary_expression_t *expr = (binary_expression_t*)_expr;
3375
3376     TRACE("\n");
3377
3378     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mod_eval, ei, ret);
3379 }
3380
3381 /* ECMA-262 3rd Edition    11.13.2 */
3382 HRESULT assign_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3383 {
3384     binary_expression_t *expr = (binary_expression_t*)_expr;
3385
3386     TRACE("\n");
3387
3388     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
3389 }
3390
3391 /* ECMA-262 3rd Edition    11.13.2 */
3392 HRESULT assign_or_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3393 {
3394     binary_expression_t *expr = (binary_expression_t*)_expr;
3395
3396     TRACE("\n");
3397
3398     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
3399 }
3400
3401 /* ECMA-262 3rd Edition    11.13.2 */
3402 HRESULT assign_xor_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3403 {
3404     binary_expression_t *expr = (binary_expression_t*)_expr;
3405
3406     TRACE("\n");
3407
3408     return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
3409 }
3410
3411 static HRESULT interp_jmp(exec_ctx_t *ctx)
3412 {
3413     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3414
3415     TRACE("\n");
3416
3417     ctx->ip = arg;
3418     return S_OK;
3419 }
3420
3421 static HRESULT interp_pop(exec_ctx_t *ctx)
3422 {
3423     TRACE("\n");
3424
3425     stack_popn(ctx, 1);
3426     return S_OK;
3427 }
3428
3429 static HRESULT interp_ret(exec_ctx_t *ctx)
3430 {
3431     TRACE("\n");
3432
3433     ctx->ip = -1;
3434     return S_OK;
3435 }
3436
3437 static HRESULT interp_tree(exec_ctx_t *ctx)
3438 {
3439     instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3440     exprval_t val;
3441     VARIANT v;
3442     HRESULT hres;
3443
3444     TRACE("\n");
3445
3446     hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3447     if(FAILED(hres))
3448         return hres;
3449
3450     hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3451     exprval_release(&val);
3452     if(FAILED(hres))
3453         return hres;
3454
3455     return stack_push(ctx, &v);
3456 }
3457
3458 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3459
3460 static const op_func_t op_funcs[] = {
3461 #define X(x,a,b,c) interp_##x,
3462 OP_LIST
3463 #undef X
3464 };
3465
3466 static const unsigned op_move[] = {
3467 #define X(a,x,b,c) x,
3468 OP_LIST
3469 #undef X
3470 };
3471
3472 HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3473 {
3474     exec_ctx_t *exec_ctx = ctx->exec_ctx;
3475     unsigned prev_ip, prev_top;
3476     jsop_t op;
3477     HRESULT hres = S_OK;
3478
3479     TRACE("\n");
3480
3481     prev_top = exec_ctx->top;
3482     prev_ip = exec_ctx->ip;
3483     exec_ctx->ip = expr->instr_off;
3484
3485     while(exec_ctx->ip != -1) {
3486         op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3487         hres = op_funcs[op](exec_ctx);
3488         if(FAILED(hres))
3489             break;
3490         exec_ctx->ip += op_move[op];
3491     }
3492
3493     exec_ctx->ip = prev_ip;
3494
3495     if(FAILED(hres)) {
3496         stack_popn(exec_ctx, exec_ctx->top-prev_top);
3497         *ei = exec_ctx->ei;
3498         memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3499         return hres;
3500     }
3501
3502     assert(exec_ctx->top == prev_top+1);
3503
3504     ret->type = EXPRVAL_VARIANT;
3505     ret->u.var = *stack_pop(exec_ctx);
3506     return S_OK;
3507 }
3508
3509 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3510 {
3511     HRESULT hres;
3512
3513     TRACE("\n");
3514
3515     hres = compile_subscript(ctx->exec_ctx->parser, expr, &expr->instr_off);
3516     if(FAILED(hres))
3517         return hres;
3518
3519     if(expr->eval == compiled_expression_eval)
3520         expr->eval = interp_expression_eval;
3521
3522     return expr->eval(ctx, expr, flags, ei, ret);
3523 }