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