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

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