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

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