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

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