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

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