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