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

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