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