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