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

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