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