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