dlls/jscript/engine.c

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