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