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