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 HRESULT for_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 699 {
 700     FIXME("\n");
 701     return E_NOTIMPL;
 702 }
 703
 704 HRESULT forin_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 705 {
 706     FIXME("\n");
 707     return E_NOTIMPL;
 708 }
 709
 710 HRESULT continue_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 711 {
 712     FIXME("\n");
 713     return E_NOTIMPL;
 714 }
 715
 716 /* ECMA-262 3rd Edition    12.8 */
 717 HRESULT break_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 718 {
 719     branch_statement_t *stat = (branch_statement_t*)_stat;
 720
 721     TRACE("\n");
 722
 723     if(stat->identifier) {
 724         FIXME("indentifier not implemented\n");
 725         return E_NOTIMPL;
 726     }
 727
 728     rt->type = RT_BREAK;
 729     V_VT(ret) = VT_EMPTY;
 730     return S_OK;
 731 }
 732
 733 /* ECMA-262 3rd Edition    12.9 */
 734 HRESULT return_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 735 {
 736     expression_statement_t *stat = (expression_statement_t*)_stat;
 737     HRESULT hres;
 738
 739     TRACE("\n");
 740
 741     if(stat->expr) {
 742         exprval_t exprval;
 743
 744         hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 745         if(FAILED(hres))
 746             return hres;
 747
 748         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, ret);
 749         exprval_release(&exprval);
 750         if(FAILED(hres))
 751             return hres;
 752     }else {
 753         V_VT(ret) = VT_EMPTY;
 754     }
 755
 756     TRACE("= %s\n", debugstr_variant(ret));
 757     rt->type = RT_RETURN;
 758     return S_OK;
 759 }
 760
 761 HRESULT with_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 762 {
 763     FIXME("\n");
 764     return E_NOTIMPL;
 765 }
 766
 767 HRESULT labelled_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 768 {
 769     FIXME("\n");
 770     return E_NOTIMPL;
 771 }
 772
 773 /* ECMA-262 3rd Edition    12.13 */
 774 HRESULT switch_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 775 {
 776     switch_statement_t *stat = (switch_statement_t*)_stat;
 777     case_clausule_t *iter, *default_clausule = NULL;
 778     statement_t *stat_iter;
 779     VARIANT val, cval;
 780     exprval_t exprval;
 781     BOOL b;
 782     HRESULT hres;
 783
 784     TRACE("\n");
 785
 786     hres = expr_eval(ctx, stat->expr, 0, &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     for(iter = stat->case_list; iter; iter = iter->next) {
 796         if(!iter->expr) {
 797             default_clausule = iter;
 798             continue;
 799         }
 800
 801         hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
 802         if(FAILED(hres))
 803             break;
 804
 805         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &cval);
 806         exprval_release(&exprval);
 807         if(FAILED(hres))
 808             break;
 809
 810         hres = equal2_values(&val, &cval, &b);
 811         VariantClear(&cval);
 812         if(FAILED(hres) || b)
 813             break;
 814     }
 815
 816     VariantClear(&val);
 817     if(FAILED(hres))
 818         return hres;
 819
 820     if(!iter)
 821         iter = default_clausule;
 822
 823     V_VT(&val) = VT_EMPTY;
 824     if(iter) {
 825         VARIANT tmp;
 826
 827         for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
 828             hres = stat_eval(ctx, stat_iter, rt, &tmp);
 829             if(FAILED(hres))
 830                 break;
 831
 832             VariantClear(&val);
 833             val = tmp;
 834
 835             if(rt->type != RT_NORMAL)
 836                 break;
 837         }
 838     }
 839
 840     if(FAILED(hres)) {
 841         VariantClear(&val);
 842         return hres;
 843     }
 844
 845     if(rt->type == RT_BREAK)
 846         rt->type = RT_NORMAL;
 847
 848     *ret = val;
 849     return S_OK;
 850 }
 851
 852 /* ECMA-262 3rd Edition    12.13 */
 853 HRESULT throw_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 854 {
 855     expression_statement_t *stat = (expression_statement_t*)_stat;
 856     exprval_t exprval;
 857     VARIANT val;
 858     HRESULT hres;
 859
 860     TRACE("\n");
 861
 862     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 863     if(FAILED(hres))
 864         return hres;
 865
 866     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 867     exprval_release(&exprval);
 868     if(FAILED(hres))
 869         return hres;
 870
 871     rt->ei.var = val;
 872     return DISP_E_EXCEPTION;
 873 }
 874
 875 /* ECMA-262 3rd Edition    12.14 */
 876 static HRESULT catch_eval(exec_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
 877 {
 878     DispatchEx *var_disp;
 879     VARIANT ex, val;
 880     HRESULT hres;
 881
 882     ex = rt->ei.var;
 883     memset(&rt->ei, 0, sizeof(jsexcept_t));
 884
 885     hres = create_dispex(ctx->parser->script, NULL, NULL, &var_disp);
 886     if(SUCCEEDED(hres)) {
 887         hres = jsdisp_propput_name(var_disp, block->identifier, ctx->parser->script->lcid,
 888                 &ex, &rt->ei, NULL/*FIXME*/);
 889         if(SUCCEEDED(hres)) {
 890             hres = scope_push(ctx->scope_chain, var_disp, &ctx->scope_chain);
 891             if(SUCCEEDED(hres)) {
 892                 hres = stat_eval(ctx, block->statement, rt, &val);
 893                 scope_pop(&ctx->scope_chain);
 894             }
 895         }
 896
 897         jsdisp_release(var_disp);
 898     }
 899
 900     VariantClear(&ex);
 901     if(FAILED(hres))
 902         return hres;
 903
 904     *ret = val;
 905     return S_OK;
 906 }
 907
 908 /* ECMA-262 3rd Edition    12.14 */
 909 HRESULT try_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 910 {
 911     try_statement_t *stat = (try_statement_t*)_stat;
 912     VARIANT val;
 913     HRESULT hres;
 914
 915     TRACE("\n");
 916
 917     hres = stat_eval(ctx, stat->try_statement, rt, &val);
 918     if(FAILED(hres)) {
 919         TRACE("EXCEPTION\n");
 920         if(!stat->catch_block)
 921             return hres;
 922
 923         hres = catch_eval(ctx, stat->catch_block, rt, &val);
 924         if(FAILED(hres))
 925             return hres;
 926     }
 927
 928     if(stat->finally_statement) {
 929         VariantClear(&val);
 930         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
 931         if(FAILED(hres))
 932             return hres;
 933     }
 934
 935     *ret = val;
 936     return S_OK;
 937 }
 938
 939 static HRESULT return_bool(exprval_t *ret, DWORD b)
 940 {
 941     ret->type = EXPRVAL_VARIANT;
 942     V_VT(&ret->u.var) = VT_BOOL;
 943     V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
 944
 945     return S_OK;
 946 }
 947
 948 static HRESULT get_binary_expr_values(exec_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
 949 {
 950     exprval_t exprval;
 951     HRESULT hres;
 952
 953     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
 954     if(FAILED(hres))
 955         return hres;
 956
 957     hres = exprval_to_value(ctx->parser->script, &exprval, ei, lval);
 958     exprval_release(&exprval);
 959     if(FAILED(hres))
 960         return hres;
 961
 962     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
 963     if(SUCCEEDED(hres)) {
 964         hres = exprval_to_value(ctx->parser->script, &exprval, ei, rval);
 965         exprval_release(&exprval);
 966     }
 967
 968     if(FAILED(hres)) {
 969         VariantClear(lval);
 970         return hres;
 971     }
 972
 973     return S_OK;
 974 }
 975
 976 typedef HRESULT (*oper_t)(exec_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
 977
 978 static HRESULT binary_expr_eval(exec_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
 979         exprval_t *ret)
 980 {
 981     VARIANT lval, rval, retv;
 982     HRESULT hres;
 983
 984     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
 985     if(FAILED(hres))
 986         return hres;
 987
 988     hres = oper(ctx, &lval, &rval, ei, &retv);
 989     VariantClear(&lval);
 990     VariantClear(&rval);
 991     if(FAILED(hres))
 992         return hres;
 993
 994     ret->type = EXPRVAL_VARIANT;
 995     ret->u.var = retv;
 996     return S_OK;
 997 }
 998
 999 /* ECMA-262 3rd Edition    11.13.2 */
1000 static HRESULT assign_oper_eval(exec_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1001                                 jsexcept_t *ei, exprval_t *ret)
1002 {
1003     VARIANT retv, lval, rval;
1004     exprval_t exprval, exprvalr;
1005     HRESULT hres;
1006
1007     hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1008     if(FAILED(hres))
1009         return hres;
1010
1011     hres = exprval_value(ctx->parser->script, &exprval, ei, &lval);
1012     if(SUCCEEDED(hres)) {
1013         hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1014         if(SUCCEEDED(hres)) {
1015             hres = exprval_value(ctx->parser->script, &exprvalr, ei, &rval);
1016             exprval_release(&exprvalr);
1017         }
1018         if(SUCCEEDED(hres)) {
1019             hres = oper(ctx, &lval, &rval, ei, &retv);
1020             VariantClear(&rval);
1021         }
1022         VariantClear(&lval);
1023     }
1024
1025     if(SUCCEEDED(hres)) {
1026         hres = put_value(ctx->parser->script, &exprval, &retv, ei);
1027         if(FAILED(hres))
1028             VariantClear(&retv);
1029     }
1030     exprval_release(&exprval);
1031
1032     if(FAILED(hres))
1033         return hres;
1034
1035     ret->type = EXPRVAL_VARIANT;
1036     ret->u.var = retv;
1037     return S_OK;
1038 }
1039
1040 /* ECMA-262 3rd Edition    13 */
1041 HRESULT function_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1042 {
1043     function_expression_t *expr = (function_expression_t*)_expr;
1044     DispatchEx *dispex;
1045     VARIANT var;
1046     HRESULT hres;
1047
1048     TRACE("\n");
1049
1050     hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain, &dispex);
1051     if(FAILED(hres))
1052         return hres;
1053
1054     V_VT(&var) = VT_DISPATCH;
1055     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
1056
1057     if(expr->identifier) {
1058         hres = jsdisp_propput_name(ctx->var_disp, expr->identifier, ctx->parser->script->lcid, &var, ei, NULL/*FIXME*/);
1059         if(FAILED(hres)) {
1060             jsdisp_release(dispex);
1061             return hres;
1062         }
1063     }
1064
1065     ret->type = EXPRVAL_VARIANT;
1066     ret->u.var = var;
1067     return S_OK;
1068 }
1069
1070 /* ECMA-262 3rd Edition    11.12 */
1071 HRESULT conditional_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1072 {
1073     conditional_expression_t *expr = (conditional_expression_t*)_expr;
1074     exprval_t exprval;
1075     VARIANT_BOOL b;
1076     HRESULT hres;
1077
1078     TRACE("\n");
1079
1080     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1081     if(FAILED(hres))
1082         return hres;
1083
1084     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
1085     exprval_release(&exprval);
1086     if(FAILED(hres))
1087         return hres;
1088
1089     return expr_eval(ctx, b ? expr->true_expression : expr->false_expression, flags, ei, ret);
1090 }
1091
1092 /* ECMA-262 3rd Edition    11.2.1 */
1093 HRESULT array_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1094 {
1095     array_expression_t *expr = (array_expression_t*)_expr;
1096     exprval_t exprval;
1097     VARIANT member, val;
1098     DISPID id;
1099     BSTR str;
1100     IDispatch *obj = NULL;
1101     HRESULT hres;
1102
1103     TRACE("\n");
1104
1105     hres = expr_eval(ctx, expr->member_expr, EXPR_NEWREF, ei, &exprval);
1106     if(FAILED(hres))
1107         return hres;
1108
1109     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1110     exprval_release(&exprval);
1111     if(FAILED(hres))
1112         return hres;
1113
1114     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1115     if(SUCCEEDED(hres)) {
1116         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1117         exprval_release(&exprval);
1118     }
1119
1120     if(SUCCEEDED(hres))
1121         hres = to_object(ctx, &member, &obj);
1122     VariantClear(&member);
1123     if(SUCCEEDED(hres)) {
1124         hres = to_string(ctx->parser->script, &val, ei, &str);
1125         if(SUCCEEDED(hres)) {
1126             if(flags & EXPR_STRREF) {
1127                 ret->type = EXPRVAL_NAMEREF;
1128                 ret->u.nameref.disp = obj;
1129                 ret->u.nameref.name = str;
1130                 return S_OK;
1131             }
1132
1133             hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1134         }
1135
1136         if(SUCCEEDED(hres)) {
1137             exprval_set_idref(ret, obj, id);
1138         }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1139             exprval_init(ret);
1140             hres = S_OK;
1141         }
1142
1143         IDispatch_Release(obj);
1144     }
1145
1146     return hres;
1147 }
1148
1149 /* ECMA-262 3rd Edition    11.2.1 */
1150 HRESULT member_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1151 {
1152     member_expression_t *expr = (member_expression_t*)_expr;
1153     IDispatch *obj = NULL;
1154     exprval_t exprval;
1155     VARIANT member;
1156     DISPID id;
1157     BSTR str;
1158     HRESULT hres;
1159
1160     TRACE("\n");
1161
1162     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1163     if(FAILED(hres))
1164         return hres;
1165
1166     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1167     exprval_release(&exprval);
1168     if(FAILED(hres))
1169         return hres;
1170
1171     hres = to_object(ctx, &member, &obj);
1172     VariantClear(&member);
1173     if(FAILED(hres))
1174         return hres;
1175
1176     str = SysAllocString(expr->identifier);
1177     if(flags & EXPR_STRREF) {
1178         ret->type = EXPRVAL_NAMEREF;
1179         ret->u.nameref.disp = obj;
1180         ret->u.nameref.name = str;
1181         return S_OK;
1182     }
1183
1184     hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1185     SysFreeString(str);
1186     if(SUCCEEDED(hres)) {
1187         exprval_set_idref(ret, obj, id);
1188     }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1189         exprval_init(ret);
1190         hres = S_OK;
1191     }
1192
1193     IDispatch_Release(obj);
1194     return hres;
1195 }
1196
1197 static void free_dp(DISPPARAMS *dp)
1198 {
1199     DWORD i;
1200
1201     for(i=0; i < dp->cArgs; i++)
1202         VariantClear(dp->rgvarg+i);
1203     heap_free(dp->rgvarg);
1204 }
1205
1206 static HRESULT args_to_param(exec_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1207 {
1208     VARIANTARG *vargs;
1209     exprval_t exprval;
1210     argument_t *iter;
1211     DWORD cnt = 0, i;
1212     HRESULT hres = S_OK;
1213
1214     memset(dp, 0, sizeof(*dp));
1215     if(!args)
1216         return S_OK;
1217
1218     for(iter = args; iter; iter = iter->next)
1219         cnt++;
1220
1221     vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1222     if(!vargs)
1223         return E_OUTOFMEMORY;
1224
1225     for(i = cnt, iter = args; iter; iter = iter->next) {
1226         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1227         if(FAILED(hres))
1228             break;
1229
1230         hres = exprval_to_value(ctx->parser->script, &exprval, ei, vargs + (--i));
1231         exprval_release(&exprval);
1232         if(FAILED(hres))
1233             break;
1234     }
1235
1236     if(FAILED(hres)) {
1237         free_dp(dp);
1238         return hres;
1239     }
1240
1241     dp->rgvarg = vargs;
1242     dp->cArgs = cnt;
1243     return S_OK;
1244 }
1245
1246 /* ECMA-262 3rd Edition    11.2.2 */
1247 HRESULT new_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1248 {
1249     call_expression_t *expr = (call_expression_t*)_expr;
1250     exprval_t exprval;
1251     VARIANT constr, var;
1252     DISPPARAMS dp;
1253     HRESULT hres;
1254
1255     TRACE("\n");
1256
1257     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1258     if(FAILED(hres))
1259         return hres;
1260
1261     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1262     if(SUCCEEDED(hres))
1263         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &constr);
1264     exprval_release(&exprval);
1265     if(FAILED(hres))
1266         return hres;
1267
1268     if(V_VT(&constr) != VT_DISPATCH) {
1269         FIXME("throw TypeError\n");
1270         VariantClear(&constr);
1271         return E_FAIL;
1272     }
1273
1274     hres = disp_call(V_DISPATCH(&constr), DISPID_VALUE, ctx->parser->script->lcid,
1275                      DISPATCH_CONSTRUCT, &dp, &var, ei, NULL/*FIXME*/);
1276     IDispatch_Release(V_DISPATCH(&constr));
1277     if(FAILED(hres))
1278         return hres;
1279
1280     ret->type = EXPRVAL_VARIANT;
1281     ret->u.var = var;
1282     return S_OK;
1283 }
1284
1285 HRESULT call_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1286 {
1287     call_expression_t *expr = (call_expression_t*)_expr;
1288     VARIANT func, var;
1289     exprval_t exprval;
1290     DISPPARAMS dp;
1291     HRESULT hres;
1292
1293     TRACE("\n");
1294
1295     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1296     if(FAILED(hres))
1297         return hres;
1298
1299     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1300     if(SUCCEEDED(hres)) {
1301         switch(exprval.type) {
1302         case EXPRVAL_IDREF:
1303             hres = disp_call(exprval.u.idref.disp, exprval.u.idref.id, ctx->parser->script->lcid, DISPATCH_METHOD,
1304                     &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1305             if(flags & EXPR_NOVAL)
1306                 V_VT(&var) = VT_EMPTY;
1307             break;
1308         default:
1309             FIXME("unimplemented type %d\n", V_VT(&func));
1310             hres = E_NOTIMPL;
1311         }
1312
1313         free_dp(&dp);
1314     }
1315
1316     exprval_release(&exprval);
1317     if(FAILED(hres))
1318         return hres;
1319
1320     TRACE("= %s\n", debugstr_variant(&var));
1321     ret->type = EXPRVAL_VARIANT;
1322     ret->u.var = var;
1323     return S_OK;
1324 }
1325
1326 HRESULT this_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1327 {
1328     TRACE("\n");
1329
1330     ret->type = EXPRVAL_VARIANT;
1331     V_VT(&ret->u.var) = VT_DISPATCH;
1332     V_DISPATCH(&ret->u.var) = ctx->this_obj;
1333     IDispatch_AddRef(ctx->this_obj);
1334     return S_OK;
1335 }
1336
1337 /* ECMA-262 3rd Edition    10.1.4 */
1338 HRESULT identifier_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1339 {
1340     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1341     BSTR identifier;
1342     HRESULT hres;
1343
1344     TRACE("\n");
1345
1346     identifier = SysAllocString(expr->identifier);
1347     if(!identifier)
1348         return E_OUTOFMEMORY;
1349
1350     hres = identifier_eval(ctx, identifier, flags, ret);
1351
1352     SysFreeString(identifier);
1353     return hres;
1354 }
1355
1356 /* ECMA-262 3rd Edition    7.8 */
1357 HRESULT literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1358 {
1359     literal_expression_t *expr = (literal_expression_t*)_expr;
1360     VARIANT var;
1361     HRESULT hres;
1362
1363     TRACE("\n");
1364
1365     hres = literal_to_var(expr->literal, &var);
1366     if(FAILED(hres))
1367         return hres;
1368
1369     ret->type = EXPRVAL_VARIANT;
1370     ret->u.var = var;
1371     return S_OK;
1372 }
1373
1374 /* ECMA-262 3rd Edition    11.1.4 */
1375 HRESULT array_literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1376 {
1377     array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
1378     DWORD length = 0, i = 0;
1379     array_element_t *elem;
1380     DispatchEx *array;
1381     exprval_t exprval;
1382     VARIANT val;
1383     HRESULT hres;
1384
1385     TRACE("\n");
1386
1387     for(elem = expr->element_list; elem; elem = elem->next)
1388         length += elem->elision+1;
1389     length += expr->length;
1390
1391     hres = create_array(ctx->parser->script, length, &array);
1392     if(FAILED(hres))
1393         return hres;
1394
1395     for(elem = expr->element_list; elem; elem = elem->next) {
1396         i += elem->elision;
1397
1398         hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
1399         if(FAILED(hres))
1400             break;
1401
1402         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1403         exprval_release(&exprval);
1404         if(FAILED(hres))
1405             break;
1406
1407         hres = jsdisp_propput_idx(array, i, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1408         VariantClear(&val);
1409         if(FAILED(hres))
1410             break;
1411
1412         i++;
1413     }
1414
1415     if(FAILED(hres)) {
1416         jsdisp_release(array);
1417         return hres;
1418     }
1419
1420     ret->type = EXPRVAL_VARIANT;
1421     V_VT(&ret->u.var) = VT_DISPATCH;
1422     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(array);
1423     return S_OK;
1424 }
1425
1426 /* ECMA-262 3rd Edition    11.1.5 */
1427 HRESULT property_value_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1428 {
1429     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1430     VARIANT val, tmp;
1431     DispatchEx *obj;
1432     prop_val_t *iter;
1433     exprval_t exprval;
1434     BSTR name;
1435     HRESULT hres;
1436
1437     TRACE("\n");
1438
1439     hres = create_object(ctx->parser->script, NULL, &obj);
1440     if(FAILED(hres))
1441         return hres;
1442
1443     for(iter = expr->property_list; iter; iter = iter->next) {
1444         hres = literal_to_var(iter->name, &tmp);
1445         if(FAILED(hres))
1446             break;
1447
1448         hres = to_string(ctx->parser->script, &tmp, ei, &name);
1449         VariantClear(&tmp);
1450         if(FAILED(hres))
1451             break;
1452
1453         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1454         if(SUCCEEDED(hres)) {
1455             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1456             exprval_release(&exprval);
1457             if(SUCCEEDED(hres)) {
1458                 hres = jsdisp_propput_name(obj, name, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1459                 VariantClear(&val);
1460             }
1461         }
1462
1463         SysFreeString(name);
1464         if(FAILED(hres))
1465             break;
1466     }
1467
1468     if(FAILED(hres)) {
1469         jsdisp_release(obj);
1470         return hres;
1471     }
1472
1473     ret->type = EXPRVAL_VARIANT;
1474     V_VT(&ret->u.var) = VT_DISPATCH;
1475     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(obj);
1476     return S_OK;
1477 }
1478
1479 /* ECMA-262 3rd Edition    11.14 */
1480 HRESULT comma_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1481 {
1482     binary_expression_t *expr = (binary_expression_t*)_expr;
1483     VARIANT lval, rval;
1484     HRESULT hres;
1485
1486     TRACE("\n");
1487
1488     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1489     if(FAILED(hres))
1490         return hres;
1491
1492     VariantClear(&lval);
1493
1494     ret->type = EXPRVAL_VARIANT;
1495     ret->u.var = rval;
1496     return S_OK;
1497 }
1498
1499 /* ECMA-262 3rd Edition    11.11 */
1500 HRESULT logical_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1501 {
1502     binary_expression_t *expr = (binary_expression_t*)_expr;
1503     exprval_t exprval;
1504     VARIANT_BOOL b;
1505     VARIANT val;
1506     HRESULT hres;
1507
1508     TRACE("\n");
1509
1510     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1511     if(FAILED(hres))
1512         return hres;
1513
1514     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1515     exprval_release(&exprval);
1516     if(FAILED(hres))
1517         return hres;
1518
1519     hres = to_boolean(&val, &b);
1520     if(SUCCEEDED(hres) && b) {
1521         ret->type = EXPRVAL_VARIANT;
1522         ret->u.var = val;
1523         return S_OK;
1524     }
1525
1526     VariantClear(&val);
1527     if(FAILED(hres))
1528         return hres;
1529
1530     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1531     if(FAILED(hres))
1532         return hres;
1533
1534     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1535     exprval_release(&exprval);
1536     if(FAILED(hres))
1537         return hres;
1538
1539     ret->type = EXPRVAL_VARIANT;
1540     ret->u.var = val;
1541     return S_OK;
1542 }
1543
1544 /* ECMA-262 3rd Edition    11.11 */
1545 HRESULT logical_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1546 {
1547     binary_expression_t *expr = (binary_expression_t*)_expr;
1548     exprval_t exprval;
1549     VARIANT_BOOL b;
1550     VARIANT val;
1551     HRESULT hres;
1552
1553     TRACE("\n");
1554
1555     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1556     if(FAILED(hres))
1557         return hres;
1558
1559     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1560     exprval_release(&exprval);
1561     if(FAILED(hres))
1562         return hres;
1563
1564     hres = to_boolean(&val, &b);
1565     if(SUCCEEDED(hres) && !b) {
1566         ret->type = EXPRVAL_VARIANT;
1567         ret->u.var = val;
1568         return S_OK;
1569     }
1570
1571     VariantClear(&val);
1572     if(FAILED(hres))
1573         return hres;
1574
1575     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1576     if(FAILED(hres))
1577         return hres;
1578
1579     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1580     exprval_release(&exprval);
1581     if(FAILED(hres))
1582         return hres;
1583
1584     ret->type = EXPRVAL_VARIANT;
1585     ret->u.var = val;
1586     return S_OK;
1587 }
1588
1589 /* ECMA-262 3rd Edition    11.10 */
1590 static HRESULT bitor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1591 {
1592     INT li, ri;
1593     HRESULT hres;
1594
1595     hres = to_int32(ctx->parser->script, lval, ei, &li);
1596     if(FAILED(hres))
1597         return hres;
1598
1599     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1600     if(FAILED(hres))
1601         return hres;
1602
1603     V_VT(retv) = VT_I4;
1604     V_I4(retv) = li|ri;
1605     return S_OK;
1606 }
1607
1608 /* ECMA-262 3rd Edition    11.10 */
1609 HRESULT binary_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1610 {
1611     binary_expression_t *expr = (binary_expression_t*)_expr;
1612
1613     TRACE("\n");
1614
1615     return binary_expr_eval(ctx, expr, bitor_eval, ei, ret);
1616 }
1617
1618 /* ECMA-262 3rd Edition    11.10 */
1619 static HRESULT xor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1620 {
1621     INT li, ri;
1622     HRESULT hres;
1623
1624     hres = to_int32(ctx->parser->script, lval, ei, &li);
1625     if(FAILED(hres))
1626         return hres;
1627
1628     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1629     if(FAILED(hres))
1630         return hres;
1631
1632     V_VT(retv) = VT_I4;
1633     V_I4(retv) = li^ri;
1634     return S_OK;
1635 }
1636
1637 /* ECMA-262 3rd Edition    11.10 */
1638 HRESULT binary_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1639 {
1640     binary_expression_t *expr = (binary_expression_t*)_expr;
1641
1642     TRACE("\n");
1643
1644     return binary_expr_eval(ctx, expr, xor_eval, ei, ret);
1645 }
1646
1647 /* ECMA-262 3rd Edition    11.10 */
1648 static HRESULT bitand_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1649 {
1650     INT li, ri;
1651     HRESULT hres;
1652
1653     hres = to_int32(ctx->parser->script, lval, ei, &li);
1654     if(FAILED(hres))
1655         return hres;
1656
1657     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1658     if(FAILED(hres))
1659         return hres;
1660
1661     V_VT(retv) = VT_I4;
1662     V_I4(retv) = li&ri;
1663     return S_OK;
1664 }
1665
1666 /* ECMA-262 3rd Edition    11.10 */
1667 HRESULT binary_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1668 {
1669     binary_expression_t *expr = (binary_expression_t*)_expr;
1670
1671     TRACE("\n");
1672
1673     return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
1674 }
1675
1676 HRESULT instanceof_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1677 {
1678     FIXME("\n");
1679     return E_NOTIMPL;
1680 }
1681
1682 HRESULT in_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1683 {
1684     FIXME("\n");
1685     return E_NOTIMPL;
1686 }
1687
1688 /* ECMA-262 3rd Edition    11.6.1 */
1689 static HRESULT add_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1690 {
1691     VARIANT r, l;
1692     HRESULT hres;
1693
1694     hres = to_primitive(ctx->parser->script, lval, ei, &l);
1695     if(FAILED(hres))
1696         return hres;
1697
1698     hres = to_primitive(ctx->parser->script, rval, ei, &r);
1699     if(FAILED(hres)) {
1700         VariantClear(&l);
1701         return hres;
1702     }
1703
1704     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1705         BSTR lstr = NULL, rstr = NULL;
1706
1707         if(V_VT(&l) == VT_BSTR)
1708             lstr = V_BSTR(&l);
1709         else
1710             hres = to_string(ctx->parser->script, &l, ei, &lstr);
1711
1712         if(SUCCEEDED(hres)) {
1713             if(V_VT(&r) == VT_BSTR)
1714                 rstr = V_BSTR(&r);
1715             else
1716                 hres = to_string(ctx->parser->script, &r, ei, &rstr);
1717         }
1718
1719         if(SUCCEEDED(hres)) {
1720             int len1, len2;
1721
1722             len1 = SysStringLen(lstr);
1723             len2 = SysStringLen(rstr);
1724
1725             V_VT(retv) = VT_BSTR;
1726             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1727             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1728             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
1729         }
1730
1731         if(lstr && V_VT(&l) != VT_BSTR)
1732             SysFreeString(lstr);
1733         if(rstr && V_VT(&r) != VT_BSTR)
1734             SysFreeString(rstr);
1735     }else {
1736         VARIANT nl, nr;
1737
1738         hres = to_number(ctx->parser->script, &l, ei, &nl);
1739         if(SUCCEEDED(hres)) {
1740             hres = to_number(ctx->parser->script, &r, ei, &nr);
1741             if(SUCCEEDED(hres))
1742                 num_set_val(retv, num_val(&nl) + num_val(&nr));
1743         }
1744     }
1745
1746     VariantClear(&r);
1747     VariantClear(&l);
1748     return hres;
1749 }
1750
1751 /* ECMA-262 3rd Edition    11.6.1 */
1752 HRESULT add_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, add_eval, ei, ret);
1759 }
1760
1761 /* ECMA-262 3rd Edition    11.6.2 */
1762 static HRESULT sub_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1763 {
1764     VARIANT lnum, rnum;
1765     HRESULT hres;
1766
1767     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1768     if(FAILED(hres))
1769         return hres;
1770
1771     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1772     if(FAILED(hres))
1773         return hres;
1774
1775     num_set_val(retv, num_val(&lnum) - num_val(&rnum));
1776     return S_OK;
1777 }
1778
1779 /* ECMA-262 3rd Edition    11.6.2 */
1780 HRESULT sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1781 {
1782     binary_expression_t *expr = (binary_expression_t*)_expr;
1783
1784     TRACE("\n");
1785
1786     return binary_expr_eval(ctx, expr, sub_eval, ei, ret);
1787 }
1788
1789 /* ECMA-262 3rd Edition    11.5.1 */
1790 static HRESULT mul_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1791 {
1792     VARIANT lnum, rnum;
1793     HRESULT hres;
1794
1795     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1796     if(FAILED(hres))
1797         return hres;
1798
1799     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1800     if(FAILED(hres))
1801         return hres;
1802
1803     num_set_val(retv, num_val(&lnum) * num_val(&rnum));
1804     return S_OK;
1805 }
1806
1807 /* ECMA-262 3rd Edition    11.5.1 */
1808 HRESULT mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1809 {
1810     binary_expression_t *expr = (binary_expression_t*)_expr;
1811
1812     TRACE("\n");
1813
1814     return binary_expr_eval(ctx, expr, mul_eval, ei, ret);
1815 }
1816
1817 /* ECMA-262 3rd Edition    11.5.2 */
1818 static HRESULT div_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1819 {
1820     VARIANT lnum, rnum;
1821     HRESULT hres;
1822
1823     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1824     if(FAILED(hres))
1825         return hres;
1826
1827     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1828     if(FAILED(hres))
1829         return hres;
1830
1831     num_set_val(retv, num_val(&lnum) / num_val(&rnum));
1832     return S_OK;
1833 }
1834
1835 /* ECMA-262 3rd Edition    11.5.2 */
1836 HRESULT div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1837 {
1838     binary_expression_t *expr = (binary_expression_t*)_expr;
1839
1840     TRACE("\n");
1841
1842     return binary_expr_eval(ctx, expr, div_eval, ei, ret);
1843 }
1844
1845 HRESULT mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1846 {
1847     FIXME("\n");
1848     return E_NOTIMPL;
1849 }
1850
1851 HRESULT delete_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1852 {
1853     FIXME("\n");
1854     return E_NOTIMPL;
1855 }
1856
1857 HRESULT void_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1858 {
1859     FIXME("\n");
1860     return E_NOTIMPL;
1861 }
1862
1863 HRESULT typeof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1864 {
1865     unary_expression_t *expr = (unary_expression_t*)_expr;
1866     const WCHAR *str;
1867     exprval_t exprval;
1868     VARIANT val;
1869     HRESULT hres;
1870
1871     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
1872     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
1873     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
1874     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
1875     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
1876     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
1877
1878     TRACE("\n");
1879
1880     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1881     if(FAILED(hres))
1882         return hres;
1883
1884     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1885     exprval_release(&exprval);
1886     if(FAILED(hres))
1887         return hres;
1888
1889     switch(V_VT(&val)) {
1890     case VT_EMPTY:
1891         str = undefinedW;
1892         break;
1893     case VT_NULL:
1894         str = objectW;
1895         break;
1896     case VT_BOOL:
1897         str = booleanW;
1898         break;
1899     case VT_I4:
1900     case VT_R8:
1901         str = numberW;
1902         break;
1903     case VT_BSTR:
1904         str = stringW;
1905         break;
1906     case VT_DISPATCH: {
1907         DispatchEx *dispex;
1908
1909         dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val));
1910         if(dispex) {
1911             str = dispex->builtin_info->class == JSCLASS_FUNCTION ? functionW : objectW;
1912             IDispatchEx_Release(_IDispatchEx_(dispex));
1913         }else {
1914             str = objectW;
1915         }
1916         break;
1917     }
1918     default:
1919         FIXME("unhandled vt %d\n", V_VT(&val));
1920         hres = E_NOTIMPL;
1921     }
1922
1923     VariantClear(&val);
1924     if(FAILED(hres))
1925         return hres;
1926
1927     ret->type = EXPRVAL_VARIANT;
1928     V_VT(&ret->u.var) = VT_BSTR;
1929     V_BSTR(&ret->u.var) = SysAllocString(str);
1930     return S_OK;
1931 }
1932
1933 /* ECMA-262 3rd Edition    11.4.7 */
1934 HRESULT minus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1935 {
1936     unary_expression_t *expr = (unary_expression_t*)_expr;
1937     exprval_t exprval;
1938     VARIANT val, num;
1939     HRESULT hres;
1940
1941     TRACE("\n");
1942
1943     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1944     if(FAILED(hres))
1945         return hres;
1946
1947     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1948     exprval_release(&exprval);
1949     if(FAILED(hres))
1950         return hres;
1951
1952     hres = to_number(ctx->parser->script, &val, ei, &num);
1953     VariantClear(&val);
1954     if(FAILED(hres))
1955         return hres;
1956
1957     ret->type = EXPRVAL_VARIANT;
1958     num_set_val(&ret->u.var, -num_val(&num));
1959     return S_OK;
1960 }
1961
1962 /* ECMA-262 3rd Edition    11.4.6 */
1963 HRESULT plus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1964 {
1965     unary_expression_t *expr = (unary_expression_t*)_expr;
1966     exprval_t exprval;
1967     VARIANT val, num;
1968     HRESULT hres;
1969
1970     TRACE("\n");
1971
1972     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1973     if(FAILED(hres))
1974         return hres;
1975
1976     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1977     exprval_release(&exprval);
1978     if(FAILED(hres))
1979         return hres;
1980
1981     hres = to_number(ctx->parser->script, &val, ei, &num);
1982     if(FAILED(hres))
1983         return hres;
1984
1985     ret->type = EXPRVAL_VARIANT;
1986     ret->u.var = num;
1987     return S_OK;
1988 }
1989
1990 /* ECMA-262 3rd Edition    11.3.1 */
1991 HRESULT post_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1992 {
1993     unary_expression_t *expr = (unary_expression_t*)_expr;
1994     VARIANT val, num;
1995     exprval_t exprval;
1996     HRESULT hres;
1997
1998     TRACE("\n");
1999
2000     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2001     if(FAILED(hres))
2002         return hres;
2003
2004     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2005     if(SUCCEEDED(hres)) {
2006         hres = to_number(ctx->parser->script, &val, ei, &num);
2007         VariantClear(&val);
2008     }
2009
2010     if(SUCCEEDED(hres)) {
2011         VARIANT inc;
2012         num_set_val(&inc, num_val(&num)+1.0);
2013         hres = put_value(ctx->parser->script, &exprval, &inc, ei);
2014     }
2015
2016     exprval_release(&exprval);
2017     if(FAILED(hres))
2018         return hres;
2019
2020     ret->type = EXPRVAL_VARIANT;
2021     ret->u.var = num;
2022     return S_OK;
2023 }
2024
2025 /* ECMA-262 3rd Edition    11.3.2 */
2026 HRESULT post_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2027 {
2028     unary_expression_t *expr = (unary_expression_t*)_expr;
2029     VARIANT val, num;
2030     exprval_t exprval;
2031     HRESULT hres;
2032
2033     TRACE("\n");
2034
2035     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2036     if(FAILED(hres))
2037         return hres;
2038
2039     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2040     if(SUCCEEDED(hres)) {
2041         hres = to_number(ctx->parser->script, &val, ei, &num);
2042         VariantClear(&val);
2043     }
2044
2045     if(SUCCEEDED(hres)) {
2046         VARIANT dec;
2047         num_set_val(&dec, num_val(&num)-1.0);
2048         hres = put_value(ctx->parser->script, &exprval, &dec, ei);
2049     }
2050
2051     exprval_release(&exprval);
2052     if(FAILED(hres))
2053         return hres;
2054
2055     ret->type = EXPRVAL_VARIANT;
2056     ret->u.var = num;
2057     return S_OK;
2058 }
2059
2060 /* ECMA-262 3rd Edition    11.4.4 */
2061 HRESULT pre_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2062 {
2063     unary_expression_t *expr = (unary_expression_t*)_expr;
2064     VARIANT val, num;
2065     exprval_t exprval;
2066     HRESULT hres;
2067
2068     TRACE("\n");
2069
2070     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2071     if(FAILED(hres))
2072         return hres;
2073
2074     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2075     if(SUCCEEDED(hres)) {
2076         hres = to_number(ctx->parser->script, &val, ei, &num);
2077         VariantClear(&val);
2078     }
2079
2080     if(SUCCEEDED(hres)) {
2081         num_set_val(&val, num_val(&num)+1.0);
2082         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2083     }
2084
2085     exprval_release(&exprval);
2086     if(FAILED(hres))
2087         return hres;
2088
2089     ret->type = EXPRVAL_VARIANT;
2090     ret->u.var = val;
2091     return S_OK;
2092 }
2093
2094 /* ECMA-262 3rd Edition    11.4.5 */
2095 HRESULT pre_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2096 {
2097     unary_expression_t *expr = (unary_expression_t*)_expr;
2098     VARIANT val, num;
2099     exprval_t exprval;
2100     HRESULT hres;
2101
2102     TRACE("\n");
2103
2104     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2105     if(FAILED(hres))
2106         return hres;
2107
2108     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2109     if(SUCCEEDED(hres)) {
2110         hres = to_number(ctx->parser->script, &val, ei, &num);
2111         VariantClear(&val);
2112     }
2113
2114     if(SUCCEEDED(hres)) {
2115         num_set_val(&val, num_val(&num)-1.0);
2116         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2117     }
2118
2119     exprval_release(&exprval);
2120     if(FAILED(hres))
2121         return hres;
2122
2123     ret->type = EXPRVAL_VARIANT;
2124     ret->u.var = val;
2125     return S_OK;
2126 }
2127
2128 /* ECMA-262 3rd Edition    11.9.3 */
2129 static HRESULT equal_values(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2130 {
2131     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2132        return equal2_values(lval, rval, ret);
2133
2134     /* FIXME: NULL disps should be handled in more general way */
2135     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2136         VARIANT v;
2137         V_VT(&v) = VT_NULL;
2138         return equal_values(ctx, &v, rval, ei, ret);
2139     }
2140
2141     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2142         VARIANT v;
2143         V_VT(&v) = VT_NULL;
2144         return equal_values(ctx, lval, &v, ei, ret);
2145     }
2146
2147     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2148        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2149         *ret = TRUE;
2150         return S_OK;
2151     }
2152
2153     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2154         VARIANT v;
2155         HRESULT hres;
2156
2157         hres = to_number(ctx->parser->script, lval, ei, &v);
2158         if(FAILED(hres))
2159             return hres;
2160
2161         return equal_values(ctx, &v, rval, ei, ret);
2162     }
2163
2164     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2165         VARIANT v;
2166         HRESULT hres;
2167
2168         hres = to_number(ctx->parser->script, rval, ei, &v);
2169         if(FAILED(hres))
2170             return hres;
2171
2172         return equal_values(ctx, lval, &v, ei, ret);
2173     }
2174
2175     if(V_VT(rval) == VT_BOOL) {
2176         VARIANT v;
2177
2178         V_VT(&v) = VT_I4;
2179         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2180         return equal_values(ctx, lval, &v, ei, ret);
2181     }
2182
2183     if(V_VT(lval) == VT_BOOL) {
2184         VARIANT v;
2185
2186         V_VT(&v) = VT_I4;
2187         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2188         return equal_values(ctx, &v, rval, ei, ret);
2189     }
2190
2191
2192     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2193         VARIANT v;
2194         HRESULT hres;
2195
2196         hres = to_primitive(ctx->parser->script, rval, ei, &v);
2197         if(FAILED(hres))
2198             return hres;
2199
2200         hres = equal_values(ctx, lval, &v, ei, ret);
2201
2202         VariantClear(&v);
2203         return hres;
2204     }
2205
2206
2207     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2208         VARIANT v;
2209         HRESULT hres;
2210
2211         hres = to_primitive(ctx->parser->script, lval, ei, &v);
2212         if(FAILED(hres))
2213             return hres;
2214
2215         hres = equal_values(ctx, &v, rval, ei, ret);
2216
2217         VariantClear(&v);
2218         return hres;
2219     }
2220
2221
2222     *ret = FALSE;
2223     return S_OK;
2224 }
2225
2226 /* ECMA-262 3rd Edition    11.9.1 */
2227 HRESULT equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2228 {
2229     binary_expression_t *expr = (binary_expression_t*)_expr;
2230     VARIANT rval, lval;
2231     BOOL b;
2232     HRESULT hres;
2233
2234     TRACE("\n");
2235
2236     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2237     if(FAILED(hres))
2238         return hres;
2239
2240     hres = equal_values(ctx, &rval, &lval, ei, &b);
2241     if(FAILED(hres))
2242         return hres;
2243
2244     return return_bool(ret, b);
2245 }
2246
2247 /* ECMA-262 3rd Edition    11.9.4 */
2248 HRESULT equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2249 {
2250     binary_expression_t *expr = (binary_expression_t*)_expr;
2251     VARIANT rval, lval;
2252     BOOL b;
2253     HRESULT hres;
2254
2255     TRACE("\n");
2256
2257     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2258     if(FAILED(hres))
2259         return hres;
2260
2261     hres = equal2_values(&rval, &lval, &b);
2262     if(FAILED(hres))
2263         return hres;
2264
2265     return return_bool(ret, b);
2266 }
2267
2268 /* ECMA-262 3rd Edition    11.9.2 */
2269 HRESULT not_equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2270 {
2271     binary_expression_t *expr = (binary_expression_t*)_expr;
2272     VARIANT rval, lval;
2273     BOOL b;
2274     HRESULT hres;
2275
2276     TRACE("\n");
2277
2278     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2279     if(FAILED(hres))
2280         return hres;
2281
2282     hres = equal_values(ctx, &lval, &rval, ei, &b);
2283     if(FAILED(hres))
2284         return hres;
2285
2286     return return_bool(ret, !b);
2287 }
2288
2289 /* ECMA-262 3rd Edition    11.9.5 */
2290 HRESULT not_equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2291 {
2292     binary_expression_t *expr = (binary_expression_t*)_expr;
2293     VARIANT rval, lval;
2294     BOOL b;
2295     HRESULT hres;
2296
2297     TRACE("\n");
2298
2299     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2300     if(FAILED(hres))
2301         return hres;
2302
2303     hres = equal2_values(&rval, &lval, &b);
2304     if(FAILED(hres))
2305         return hres;
2306
2307     return return_bool(ret, !b);
2308 }
2309
2310 /* ECMA-262 3rd Edition    11.8.5 */
2311 static HRESULT less_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2312 {
2313     VARIANT l, r, ln, rn;
2314     HRESULT hres;
2315
2316     hres = to_primitive(ctx->parser->script, lval, ei, &l);
2317     if(FAILED(hres))
2318         return hres;
2319
2320     hres = to_primitive(ctx->parser->script, rval, ei, &r);
2321     if(FAILED(hres)) {
2322         VariantClear(&l);
2323         return hres;
2324     }
2325
2326     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2327         *ret = strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0;
2328         SysFreeString(V_BSTR(&l));
2329         SysFreeString(V_BSTR(&r));
2330         return S_OK;
2331     }
2332
2333     hres = to_number(ctx->parser->script, &l, ei, &ln);
2334     VariantClear(&l);
2335     if(SUCCEEDED(hres))
2336         hres = to_number(ctx->parser->script, &r, ei, &rn);
2337     VariantClear(&r);
2338     if(FAILED(hres))
2339         return hres;
2340
2341     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4)
2342         *ret = V_I4(&ln) < V_I4(&rn);
2343     else
2344         *ret = num_val(&ln) < num_val(&rn);
2345
2346     return S_OK;
2347 }
2348
2349 /* ECMA-262 3rd Edition    11.8.1 */
2350 HRESULT less_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2351 {
2352     binary_expression_t *expr = (binary_expression_t*)_expr;
2353     VARIANT rval, lval;
2354     BOOL b;
2355     HRESULT hres;
2356
2357     TRACE("\n");
2358
2359     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2360     if(FAILED(hres))
2361         return hres;
2362
2363     hres = less_eval(ctx, &lval, &rval, ei, &b);
2364     VariantClear(&lval);
2365     VariantClear(&rval);
2366     if(FAILED(hres))
2367         return hres;
2368
2369     return return_bool(ret, b);
2370 }
2371
2372 /* ECMA-262 3rd Edition    11.8.3 */
2373 HRESULT lesseq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2374 {
2375     binary_expression_t *expr = (binary_expression_t*)_expr;
2376     VARIANT rval, lval;
2377     BOOL b;
2378     HRESULT hres;
2379
2380     TRACE("\n");
2381
2382     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2383     if(FAILED(hres))
2384         return hres;
2385
2386     hres = less_eval(ctx, &rval, &lval, ei, &b);
2387     VariantClear(&lval);
2388     VariantClear(&rval);
2389     if(FAILED(hres))
2390         return hres;
2391
2392     return return_bool(ret, !b);
2393 }
2394
2395 /* ECMA-262 3rd Edition    11.8.2 */
2396 HRESULT greater_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, &lval, &rval);
2406     if(FAILED(hres))
2407         return hres;
2408
2409     hres = less_eval(ctx, &rval, &lval, ei, &b);
2410     VariantClear(&lval);
2411     VariantClear(&rval);
2412     if(FAILED(hres))
2413         return hres;
2414
2415     return return_bool(ret, b);
2416 }
2417
2418 /* ECMA-262 3rd Edition    11.8.4 */
2419 HRESULT greatereq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2420 {
2421     binary_expression_t *expr = (binary_expression_t*)_expr;
2422     VARIANT rval, lval;
2423     BOOL b;
2424     HRESULT hres;
2425
2426     TRACE("\n");
2427
2428     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2429     if(FAILED(hres))
2430         return hres;
2431
2432     hres = less_eval(ctx, &lval, &rval, ei, &b);
2433     VariantClear(&lval);
2434     VariantClear(&rval);
2435     if(FAILED(hres))
2436         return hres;
2437
2438     return return_bool(ret, !b);
2439 }
2440
2441 /* ECMA-262 3rd Edition    11.4.8 */
2442 HRESULT binary_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2443 {
2444     unary_expression_t *expr = (unary_expression_t*)_expr;
2445     exprval_t exprval;
2446     VARIANT val;
2447     INT i;
2448     HRESULT hres;
2449
2450     TRACE("\n");
2451
2452     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2453     if(FAILED(hres))
2454         return hres;
2455
2456     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2457     exprval_release(&exprval);
2458     if(FAILED(hres))
2459         return hres;
2460
2461     hres = to_int32(ctx->parser->script, &val, ei, &i);
2462     if(FAILED(hres))
2463         return hres;
2464
2465     ret->type = EXPRVAL_VARIANT;
2466     V_VT(&ret->u.var) = VT_I4;
2467     V_I4(&ret->u.var) = ~i;
2468     return S_OK;
2469 }
2470
2471 /* ECMA-262 3rd Edition    11.4.9 */
2472 HRESULT logical_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2473 {
2474     unary_expression_t *expr = (unary_expression_t*)_expr;
2475     exprval_t exprval;
2476     VARIANT_BOOL b;
2477     HRESULT hres;
2478
2479     TRACE("\n");
2480
2481     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2482     if(FAILED(hres))
2483         return hres;
2484
2485     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
2486     exprval_release(&exprval);
2487     if(FAILED(hres))
2488         return hres;
2489
2490     return return_bool(ret, !b);
2491 }
2492
2493 HRESULT left_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2494 {
2495     FIXME("\n");
2496     return E_NOTIMPL;
2497 }
2498
2499 HRESULT right_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2500 {
2501     FIXME("\n");
2502     return E_NOTIMPL;
2503 }
2504
2505 HRESULT right2_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2506 {
2507     FIXME("\n");
2508     return E_NOTIMPL;
2509 }
2510
2511 /* ECMA-262 3rd Edition    11.13.1 */
2512 HRESULT assign_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2513 {
2514     binary_expression_t *expr = (binary_expression_t*)_expr;
2515     exprval_t exprval, exprvalr;
2516     VARIANT rval;
2517     HRESULT hres;
2518
2519     TRACE("\n");
2520
2521     hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
2522     if(FAILED(hres))
2523         return hres;
2524
2525     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
2526     if(SUCCEEDED(hres)) {
2527         hres = exprval_to_value(ctx->parser->script, &exprvalr, ei, &rval);
2528         exprval_release(&exprvalr);
2529     }
2530
2531     if(SUCCEEDED(hres))
2532         hres = put_value(ctx->parser->script, &exprval, &rval, ei);
2533
2534     exprval_release(&exprval);
2535     if(FAILED(hres)) {
2536         VariantClear(&rval);
2537         return hres;
2538     }
2539
2540     ret->type = EXPRVAL_VARIANT;
2541     ret->u.var = rval;
2542     return S_OK;
2543 }
2544
2545 HRESULT assign_lshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2546 {
2547     FIXME("\n");
2548     return E_NOTIMPL;
2549 }
2550
2551 HRESULT assign_rshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2552 {
2553     FIXME("\n");
2554     return E_NOTIMPL;
2555 }
2556
2557 HRESULT assign_rrshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2558 {
2559     FIXME("\n");
2560     return E_NOTIMPL;
2561 }
2562
2563 /* ECMA-262 3rd Edition    11.13.2 */
2564 HRESULT assign_add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2565 {
2566     binary_expression_t *expr = (binary_expression_t*)_expr;
2567
2568     TRACE("\n");
2569
2570     return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
2571 }
2572
2573 /* ECMA-262 3rd Edition    11.13.2 */
2574 HRESULT assign_sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2575 {
2576     binary_expression_t *expr = (binary_expression_t*)_expr;
2577
2578     TRACE("\n");
2579
2580     return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
2581 }
2582
2583 /* ECMA-262 3rd Edition    11.13.2 */
2584 HRESULT assign_mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2585 {
2586     binary_expression_t *expr = (binary_expression_t*)_expr;
2587
2588     TRACE("\n");
2589
2590     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
2591 }
2592
2593 /* ECMA-262 3rd Edition    11.13.2 */
2594 HRESULT assign_div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2595 {
2596     binary_expression_t *expr = (binary_expression_t*)_expr;
2597
2598     TRACE("\n");
2599
2600     return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
2601 }
2602
2603 HRESULT assign_mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2604 {
2605     FIXME("\n");
2606     return E_NOTIMPL;
2607 }
2608
2609 /* ECMA-262 3rd Edition    11.13.2 */
2610 HRESULT assign_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2611 {
2612     binary_expression_t *expr = (binary_expression_t*)_expr;
2613
2614     TRACE("\n");
2615
2616     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
2617 }
2618
2619 /* ECMA-262 3rd Edition    11.13.2 */
2620 HRESULT assign_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2621 {
2622     binary_expression_t *expr = (binary_expression_t*)_expr;
2623
2624     TRACE("\n");
2625
2626     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
2627 }
2628
2629 /* ECMA-262 3rd Edition    11.13.2 */
2630 HRESULT assign_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2631 {
2632     binary_expression_t *expr = (binary_expression_t*)_expr;
2633
2634     TRACE("\n");
2635
2636     return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
2637 }