git.oblomov.eu Git - wine/blob - dlls/jscript/engine.c

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