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 dispex_get_id(IDispatchEx *dispex, BSTR name, DWORD flags, DISPID *id)
 207 {
 208     *id = 0;
 209
 210     return IDispatchEx_GetDispID(dispex, name, flags|fdexNameCaseSensitive, id);
 211 }
 212
 213 static HRESULT disp_get_id(IDispatch *disp, BSTR name, DWORD flags, DISPID *id)
 214 {
 215     IDispatchEx *dispex;
 216     HRESULT hres;
 217
 218     hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
 219     if(FAILED(hres)) {
 220         TRACE("unsing IDispatch\n");
 221
 222         *id = 0;
 223         return IDispatch_GetIDsOfNames(disp, &IID_NULL, &name, 1, 0, id);
 224     }
 225
 226     hres = dispex_get_id(dispex, name, flags, id);
 227     IDispatchEx_Release(dispex);
 228     return hres;
 229 }
 230
 231 /* ECMA-262 3rd Edition    8.7.2 */
 232 static HRESULT put_value(script_ctx_t *ctx, exprval_t *ref, VARIANT *v, jsexcept_t *ei)
 233 {
 234     if(ref->type != EXPRVAL_IDREF) {
 235         FIXME("throw ReferemceError\n");
 236         return E_FAIL;
 237     }
 238
 239     return disp_propput(ref->u.idref.disp, ref->u.idref.id, ctx->lcid, v, ei, NULL/*FIXME*/);
 240 }
 241
 242 static HRESULT disp_cmp(IDispatch *disp1, IDispatch *disp2, BOOL *ret)
 243 {
 244     IObjectIdentity *identity;
 245     IUnknown *unk1, *unk2;
 246     HRESULT hres;
 247
 248     if(disp1 == disp2) {
 249         *ret = TRUE;
 250         return S_OK;
 251     }
 252
 253     hres = IDispatch_QueryInterface(disp1, &IID_IUnknown, (void**)&unk1);
 254     if(FAILED(hres))
 255         return hres;
 256
 257     hres = IDispatch_QueryInterface(disp2, &IID_IUnknown, (void**)&unk2);
 258     if(FAILED(hres)) {
 259         IUnknown_Release(unk1);
 260         return hres;
 261     }
 262
 263     if(unk1 == unk2) {
 264         *ret = TRUE;
 265     }else {
 266         hres = IUnknown_QueryInterface(unk1, &IID_IObjectIdentity, (void**)&identity);
 267         if(SUCCEEDED(hres)) {
 268             hres = IObjectIdentity_IsEqualObject(identity, unk2);
 269             IObjectIdentity_Release(identity);
 270             *ret = hres == S_OK;
 271         }else {
 272             *ret = FALSE;
 273         }
 274     }
 275
 276     IUnknown_Release(unk1);
 277     IUnknown_Release(unk2);
 278     return S_OK;
 279 }
 280
 281 static inline BOOL is_num_vt(enum VARENUM vt)
 282 {
 283     return vt == VT_I4 || vt == VT_R8;
 284 }
 285
 286 static inline DOUBLE num_val(const VARIANT *v)
 287 {
 288     return V_VT(v) == VT_I4 ? V_I4(v) : V_R8(v);
 289 }
 290
 291 static inline void num_set_val(VARIANT *v, DOUBLE d)
 292 {
 293     if(d == (DOUBLE)(INT)d) {
 294         V_VT(v) = VT_I4;
 295         V_I4(v) = d;
 296     }else {
 297         V_VT(v) = VT_R8;
 298         V_R8(v) = d;
 299     }
 300 }
 301
 302 /* ECMA-262 3rd Edition    11.9.6 */
 303 HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
 304 {
 305     TRACE("\n");
 306
 307     if(V_VT(lval) != V_VT(rval)) {
 308         if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))) {
 309             *ret = num_val(lval) == num_val(rval);
 310             return S_OK;
 311         }
 312
 313         *ret = FALSE;
 314         return S_OK;
 315     }
 316
 317     switch(V_VT(lval)) {
 318     case VT_EMPTY:
 319     case VT_NULL:
 320         *ret = VARIANT_TRUE;
 321         break;
 322     case VT_I4:
 323         *ret = V_I4(lval) == V_I4(rval);
 324         break;
 325     case VT_R8:
 326         *ret = V_R8(lval) == V_R8(rval);
 327         break;
 328     case VT_BSTR:
 329         *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
 330         break;
 331     case VT_DISPATCH:
 332         return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
 333     case VT_BOOL:
 334         *ret = !V_BOOL(lval) == !V_BOOL(rval);
 335         break;
 336     default:
 337         FIXME("unimplemented vt %d\n", V_VT(lval));
 338         return E_NOTIMPL;
 339     }
 340
 341     return S_OK;
 342 }
 343
 344 static HRESULT literal_to_var(literal_t *literal, VARIANT *v)
 345 {
 346     V_VT(v) = literal->vt;
 347
 348     switch(V_VT(v)) {
 349     case VT_EMPTY:
 350     case VT_NULL:
 351         break;
 352     case VT_I4:
 353         V_I4(v) = literal->u.lval;
 354         break;
 355     case VT_R8:
 356         V_R8(v) = literal->u.dval;
 357         break;
 358     case VT_BSTR:
 359         V_BSTR(v) = SysAllocString(literal->u.wstr);
 360         break;
 361     case VT_BOOL:
 362         V_BOOL(v) = literal->u.bval;
 363         break;
 364     case VT_DISPATCH:
 365         IDispatch_AddRef(literal->u.disp);
 366         V_DISPATCH(v) = literal->u.disp;
 367         break;
 368     default:
 369         ERR("wrong type %d\n", V_VT(v));
 370         return E_NOTIMPL;
 371     }
 372
 373     return S_OK;
 374 }
 375
 376 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, jsexcept_t *ei, VARIANT *retv)
 377 {
 378     script_ctx_t *script = parser->script;
 379     function_declaration_t *func;
 380     parser_ctx_t *prev_parser;
 381     VARIANT val, tmp;
 382     statement_t *stat;
 383     exec_ctx_t *prev_ctx;
 384     return_type_t rt;
 385     HRESULT hres = S_OK;
 386
 387     for(func = source->functions; func; func = func->next) {
 388         DispatchEx *func_obj;
 389         VARIANT var;
 390
 391         hres = create_source_function(parser, func->parameter_list, func->source_elements, ctx->scope_chain, &func_obj);
 392         if(FAILED(hres))
 393             return hres;
 394
 395         V_VT(&var) = VT_DISPATCH;
 396         V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(func_obj);
 397         hres = jsdisp_propput_name(ctx->var_disp, func->identifier, script->lcid, &var, ei, NULL);
 398         IDispatchEx_Release(_IDispatchEx_(func_obj));
 399         if(FAILED(hres))
 400             return hres;
 401     }
 402
 403     prev_ctx = script->exec_ctx;
 404     script->exec_ctx = ctx;
 405
 406     prev_parser = ctx->parser;
 407     ctx->parser = parser;
 408
 409     V_VT(&val) = VT_EMPTY;
 410     memset(&rt, 0, sizeof(rt));
 411     rt.type = RT_NORMAL;
 412
 413     for(stat = source->statement; stat; stat = stat->next) {
 414         hres = stat_eval(ctx, stat, &rt, &tmp);
 415         if(FAILED(hres))
 416             break;
 417
 418         VariantClear(&val);
 419         val = tmp;
 420         if(rt.type != RT_NORMAL)
 421             break;
 422     }
 423
 424     script->exec_ctx = prev_ctx;
 425     ctx->parser = prev_parser;
 426
 427     if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
 428         FIXME("wrong rt %d\n", rt.type);
 429         hres = E_FAIL;
 430     }
 431
 432     *ei = rt.ei;
 433     if(FAILED(hres)) {
 434         VariantClear(&val);
 435         return hres;
 436     }
 437
 438     if(retv)
 439         *retv = val;
 440     else
 441         VariantClear(&val);
 442     return S_OK;
 443 }
 444
 445 /* ECMA-262 3rd Edition    10.1.4 */
 446 static HRESULT identifier_eval(exec_ctx_t *ctx, BSTR identifier, DWORD flags, exprval_t *ret)
 447 {
 448     scope_chain_t *scope;
 449     named_item_t *item;
 450     DISPID id = 0;
 451     HRESULT hres;
 452
 453     TRACE("%s\n", debugstr_w(identifier));
 454
 455     for(scope = ctx->scope_chain; scope; scope = scope->next) {
 456         hres = dispex_get_id(_IDispatchEx_(scope->obj), identifier, 0, &id);
 457         if(SUCCEEDED(hres))
 458             break;
 459     }
 460
 461     if(scope) {
 462         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(scope->obj), id);
 463         return S_OK;
 464     }
 465
 466     hres = dispex_get_id(_IDispatchEx_(ctx->parser->script->global), identifier, 0, &id);
 467     if(SUCCEEDED(hres)) {
 468         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->global), id);
 469         return S_OK;
 470     }
 471
 472     for(item = ctx->parser->script->named_items; item; item = item->next) {
 473         hres = disp_get_id(item->disp, identifier, 0, &id);
 474         if(SUCCEEDED(hres))
 475             break;
 476     }
 477
 478     if(item) {
 479         exprval_set_idref(ret, (IDispatch*)item->disp, id);
 480         return S_OK;
 481     }
 482
 483     hres = dispex_get_id(_IDispatchEx_(ctx->parser->script->script_disp), identifier, 0, &id);
 484     if(SUCCEEDED(hres)) {
 485         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->script_disp), id);
 486         return S_OK;
 487     }
 488
 489     if(flags & EXPR_NEWREF) {
 490         hres = dispex_get_id(_IDispatchEx_(ctx->var_disp), identifier, fdexNameEnsure, &id);
 491         if(FAILED(hres))
 492             return hres;
 493
 494         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->var_disp), id);
 495         return S_OK;
 496     }
 497
 498     WARN("Could not find identifier %s\n", debugstr_w(identifier));
 499     return E_FAIL;
 500 }
 501
 502 /* ECMA-262 3rd Edition    12.1 */
 503 HRESULT block_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 504 {
 505     block_statement_t *stat = (block_statement_t*)_stat;
 506     VARIANT val, tmp;
 507     statement_t *iter;
 508     HRESULT hres = S_OK;
 509
 510     TRACE("\n");
 511
 512     V_VT(&val) = VT_EMPTY;
 513     for(iter = stat->stat_list; iter; iter = iter->next) {
 514         hres = stat_eval(ctx, iter, rt, &tmp);
 515         if(FAILED(hres))
 516             break;
 517
 518         VariantClear(&val);
 519         val = tmp;
 520         if(rt->type != RT_NORMAL)
 521             break;
 522     }
 523
 524     if(FAILED(hres)) {
 525         VariantClear(&val);
 526         return hres;
 527     }
 528
 529     *ret = val;
 530     return S_OK;
 531 }
 532
 533 /* ECMA-262 3rd Edition    12.2 */
 534 static HRESULT variable_list_eval(exec_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
 535 {
 536     variable_declaration_t *iter;
 537     HRESULT hres = E_FAIL;
 538
 539     for(iter = var_list; iter; iter = iter->next) {
 540         VARIANT val;
 541
 542         if(iter->expr) {
 543             exprval_t exprval;
 544
 545             hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
 546             if(FAILED(hres))
 547                 break;
 548
 549             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
 550             exprval_release(&exprval);
 551             if(FAILED(hres))
 552                 break;
 553         }else {
 554             V_VT(&val) = VT_EMPTY;
 555         }
 556
 557         hres = jsdisp_propput_name(ctx->var_disp, iter->identifier, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
 558         VariantClear(&val);
 559         if(FAILED(hres))
 560             break;
 561     }
 562
 563     return hres;
 564 }
 565
 566 /* ECMA-262 3rd Edition    12.2 */
 567 HRESULT var_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 568 {
 569     var_statement_t *stat = (var_statement_t*)_stat;
 570     HRESULT hres;
 571
 572     TRACE("\n");
 573
 574     hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
 575     if(FAILED(hres))
 576         return hres;
 577
 578     V_VT(ret) = VT_EMPTY;
 579     return S_OK;
 580 }
 581
 582 /* ECMA-262 3rd Edition    12.3 */
 583 HRESULT empty_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 584 {
 585     TRACE("\n");
 586
 587     V_VT(ret) = VT_EMPTY;
 588     return S_OK;
 589 }
 590
 591 /* ECMA-262 3rd Edition    12.4 */
 592 HRESULT expression_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 593 {
 594     expression_statement_t *stat = (expression_statement_t*)_stat;
 595     exprval_t exprval;
 596     VARIANT val;
 597     HRESULT hres;
 598
 599     TRACE("\n");
 600
 601     hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
 602     if(FAILED(hres))
 603         return hres;
 604
 605     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 606     exprval_release(&exprval);
 607     if(FAILED(hres))
 608         return hres;
 609
 610     *ret = val;
 611     TRACE("= %s\n", debugstr_variant(ret));
 612     return S_OK;
 613 }
 614
 615 /* ECMA-262 3rd Edition    12.5 */
 616 HRESULT if_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 617 {
 618     if_statement_t *stat = (if_statement_t*)_stat;
 619     exprval_t exprval;
 620     VARIANT_BOOL b;
 621     HRESULT hres;
 622
 623     TRACE("\n");
 624
 625     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 626     if(FAILED(hres))
 627         return hres;
 628
 629     hres = exprval_to_boolean(ctx->parser->script, &exprval, &rt->ei, &b);
 630     exprval_release(&exprval);
 631     if(FAILED(hres))
 632         return hres;
 633
 634     if(b)
 635         hres = stat_eval(ctx, stat->if_stat, rt, ret);
 636     else if(stat->else_stat)
 637         hres = stat_eval(ctx, stat->else_stat, rt, ret);
 638     else
 639         V_VT(ret) = VT_EMPTY;
 640
 641     return hres;
 642 }
 643
 644 HRESULT dowhile_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 645 {
 646     FIXME("\n");
 647     return E_NOTIMPL;
 648 }
 649
 650 HRESULT while_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 651 {
 652     FIXME("\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 HRESULT for_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 657 {
 658     FIXME("\n");
 659     return E_NOTIMPL;
 660 }
 661
 662 HRESULT forin_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 663 {
 664     FIXME("\n");
 665     return E_NOTIMPL;
 666 }
 667
 668 HRESULT continue_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 669 {
 670     FIXME("\n");
 671     return E_NOTIMPL;
 672 }
 673
 674 HRESULT break_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 675 {
 676     FIXME("\n");
 677     return E_NOTIMPL;
 678 }
 679
 680 /* ECMA-262 3rd Edition    12.9 */
 681 HRESULT return_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 682 {
 683     expression_statement_t *stat = (expression_statement_t*)_stat;
 684     HRESULT hres;
 685
 686     TRACE("\n");
 687
 688     if(stat->expr) {
 689         exprval_t exprval;
 690
 691         hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 692         if(FAILED(hres))
 693             return hres;
 694
 695         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, ret);
 696         exprval_release(&exprval);
 697         if(FAILED(hres))
 698             return hres;
 699     }else {
 700         V_VT(ret) = VT_EMPTY;
 701     }
 702
 703     TRACE("= %s\n", debugstr_variant(ret));
 704     rt->type = RT_RETURN;
 705     return S_OK;
 706 }
 707
 708 HRESULT with_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 709 {
 710     FIXME("\n");
 711     return E_NOTIMPL;
 712 }
 713
 714 HRESULT labelled_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 715 {
 716     FIXME("\n");
 717     return E_NOTIMPL;
 718 }
 719
 720 HRESULT switch_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 721 {
 722     FIXME("\n");
 723     return E_NOTIMPL;
 724 }
 725
 726 /* ECMA-262 3rd Edition    12.13 */
 727 HRESULT throw_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 728 {
 729     expression_statement_t *stat = (expression_statement_t*)_stat;
 730     exprval_t exprval;
 731     VARIANT val;
 732     HRESULT hres;
 733
 734     TRACE("\n");
 735
 736     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 737     if(FAILED(hres))
 738         return hres;
 739
 740     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 741     exprval_release(&exprval);
 742     if(FAILED(hres))
 743         return hres;
 744
 745     rt->ei.var = val;
 746     return DISP_E_EXCEPTION;
 747 }
 748
 749 /* ECMA-262 3rd Edition    12.14 */
 750 static HRESULT catch_eval(exec_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
 751 {
 752     DispatchEx *var_disp;
 753     VARIANT ex, val;
 754     HRESULT hres;
 755
 756     ex = rt->ei.var;
 757     memset(&rt->ei, 0, sizeof(jsexcept_t));
 758
 759     hres = create_dispex(ctx->parser->script, NULL, NULL, &var_disp);
 760     if(SUCCEEDED(hres)) {
 761         hres = jsdisp_propput_name(var_disp, block->identifier, ctx->parser->script->lcid,
 762                 &ex, &rt->ei, NULL/*FIXME*/);
 763         if(SUCCEEDED(hres)) {
 764             hres = scope_push(ctx->scope_chain, var_disp, &ctx->scope_chain);
 765             if(SUCCEEDED(hres)) {
 766                 hres = stat_eval(ctx, block->statement, rt, &val);
 767                 scope_pop(&ctx->scope_chain);
 768             }
 769         }
 770
 771         jsdisp_release(var_disp);
 772     }
 773
 774     VariantClear(&ex);
 775     if(FAILED(hres))
 776         return hres;
 777
 778     *ret = val;
 779     return S_OK;
 780 }
 781
 782 /* ECMA-262 3rd Edition    12.14 */
 783 HRESULT try_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 784 {
 785     try_statement_t *stat = (try_statement_t*)_stat;
 786     VARIANT val;
 787     HRESULT hres;
 788
 789     TRACE("\n");
 790
 791     hres = stat_eval(ctx, stat->try_statement, rt, &val);
 792     if(FAILED(hres)) {
 793         TRACE("EXCEPTION\n");
 794         if(!stat->catch_block)
 795             return hres;
 796
 797         hres = catch_eval(ctx, stat->catch_block, rt, &val);
 798         if(FAILED(hres))
 799             return hres;
 800     }
 801
 802     if(stat->finally_statement) {
 803         VariantClear(&val);
 804         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
 805         if(FAILED(hres))
 806             return hres;
 807     }
 808
 809     *ret = val;
 810     return S_OK;
 811 }
 812
 813 static HRESULT return_bool(exprval_t *ret, DWORD b)
 814 {
 815     ret->type = EXPRVAL_VARIANT;
 816     V_VT(&ret->u.var) = VT_BOOL;
 817     V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
 818
 819     return S_OK;
 820 }
 821
 822 static HRESULT get_binary_expr_values(exec_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
 823 {
 824     exprval_t exprval;
 825     HRESULT hres;
 826
 827     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
 828     if(FAILED(hres))
 829         return hres;
 830
 831     hres = exprval_to_value(ctx->parser->script, &exprval, ei, lval);
 832     exprval_release(&exprval);
 833     if(FAILED(hres))
 834         return hres;
 835
 836     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
 837     if(SUCCEEDED(hres)) {
 838         hres = exprval_to_value(ctx->parser->script, &exprval, ei, rval);
 839         exprval_release(&exprval);
 840     }
 841
 842     if(FAILED(hres)) {
 843         VariantClear(lval);
 844         return hres;
 845     }
 846
 847     return S_OK;
 848 }
 849
 850 typedef HRESULT (*oper_t)(exec_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
 851
 852 static HRESULT binary_expr_eval(exec_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
 853         exprval_t *ret)
 854 {
 855     VARIANT lval, rval, retv;
 856     HRESULT hres;
 857
 858     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
 859     if(FAILED(hres))
 860         return hres;
 861
 862     hres = oper(ctx, &lval, &rval, ei, &retv);
 863     VariantClear(&lval);
 864     VariantClear(&rval);
 865     if(FAILED(hres))
 866         return hres;
 867
 868     ret->type = EXPRVAL_VARIANT;
 869     ret->u.var = retv;
 870     return S_OK;
 871 }
 872
 873 /* ECMA-262 3rd Edition    11.13.2 */
 874 static HRESULT assign_oper_eval(exec_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
 875                                 jsexcept_t *ei, exprval_t *ret)
 876 {
 877     VARIANT retv, lval, rval;
 878     exprval_t exprval, exprvalr;
 879     HRESULT hres;
 880
 881     hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
 882     if(FAILED(hres))
 883         return hres;
 884
 885     hres = exprval_value(ctx->parser->script, &exprval, ei, &lval);
 886     if(SUCCEEDED(hres)) {
 887         hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
 888         if(SUCCEEDED(hres)) {
 889             hres = exprval_value(ctx->parser->script, &exprvalr, ei, &rval);
 890             exprval_release(&exprvalr);
 891         }
 892         if(SUCCEEDED(hres)) {
 893             hres = oper(ctx, &lval, &rval, ei, &retv);
 894             VariantClear(&rval);
 895         }
 896         VariantClear(&lval);
 897     }
 898
 899     if(SUCCEEDED(hres)) {
 900         hres = put_value(ctx->parser->script, &exprval, &retv, ei);
 901         if(FAILED(hres))
 902             VariantClear(&retv);
 903     }
 904     exprval_release(&exprval);
 905
 906     if(FAILED(hres))
 907         return hres;
 908
 909     ret->type = EXPRVAL_VARIANT;
 910     ret->u.var = retv;
 911     return S_OK;
 912 }
 913
 914 /* ECMA-262 3rd Edition    13 */
 915 HRESULT function_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
 916 {
 917     function_expression_t *expr = (function_expression_t*)_expr;
 918     DispatchEx *dispex;
 919     VARIANT var;
 920     HRESULT hres;
 921
 922     TRACE("\n");
 923
 924     hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain, &dispex);
 925     if(FAILED(hres))
 926         return hres;
 927
 928     V_VT(&var) = VT_DISPATCH;
 929     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
 930
 931     if(expr->identifier) {
 932         hres = jsdisp_propput_name(ctx->var_disp, expr->identifier, ctx->parser->script->lcid, &var, ei, NULL/*FIXME*/);
 933         if(FAILED(hres)) {
 934             jsdisp_release(dispex);
 935             return hres;
 936         }
 937     }
 938
 939     ret->type = EXPRVAL_VARIANT;
 940     ret->u.var = var;
 941     return S_OK;
 942 }
 943
 944 /* ECMA-262 3rd Edition    11.12 */
 945 HRESULT conditional_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
 946 {
 947     conditional_expression_t *expr = (conditional_expression_t*)_expr;
 948     exprval_t exprval;
 949     VARIANT_BOOL b;
 950     HRESULT hres;
 951
 952     TRACE("\n");
 953
 954     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
 955     if(FAILED(hres))
 956         return hres;
 957
 958     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
 959     exprval_release(&exprval);
 960     if(FAILED(hres))
 961         return hres;
 962
 963     return expr_eval(ctx, b ? expr->true_expression : expr->false_expression, flags, ei, ret);
 964 }
 965
 966 /* ECMA-262 3rd Edition    11.2.1 */
 967 HRESULT array_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
 968 {
 969     array_expression_t *expr = (array_expression_t*)_expr;
 970     exprval_t exprval;
 971     VARIANT member, val;
 972     DISPID id;
 973     BSTR str;
 974     IDispatch *obj = NULL;
 975     HRESULT hres;
 976
 977     TRACE("\n");
 978
 979     hres = expr_eval(ctx, expr->member_expr, EXPR_NEWREF, ei, &exprval);
 980     if(FAILED(hres))
 981         return hres;
 982
 983     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
 984     exprval_release(&exprval);
 985     if(FAILED(hres))
 986         return hres;
 987
 988     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
 989     if(SUCCEEDED(hres)) {
 990         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
 991         exprval_release(&exprval);
 992     }
 993
 994     if(SUCCEEDED(hres))
 995         hres = to_object(ctx, &member, &obj);
 996     VariantClear(&member);
 997     if(SUCCEEDED(hres)) {
 998         hres = to_string(ctx->parser->script, &val, ei, &str);
 999         if(SUCCEEDED(hres)) {
1000             if(flags & EXPR_STRREF) {
1001                 ret->type = EXPRVAL_NAMEREF;
1002                 ret->u.nameref.disp = obj;
1003                 ret->u.nameref.name = str;
1004                 return S_OK;
1005             }
1006
1007             hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1008         }
1009
1010         if(SUCCEEDED(hres)) {
1011             exprval_set_idref(ret, obj, id);
1012         }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1013             exprval_init(ret);
1014             hres = S_OK;
1015         }
1016
1017         IDispatch_Release(obj);
1018     }
1019
1020     return hres;
1021 }
1022
1023 /* ECMA-262 3rd Edition    11.2.1 */
1024 HRESULT member_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1025 {
1026     member_expression_t *expr = (member_expression_t*)_expr;
1027     IDispatch *obj = NULL;
1028     exprval_t exprval;
1029     VARIANT member;
1030     DISPID id;
1031     BSTR str;
1032     HRESULT hres;
1033
1034     TRACE("\n");
1035
1036     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1037     if(FAILED(hres))
1038         return hres;
1039
1040     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1041     exprval_release(&exprval);
1042     if(FAILED(hres))
1043         return hres;
1044
1045     hres = to_object(ctx, &member, &obj);
1046     VariantClear(&member);
1047     if(FAILED(hres))
1048         return hres;
1049
1050     str = SysAllocString(expr->identifier);
1051     if(flags & EXPR_STRREF) {
1052         ret->type = EXPRVAL_NAMEREF;
1053         ret->u.nameref.disp = obj;
1054         ret->u.nameref.name = str;
1055         return S_OK;
1056     }
1057
1058     hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1059     SysFreeString(str);
1060     if(SUCCEEDED(hres)) {
1061         exprval_set_idref(ret, obj, id);
1062     }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1063         exprval_init(ret);
1064         hres = S_OK;
1065     }
1066
1067     IDispatch_Release(obj);
1068     return hres;
1069 }
1070
1071 static void free_dp(DISPPARAMS *dp)
1072 {
1073     DWORD i;
1074
1075     for(i=0; i < dp->cArgs; i++)
1076         VariantClear(dp->rgvarg+i);
1077     heap_free(dp->rgvarg);
1078 }
1079
1080 static HRESULT args_to_param(exec_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1081 {
1082     VARIANTARG *vargs;
1083     exprval_t exprval;
1084     argument_t *iter;
1085     DWORD cnt = 0, i;
1086     HRESULT hres = S_OK;
1087
1088     memset(dp, 0, sizeof(*dp));
1089     if(!args)
1090         return S_OK;
1091
1092     for(iter = args; iter; iter = iter->next)
1093         cnt++;
1094
1095     vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1096     if(!vargs)
1097         return E_OUTOFMEMORY;
1098
1099     for(i = cnt, iter = args; iter; iter = iter->next) {
1100         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1101         if(FAILED(hres))
1102             break;
1103
1104         hres = exprval_to_value(ctx->parser->script, &exprval, ei, vargs + (--i));
1105         exprval_release(&exprval);
1106         if(FAILED(hres))
1107             break;
1108     }
1109
1110     if(FAILED(hres)) {
1111         free_dp(dp);
1112         return hres;
1113     }
1114
1115     dp->rgvarg = vargs;
1116     dp->cArgs = cnt;
1117     return S_OK;
1118 }
1119
1120 /* ECMA-262 3rd Edition    11.2.2 */
1121 HRESULT new_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1122 {
1123     call_expression_t *expr = (call_expression_t*)_expr;
1124     exprval_t exprval;
1125     VARIANT constr, var;
1126     DISPPARAMS dp;
1127     HRESULT hres;
1128
1129     TRACE("\n");
1130
1131     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1132     if(FAILED(hres))
1133         return hres;
1134
1135     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1136     if(SUCCEEDED(hres))
1137         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &constr);
1138     exprval_release(&exprval);
1139     if(FAILED(hres))
1140         return hres;
1141
1142     if(V_VT(&constr) != VT_DISPATCH) {
1143         FIXME("throw TypeError\n");
1144         VariantClear(&constr);
1145         return E_FAIL;
1146     }
1147
1148     hres = disp_call(V_DISPATCH(&constr), DISPID_VALUE, ctx->parser->script->lcid,
1149                      DISPATCH_CONSTRUCT, &dp, &var, ei, NULL/*FIXME*/);
1150     IDispatch_Release(V_DISPATCH(&constr));
1151     if(FAILED(hres))
1152         return hres;
1153
1154     ret->type = EXPRVAL_VARIANT;
1155     ret->u.var = var;
1156     return S_OK;
1157 }
1158
1159 HRESULT call_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1160 {
1161     call_expression_t *expr = (call_expression_t*)_expr;
1162     VARIANT func, var;
1163     exprval_t exprval;
1164     DISPPARAMS dp;
1165     HRESULT hres;
1166
1167     TRACE("\n");
1168
1169     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1170     if(FAILED(hres))
1171         return hres;
1172
1173     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1174     if(SUCCEEDED(hres)) {
1175         switch(exprval.type) {
1176         case EXPRVAL_IDREF:
1177             hres = disp_call(exprval.u.idref.disp, exprval.u.idref.id, ctx->parser->script->lcid, DISPATCH_METHOD,
1178                     &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1179             if(flags & EXPR_NOVAL)
1180                 V_VT(&var) = VT_EMPTY;
1181             break;
1182         default:
1183             FIXME("unimplemented type %d\n", V_VT(&func));
1184             hres = E_NOTIMPL;
1185         }
1186
1187         free_dp(&dp);
1188     }
1189
1190     exprval_release(&exprval);
1191     if(FAILED(hres))
1192         return hres;
1193
1194     TRACE("= %s\n", debugstr_variant(&var));
1195     ret->type = EXPRVAL_VARIANT;
1196     ret->u.var = var;
1197     return S_OK;
1198 }
1199
1200 HRESULT this_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1201 {
1202     TRACE("\n");
1203
1204     ret->type = EXPRVAL_VARIANT;
1205     V_VT(&ret->u.var) = VT_DISPATCH;
1206     V_DISPATCH(&ret->u.var) = ctx->this_obj;
1207     IDispatch_AddRef(ctx->this_obj);
1208     return S_OK;
1209 }
1210
1211 /* ECMA-262 3rd Edition    10.1.4 */
1212 HRESULT identifier_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1213 {
1214     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1215     BSTR identifier;
1216     HRESULT hres;
1217
1218     TRACE("\n");
1219
1220     identifier = SysAllocString(expr->identifier);
1221     if(!identifier)
1222         return E_OUTOFMEMORY;
1223
1224     hres = identifier_eval(ctx, identifier, flags, ret);
1225
1226     SysFreeString(identifier);
1227     return hres;
1228 }
1229
1230 /* ECMA-262 3rd Edition    7.8 */
1231 HRESULT literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1232 {
1233     literal_expression_t *expr = (literal_expression_t*)_expr;
1234     VARIANT var;
1235     HRESULT hres;
1236
1237     TRACE("\n");
1238
1239     hres = literal_to_var(expr->literal, &var);
1240     if(FAILED(hres))
1241         return hres;
1242
1243     ret->type = EXPRVAL_VARIANT;
1244     ret->u.var = var;
1245     return S_OK;
1246 }
1247
1248 HRESULT array_literal_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1249 {
1250     FIXME("\n");
1251     return E_NOTIMPL;
1252 }
1253
1254 /* ECMA-262 3rd Edition    11.1.5 */
1255 HRESULT property_value_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1256 {
1257     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1258     VARIANT val, tmp;
1259     DispatchEx *obj;
1260     prop_val_t *iter;
1261     exprval_t exprval;
1262     BSTR name;
1263     HRESULT hres;
1264
1265     TRACE("\n");
1266
1267     hres = create_object(ctx->parser->script, NULL, &obj);
1268     if(FAILED(hres))
1269         return hres;
1270
1271     for(iter = expr->property_list; iter; iter = iter->next) {
1272         hres = literal_to_var(iter->name, &tmp);
1273         if(FAILED(hres))
1274             break;
1275
1276         hres = to_string(ctx->parser->script, &tmp, ei, &name);
1277         VariantClear(&tmp);
1278         if(FAILED(hres))
1279             break;
1280
1281         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1282         if(SUCCEEDED(hres)) {
1283             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1284             exprval_release(&exprval);
1285             if(SUCCEEDED(hres)) {
1286                 hres = jsdisp_propput_name(obj, name, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1287                 VariantClear(&val);
1288             }
1289         }
1290
1291         SysFreeString(name);
1292         if(FAILED(hres))
1293             break;
1294     }
1295
1296     if(FAILED(hres)) {
1297         jsdisp_release(obj);
1298         return hres;
1299     }
1300
1301     ret->type = EXPRVAL_VARIANT;
1302     V_VT(&ret->u.var) = VT_DISPATCH;
1303     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(obj);
1304     return S_OK;
1305 }
1306
1307 HRESULT comma_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1308 {
1309     FIXME("\n");
1310     return E_NOTIMPL;
1311 }
1312
1313 /* ECMA-262 3rd Edition    11.11 */
1314 HRESULT logical_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1315 {
1316     binary_expression_t *expr = (binary_expression_t*)_expr;
1317     exprval_t exprval;
1318     VARIANT_BOOL b;
1319     VARIANT val;
1320     HRESULT hres;
1321
1322     TRACE("\n");
1323
1324     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1325     if(FAILED(hres))
1326         return hres;
1327
1328     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1329     exprval_release(&exprval);
1330     if(FAILED(hres))
1331         return hres;
1332
1333     hres = to_boolean(&val, &b);
1334     if(SUCCEEDED(hres) && b) {
1335         ret->type = EXPRVAL_VARIANT;
1336         ret->u.var = val;
1337         return S_OK;
1338     }
1339
1340     VariantClear(&val);
1341     if(FAILED(hres))
1342         return hres;
1343
1344     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1345     if(FAILED(hres))
1346         return hres;
1347
1348     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1349     exprval_release(&exprval);
1350     if(FAILED(hres))
1351         return hres;
1352
1353     ret->type = EXPRVAL_VARIANT;
1354     ret->u.var = val;
1355     return S_OK;
1356 }
1357
1358 /* ECMA-262 3rd Edition    11.11 */
1359 HRESULT logical_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1360 {
1361     binary_expression_t *expr = (binary_expression_t*)_expr;
1362     exprval_t exprval;
1363     VARIANT_BOOL b;
1364     VARIANT val;
1365     HRESULT hres;
1366
1367     TRACE("\n");
1368
1369     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1370     if(FAILED(hres))
1371         return hres;
1372
1373     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1374     exprval_release(&exprval);
1375     if(FAILED(hres))
1376         return hres;
1377
1378     hres = to_boolean(&val, &b);
1379     if(SUCCEEDED(hres) && !b) {
1380         ret->type = EXPRVAL_VARIANT;
1381         ret->u.var = val;
1382         return S_OK;
1383     }
1384
1385     VariantClear(&val);
1386     if(FAILED(hres))
1387         return hres;
1388
1389     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1390     if(FAILED(hres))
1391         return hres;
1392
1393     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1394     exprval_release(&exprval);
1395     if(FAILED(hres))
1396         return hres;
1397
1398     ret->type = EXPRVAL_VARIANT;
1399     ret->u.var = val;
1400     return S_OK;
1401 }
1402
1403 HRESULT binary_or_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1404 {
1405     FIXME("\n");
1406     return E_NOTIMPL;
1407 }
1408
1409 HRESULT binary_xor_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1410 {
1411     FIXME("\n");
1412     return E_NOTIMPL;
1413 }
1414
1415 HRESULT binary_and_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1416 {
1417     FIXME("\n");
1418     return E_NOTIMPL;
1419 }
1420
1421 HRESULT instanceof_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1422 {
1423     FIXME("\n");
1424     return E_NOTIMPL;
1425 }
1426
1427 HRESULT in_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1428 {
1429     FIXME("\n");
1430     return E_NOTIMPL;
1431 }
1432
1433 /* ECMA-262 3rd Edition    11.6.1 */
1434 static HRESULT add_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1435 {
1436     VARIANT r, l;
1437     HRESULT hres;
1438
1439     hres = to_primitive(ctx->parser->script, lval, ei, &l);
1440     if(FAILED(hres))
1441         return hres;
1442
1443     hres = to_primitive(ctx->parser->script, rval, ei, &r);
1444     if(FAILED(hres)) {
1445         VariantClear(&l);
1446         return hres;
1447     }
1448
1449     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1450         BSTR lstr = NULL, rstr = NULL;
1451
1452         if(V_VT(&l) == VT_BSTR)
1453             lstr = V_BSTR(&l);
1454         else
1455             hres = to_string(ctx->parser->script, &l, ei, &lstr);
1456
1457         if(SUCCEEDED(hres)) {
1458             if(V_VT(&r) == VT_BSTR)
1459                 rstr = V_BSTR(&r);
1460             else
1461                 hres = to_string(ctx->parser->script, &r, ei, &rstr);
1462         }
1463
1464         if(SUCCEEDED(hres)) {
1465             int len1, len2;
1466
1467             len1 = SysStringLen(lstr);
1468             len2 = SysStringLen(rstr);
1469
1470             V_VT(retv) = VT_BSTR;
1471             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1472             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1473             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
1474         }
1475
1476         if(lstr && V_VT(&l) != VT_BSTR)
1477             SysFreeString(lstr);
1478         if(rstr && V_VT(&r) != VT_BSTR)
1479             SysFreeString(rstr);
1480     }else {
1481         VARIANT nl, nr;
1482
1483         hres = to_number(ctx->parser->script, &l, ei, &nl);
1484         if(SUCCEEDED(hres)) {
1485             hres = to_number(ctx->parser->script, &r, ei, &nr);
1486             if(SUCCEEDED(hres))
1487                 num_set_val(retv, num_val(&nl) + num_val(&nr));
1488         }
1489     }
1490
1491     VariantClear(&r);
1492     VariantClear(&l);
1493     return hres;
1494 }
1495
1496 /* ECMA-262 3rd Edition    11.6.1 */
1497 HRESULT add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1498 {
1499     binary_expression_t *expr = (binary_expression_t*)_expr;
1500
1501     TRACE("\n");
1502
1503     return binary_expr_eval(ctx, expr, add_eval, ei, ret);
1504 }
1505
1506 /* ECMA-262 3rd Edition    11.6.2 */
1507 static HRESULT sub_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1508 {
1509     VARIANT lnum, rnum;
1510     HRESULT hres;
1511
1512     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1513     if(FAILED(hres))
1514         return hres;
1515
1516     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1517     if(FAILED(hres))
1518         return hres;
1519
1520     num_set_val(retv, num_val(&lnum) - num_val(&rnum));
1521     return S_OK;
1522 }
1523
1524 /* ECMA-262 3rd Edition    11.6.2 */
1525 HRESULT sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1526 {
1527     binary_expression_t *expr = (binary_expression_t*)_expr;
1528
1529     TRACE("\n");
1530
1531     return binary_expr_eval(ctx, expr, sub_eval, ei, ret);
1532 }
1533
1534 /* ECMA-262 3rd Edition    11.5.1 */
1535 static HRESULT mul_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1536 {
1537     VARIANT lnum, rnum;
1538     HRESULT hres;
1539
1540     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1541     if(FAILED(hres))
1542         return hres;
1543
1544     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1545     if(FAILED(hres))
1546         return hres;
1547
1548     num_set_val(retv, num_val(&lnum) * num_val(&rnum));
1549     return S_OK;
1550 }
1551
1552 /* ECMA-262 3rd Edition    11.5.1 */
1553 HRESULT mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1554 {
1555     binary_expression_t *expr = (binary_expression_t*)_expr;
1556
1557     TRACE("\n");
1558
1559     return binary_expr_eval(ctx, expr, mul_eval, ei, ret);
1560 }
1561
1562 /* ECMA-262 3rd Edition    11.5.2 */
1563 static HRESULT div_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1564 {
1565     VARIANT lnum, rnum;
1566     HRESULT hres;
1567
1568     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1569     if(FAILED(hres))
1570         return hres;
1571
1572     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1573     if(FAILED(hres))
1574         return hres;
1575
1576     num_set_val(retv, num_val(&lnum) / num_val(&rnum));
1577     return S_OK;
1578 }
1579
1580 /* ECMA-262 3rd Edition    11.5.2 */
1581 HRESULT div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1582 {
1583     binary_expression_t *expr = (binary_expression_t*)_expr;
1584
1585     TRACE("\n");
1586
1587     return binary_expr_eval(ctx, expr, div_eval, ei, ret);
1588 }
1589
1590 HRESULT mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1591 {
1592     FIXME("\n");
1593     return E_NOTIMPL;
1594 }
1595
1596 HRESULT delete_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1597 {
1598     FIXME("\n");
1599     return E_NOTIMPL;
1600 }
1601
1602 HRESULT void_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1603 {
1604     FIXME("\n");
1605     return E_NOTIMPL;
1606 }
1607
1608 HRESULT typeof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1609 {
1610     unary_expression_t *expr = (unary_expression_t*)_expr;
1611     const WCHAR *str;
1612     exprval_t exprval;
1613     VARIANT val;
1614     HRESULT hres;
1615
1616     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
1617     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
1618     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
1619     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
1620     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
1621     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
1622
1623     TRACE("\n");
1624
1625     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1626     if(FAILED(hres))
1627         return hres;
1628
1629     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1630     exprval_release(&exprval);
1631     if(FAILED(hres))
1632         return hres;
1633
1634     switch(V_VT(&val)) {
1635     case VT_EMPTY:
1636         str = undefinedW;
1637         break;
1638     case VT_NULL:
1639         str = objectW;
1640         break;
1641     case VT_BOOL:
1642         str = booleanW;
1643         break;
1644     case VT_I4:
1645     case VT_R8:
1646         str = numberW;
1647         break;
1648     case VT_BSTR:
1649         str = stringW;
1650         break;
1651     case VT_DISPATCH: {
1652         DispatchEx *dispex;
1653
1654         dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val));
1655         if(dispex) {
1656             str = dispex->builtin_info->class == JSCLASS_FUNCTION ? functionW : objectW;
1657             IDispatchEx_Release(_IDispatchEx_(dispex));
1658         }else {
1659             str = objectW;
1660         }
1661         break;
1662     }
1663     default:
1664         FIXME("unhandled vt %d\n", V_VT(&val));
1665         hres = E_NOTIMPL;
1666     }
1667
1668     VariantClear(&val);
1669     if(FAILED(hres))
1670         return hres;
1671
1672     ret->type = EXPRVAL_VARIANT;
1673     V_VT(&ret->u.var) = VT_BSTR;
1674     V_BSTR(&ret->u.var) = SysAllocString(str);
1675     return S_OK;
1676 }
1677
1678 /* ECMA-262 3rd Edition    11.4.7 */
1679 HRESULT minus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1680 {
1681     unary_expression_t *expr = (unary_expression_t*)_expr;
1682     exprval_t exprval;
1683     VARIANT val, num;
1684     HRESULT hres;
1685
1686     TRACE("\n");
1687
1688     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1689     if(FAILED(hres))
1690         return hres;
1691
1692     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1693     exprval_release(&exprval);
1694     if(FAILED(hres))
1695         return hres;
1696
1697     hres = to_number(ctx->parser->script, &val, ei, &num);
1698     VariantClear(&val);
1699     if(FAILED(hres))
1700         return hres;
1701
1702     ret->type = EXPRVAL_VARIANT;
1703     num_set_val(&ret->u.var, -num_val(&num));
1704     return S_OK;
1705 }
1706
1707 HRESULT plus_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1708 {
1709     FIXME("\n");
1710     return E_NOTIMPL;
1711 }
1712
1713 /* ECMA-262 3rd Edition    11.3.1 */
1714 HRESULT post_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1715 {
1716     unary_expression_t *expr = (unary_expression_t*)_expr;
1717     VARIANT val, num;
1718     exprval_t exprval;
1719     HRESULT hres;
1720
1721     TRACE("\n");
1722
1723     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1724     if(FAILED(hres))
1725         return hres;
1726
1727     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1728     if(SUCCEEDED(hres)) {
1729         hres = to_number(ctx->parser->script, &val, ei, &num);
1730         VariantClear(&val);
1731     }
1732
1733     if(SUCCEEDED(hres)) {
1734         VARIANT inc;
1735         num_set_val(&inc, num_val(&num)+1.0);
1736         hres = put_value(ctx->parser->script, &exprval, &inc, ei);
1737     }
1738
1739     exprval_release(&exprval);
1740     if(FAILED(hres))
1741         return hres;
1742
1743     ret->type = EXPRVAL_VARIANT;
1744     ret->u.var = num;
1745     return S_OK;
1746 }
1747
1748 /* ECMA-262 3rd Edition    11.3.2 */
1749 HRESULT post_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1750 {
1751     unary_expression_t *expr = (unary_expression_t*)_expr;
1752     VARIANT val, num;
1753     exprval_t exprval;
1754     HRESULT hres;
1755
1756     TRACE("\n");
1757
1758     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1759     if(FAILED(hres))
1760         return hres;
1761
1762     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1763     if(SUCCEEDED(hres)) {
1764         hres = to_number(ctx->parser->script, &val, ei, &num);
1765         VariantClear(&val);
1766     }
1767
1768     if(SUCCEEDED(hres)) {
1769         VARIANT dec;
1770         num_set_val(&dec, num_val(&num)-1.0);
1771         hres = put_value(ctx->parser->script, &exprval, &dec, ei);
1772     }
1773
1774     exprval_release(&exprval);
1775     if(FAILED(hres))
1776         return hres;
1777
1778     ret->type = EXPRVAL_VARIANT;
1779     ret->u.var = num;
1780     return S_OK;
1781 }
1782
1783 /* ECMA-262 3rd Edition    11.4.4 */
1784 HRESULT pre_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1785 {
1786     unary_expression_t *expr = (unary_expression_t*)_expr;
1787     VARIANT val, num;
1788     exprval_t exprval;
1789     HRESULT hres;
1790
1791     TRACE("\n");
1792
1793     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1794     if(FAILED(hres))
1795         return hres;
1796
1797     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1798     if(SUCCEEDED(hres)) {
1799         hres = to_number(ctx->parser->script, &val, ei, &num);
1800         VariantClear(&val);
1801     }
1802
1803     if(SUCCEEDED(hres)) {
1804         num_set_val(&val, num_val(&num)+1.0);
1805         hres = put_value(ctx->parser->script, &exprval, &val, ei);
1806     }
1807
1808     exprval_release(&exprval);
1809     if(FAILED(hres))
1810         return hres;
1811
1812     ret->type = EXPRVAL_VARIANT;
1813     ret->u.var = val;
1814     return S_OK;
1815 }
1816
1817 /* ECMA-262 3rd Edition    11.4.5 */
1818 HRESULT pre_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1819 {
1820     unary_expression_t *expr = (unary_expression_t*)_expr;
1821     VARIANT val, num;
1822     exprval_t exprval;
1823     HRESULT hres;
1824
1825     TRACE("\n");
1826
1827     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1828     if(FAILED(hres))
1829         return hres;
1830
1831     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1832     if(SUCCEEDED(hres)) {
1833         hres = to_number(ctx->parser->script, &val, ei, &num);
1834         VariantClear(&val);
1835     }
1836
1837     if(SUCCEEDED(hres)) {
1838         num_set_val(&val, num_val(&num)-1.0);
1839         hres = put_value(ctx->parser->script, &exprval, &val, ei);
1840     }
1841
1842     exprval_release(&exprval);
1843     if(FAILED(hres))
1844         return hres;
1845
1846     ret->type = EXPRVAL_VARIANT;
1847     ret->u.var = val;
1848     return S_OK;
1849 }
1850
1851 /* ECMA-262 3rd Edition    11.9.3 */
1852 static HRESULT equal_values(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
1853 {
1854     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
1855        return equal2_values(lval, rval, ret);
1856
1857     /* FIXME: NULL disps should be handled in more general way */
1858     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
1859         VARIANT v;
1860         V_VT(&v) = VT_NULL;
1861         return equal_values(ctx, &v, rval, ei, ret);
1862     }
1863
1864     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
1865         VARIANT v;
1866         V_VT(&v) = VT_NULL;
1867         return equal_values(ctx, lval, &v, ei, ret);
1868     }
1869
1870     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
1871        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
1872         *ret = TRUE;
1873         return S_OK;
1874     }
1875
1876     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
1877         VARIANT v;
1878         HRESULT hres;
1879
1880         hres = to_number(ctx->parser->script, lval, ei, &v);
1881         if(FAILED(hres))
1882             return hres;
1883
1884         return equal_values(ctx, &v, rval, ei, ret);
1885     }
1886
1887     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
1888         VARIANT v;
1889         HRESULT hres;
1890
1891         hres = to_number(ctx->parser->script, rval, ei, &v);
1892         if(FAILED(hres))
1893             return hres;
1894
1895         return equal_values(ctx, lval, &v, ei, ret);
1896     }
1897
1898     if(V_VT(rval) == VT_BOOL) {
1899         VARIANT v;
1900
1901         V_VT(&v) = VT_I4;
1902         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
1903         return equal_values(ctx, lval, &v, ei, ret);
1904     }
1905
1906     if(V_VT(lval) == VT_BOOL) {
1907         VARIANT v;
1908
1909         V_VT(&v) = VT_I4;
1910         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
1911         return equal_values(ctx, &v, rval, ei, ret);
1912     }
1913
1914
1915     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
1916         VARIANT v;
1917         HRESULT hres;
1918
1919         hres = to_primitive(ctx->parser->script, rval, ei, &v);
1920         if(FAILED(hres))
1921             return hres;
1922
1923         hres = equal_values(ctx, lval, &v, ei, ret);
1924
1925         VariantClear(&v);
1926         return hres;
1927     }
1928
1929
1930     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
1931         VARIANT v;
1932         HRESULT hres;
1933
1934         hres = to_primitive(ctx->parser->script, lval, ei, &v);
1935         if(FAILED(hres))
1936             return hres;
1937
1938         hres = equal_values(ctx, &v, rval, ei, ret);
1939
1940         VariantClear(&v);
1941         return hres;
1942     }
1943
1944
1945     *ret = FALSE;
1946     return S_OK;
1947 }
1948
1949 /* ECMA-262 3rd Edition    11.9.1 */
1950 HRESULT equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1951 {
1952     binary_expression_t *expr = (binary_expression_t*)_expr;
1953     VARIANT rval, lval;
1954     BOOL b;
1955     HRESULT hres;
1956
1957     TRACE("\n");
1958
1959     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
1960     if(FAILED(hres))
1961         return hres;
1962
1963     hres = equal_values(ctx, &rval, &lval, ei, &b);
1964     if(FAILED(hres))
1965         return hres;
1966
1967     return return_bool(ret, b);
1968 }
1969
1970 /* ECMA-262 3rd Edition    11.9.4 */
1971 HRESULT equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1972 {
1973     binary_expression_t *expr = (binary_expression_t*)_expr;
1974     VARIANT rval, lval;
1975     BOOL b;
1976     HRESULT hres;
1977
1978     TRACE("\n");
1979
1980     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
1981     if(FAILED(hres))
1982         return hres;
1983
1984     hres = equal2_values(&rval, &lval, &b);
1985     if(FAILED(hres))
1986         return hres;
1987
1988     return return_bool(ret, b);
1989 }
1990
1991 /* ECMA-262 3rd Edition    11.9.2 */
1992 HRESULT not_equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1993 {
1994     binary_expression_t *expr = (binary_expression_t*)_expr;
1995     VARIANT rval, lval;
1996     BOOL b;
1997     HRESULT hres;
1998
1999     TRACE("\n");
2000
2001     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2002     if(FAILED(hres))
2003         return hres;
2004
2005     hres = equal_values(ctx, &lval, &rval, ei, &b);
2006     if(FAILED(hres))
2007         return hres;
2008
2009     return return_bool(ret, !b);
2010 }
2011
2012 /* ECMA-262 3rd Edition    11.9.5 */
2013 HRESULT not_equal2_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     VARIANT rval, lval;
2017     BOOL b;
2018     HRESULT hres;
2019
2020     TRACE("\n");
2021
2022     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2023     if(FAILED(hres))
2024         return hres;
2025
2026     hres = equal2_values(&rval, &lval, &b);
2027     if(FAILED(hres))
2028         return hres;
2029
2030     return return_bool(ret, !b);
2031 }
2032
2033 /* ECMA-262 3rd Edition    11.8.5 */
2034 static HRESULT less_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2035 {
2036     VARIANT l, r, ln, rn;
2037     HRESULT hres;
2038
2039     hres = to_primitive(ctx->parser->script, lval, ei, &l);
2040     if(FAILED(hres))
2041         return hres;
2042
2043     hres = to_primitive(ctx->parser->script, rval, ei, &r);
2044     if(FAILED(hres)) {
2045         VariantClear(&l);
2046         return hres;
2047     }
2048
2049     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2050         *ret = strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0;
2051         SysFreeString(V_BSTR(&l));
2052         SysFreeString(V_BSTR(&r));
2053         return S_OK;
2054     }
2055
2056     hres = to_number(ctx->parser->script, &l, ei, &ln);
2057     VariantClear(&l);
2058     if(SUCCEEDED(hres))
2059         hres = to_number(ctx->parser->script, &r, ei, &rn);
2060     VariantClear(&r);
2061     if(FAILED(hres))
2062         return hres;
2063
2064     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4)
2065         *ret = V_I4(&ln) < V_I4(&rn);
2066     else
2067         *ret = num_val(&ln) < num_val(&rn);
2068
2069     return S_OK;
2070 }
2071
2072 /* ECMA-262 3rd Edition    11.8.1 */
2073 HRESULT less_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2074 {
2075     binary_expression_t *expr = (binary_expression_t*)_expr;
2076     VARIANT rval, lval;
2077     BOOL b;
2078     HRESULT hres;
2079
2080     TRACE("\n");
2081
2082     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2083     if(FAILED(hres))
2084         return hres;
2085
2086     hres = less_eval(ctx, &lval, &rval, ei, &b);
2087     VariantClear(&lval);
2088     VariantClear(&rval);
2089     if(FAILED(hres))
2090         return hres;
2091
2092     return return_bool(ret, b);
2093 }
2094
2095 /* ECMA-262 3rd Edition    11.8.3 */
2096 HRESULT lesseq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2097 {
2098     binary_expression_t *expr = (binary_expression_t*)_expr;
2099     VARIANT rval, lval;
2100     BOOL b;
2101     HRESULT hres;
2102
2103     TRACE("\n");
2104
2105     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2106     if(FAILED(hres))
2107         return hres;
2108
2109     hres = less_eval(ctx, &rval, &lval, ei, &b);
2110     VariantClear(&lval);
2111     VariantClear(&rval);
2112     if(FAILED(hres))
2113         return hres;
2114
2115     return return_bool(ret, !b);
2116 }
2117
2118 /* ECMA-262 3rd Edition    11.8.2 */
2119 HRESULT greater_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2120 {
2121     binary_expression_t *expr = (binary_expression_t*)_expr;
2122     VARIANT rval, lval;
2123     BOOL b;
2124     HRESULT hres;
2125
2126     TRACE("\n");
2127
2128     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2129     if(FAILED(hres))
2130         return hres;
2131
2132     hres = less_eval(ctx, &rval, &lval, ei, &b);
2133     VariantClear(&lval);
2134     VariantClear(&rval);
2135     if(FAILED(hres))
2136         return hres;
2137
2138     return return_bool(ret, b);
2139 }
2140
2141 /* ECMA-262 3rd Edition    11.8.4 */
2142 HRESULT greatereq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2143 {
2144     binary_expression_t *expr = (binary_expression_t*)_expr;
2145     VARIANT rval, lval;
2146     BOOL b;
2147     HRESULT hres;
2148
2149     TRACE("\n");
2150
2151     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2152     if(FAILED(hres))
2153         return hres;
2154
2155     hres = less_eval(ctx, &lval, &rval, ei, &b);
2156     VariantClear(&lval);
2157     VariantClear(&rval);
2158     if(FAILED(hres))
2159         return hres;
2160
2161     return return_bool(ret, !b);
2162 }
2163
2164 HRESULT binary_negation_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2165 {
2166     FIXME("\n");
2167     return E_NOTIMPL;
2168 }
2169
2170 /* ECMA-262 3rd Edition    11.4.9 */
2171 HRESULT logical_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2172 {
2173     unary_expression_t *expr = (unary_expression_t*)_expr;
2174     exprval_t exprval;
2175     VARIANT_BOOL b;
2176     HRESULT hres;
2177
2178     TRACE("\n");
2179
2180     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2181     if(FAILED(hres))
2182         return hres;
2183
2184     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
2185     exprval_release(&exprval);
2186     if(FAILED(hres))
2187         return hres;
2188
2189     return return_bool(ret, !b);
2190 }
2191
2192 HRESULT left_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2193 {
2194     FIXME("\n");
2195     return E_NOTIMPL;
2196 }
2197
2198 HRESULT right_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2199 {
2200     FIXME("\n");
2201     return E_NOTIMPL;
2202 }
2203
2204 HRESULT right2_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2205 {
2206     FIXME("\n");
2207     return E_NOTIMPL;
2208 }
2209
2210 /* ECMA-262 3rd Edition    11.13.1 */
2211 HRESULT assign_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2212 {
2213     binary_expression_t *expr = (binary_expression_t*)_expr;
2214     exprval_t exprval, exprvalr;
2215     VARIANT rval;
2216     HRESULT hres;
2217
2218     TRACE("\n");
2219
2220     hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
2221     if(FAILED(hres))
2222         return hres;
2223
2224     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
2225     if(SUCCEEDED(hres)) {
2226         hres = exprval_to_value(ctx->parser->script, &exprvalr, ei, &rval);
2227         exprval_release(&exprvalr);
2228     }
2229
2230     if(SUCCEEDED(hres))
2231         hres = put_value(ctx->parser->script, &exprval, &rval, ei);
2232
2233     exprval_release(&exprval);
2234     if(FAILED(hres)) {
2235         VariantClear(&rval);
2236         return hres;
2237     }
2238
2239     ret->type = EXPRVAL_VARIANT;
2240     ret->u.var = rval;
2241     return S_OK;
2242 }
2243
2244 HRESULT assign_lshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2245 {
2246     FIXME("\n");
2247     return E_NOTIMPL;
2248 }
2249
2250 HRESULT assign_rshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2251 {
2252     FIXME("\n");
2253     return E_NOTIMPL;
2254 }
2255
2256 HRESULT assign_rrshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2257 {
2258     FIXME("\n");
2259     return E_NOTIMPL;
2260 }
2261
2262 /* ECMA-262 3rd Edition    11.13.2 */
2263 HRESULT assign_add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2264 {
2265     binary_expression_t *expr = (binary_expression_t*)_expr;
2266
2267     TRACE("\n");
2268
2269     return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
2270 }
2271
2272 /* ECMA-262 3rd Edition    11.13.2 */
2273 HRESULT assign_sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2274 {
2275     binary_expression_t *expr = (binary_expression_t*)_expr;
2276
2277     TRACE("\n");
2278
2279     return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
2280 }
2281
2282 /* ECMA-262 3rd Edition    11.13.2 */
2283 HRESULT assign_mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2284 {
2285     binary_expression_t *expr = (binary_expression_t*)_expr;
2286
2287     TRACE("\n");
2288
2289     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
2290 }
2291
2292 /* ECMA-262 3rd Edition    11.13.2 */
2293 HRESULT assign_div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2294 {
2295     binary_expression_t *expr = (binary_expression_t*)_expr;
2296
2297     TRACE("\n");
2298
2299     return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
2300 }
2301
2302 HRESULT assign_mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2303 {
2304     FIXME("\n");
2305     return E_NOTIMPL;
2306 }
2307
2308 HRESULT assign_and_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2309 {
2310     FIXME("\n");
2311     return E_NOTIMPL;
2312 }
2313
2314 HRESULT assign_or_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2315 {
2316     FIXME("\n");
2317     return E_NOTIMPL;
2318 }
2319
2320 HRESULT assign_xor_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2321 {
2322     FIXME("\n");
2323     return E_NOTIMPL;
2324 }