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