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