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