dlls/jscript/engine.c

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