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