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