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 "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         return hres;
 956
 957     hres = stat_eval(ctx, stat->statement, rt, ret);
 958
 959     scope_pop(&ctx->scope_chain);
 960     return hres;
 961 }
 962
 963 /* ECMA-262 3rd Edition    12.12 */
 964 HRESULT labelled_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 965 {
 966     FIXME("\n");
 967     return E_NOTIMPL;
 968 }
 969
 970 /* ECMA-262 3rd Edition    12.13 */
 971 HRESULT switch_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 972 {
 973     switch_statement_t *stat = (switch_statement_t*)_stat;
 974     case_clausule_t *iter, *default_clausule = NULL;
 975     statement_t *stat_iter;
 976     VARIANT val, cval;
 977     exprval_t exprval;
 978     BOOL b;
 979     HRESULT hres;
 980
 981     TRACE("\n");
 982
 983     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 984     if(FAILED(hres))
 985         return hres;
 986
 987     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 988     exprval_release(&exprval);
 989     if(FAILED(hres))
 990         return hres;
 991
 992     for(iter = stat->case_list; iter; iter = iter->next) {
 993         if(!iter->expr) {
 994             default_clausule = iter;
 995             continue;
 996         }
 997
 998         hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
 999         if(FAILED(hres))
1000             break;
1001
1002         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &cval);
1003         exprval_release(&exprval);
1004         if(FAILED(hres))
1005             break;
1006
1007         hres = equal2_values(&val, &cval, &b);
1008         VariantClear(&cval);
1009         if(FAILED(hres) || b)
1010             break;
1011     }
1012
1013     VariantClear(&val);
1014     if(FAILED(hres))
1015         return hres;
1016
1017     if(!iter)
1018         iter = default_clausule;
1019
1020     V_VT(&val) = VT_EMPTY;
1021     if(iter) {
1022         VARIANT tmp;
1023
1024         for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1025             hres = stat_eval(ctx, stat_iter, rt, &tmp);
1026             if(FAILED(hres))
1027                 break;
1028
1029             VariantClear(&val);
1030             val = tmp;
1031
1032             if(rt->type != RT_NORMAL)
1033                 break;
1034         }
1035     }
1036
1037     if(FAILED(hres)) {
1038         VariantClear(&val);
1039         return hres;
1040     }
1041
1042     if(rt->type == RT_BREAK)
1043         rt->type = RT_NORMAL;
1044
1045     *ret = val;
1046     return S_OK;
1047 }
1048
1049 /* ECMA-262 3rd Edition    12.13 */
1050 HRESULT throw_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1051 {
1052     expression_statement_t *stat = (expression_statement_t*)_stat;
1053     exprval_t exprval;
1054     VARIANT val;
1055     HRESULT hres;
1056
1057     TRACE("\n");
1058
1059     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
1060     if(FAILED(hres))
1061         return hres;
1062
1063     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
1064     exprval_release(&exprval);
1065     if(FAILED(hres))
1066         return hres;
1067
1068     rt->ei.var = val;
1069     return DISP_E_EXCEPTION;
1070 }
1071
1072 /* ECMA-262 3rd Edition    12.14 */
1073 static HRESULT catch_eval(exec_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1074 {
1075     DispatchEx *var_disp;
1076     VARIANT ex, val;
1077     HRESULT hres;
1078
1079     ex = rt->ei.var;
1080     memset(&rt->ei, 0, sizeof(jsexcept_t));
1081
1082     hres = create_dispex(ctx->parser->script, NULL, NULL, &var_disp);
1083     if(SUCCEEDED(hres)) {
1084         hres = jsdisp_propput_name(var_disp, block->identifier, ctx->parser->script->lcid,
1085                 &ex, &rt->ei, NULL/*FIXME*/);
1086         if(SUCCEEDED(hres)) {
1087             hres = scope_push(ctx->scope_chain, var_disp, &ctx->scope_chain);
1088             if(SUCCEEDED(hres)) {
1089                 hres = stat_eval(ctx, block->statement, rt, &val);
1090                 scope_pop(&ctx->scope_chain);
1091             }
1092         }
1093
1094         jsdisp_release(var_disp);
1095     }
1096
1097     VariantClear(&ex);
1098     if(FAILED(hres))
1099         return hres;
1100
1101     *ret = val;
1102     return S_OK;
1103 }
1104
1105 /* ECMA-262 3rd Edition    12.14 */
1106 HRESULT try_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1107 {
1108     try_statement_t *stat = (try_statement_t*)_stat;
1109     VARIANT val;
1110     HRESULT hres;
1111
1112     TRACE("\n");
1113
1114     hres = stat_eval(ctx, stat->try_statement, rt, &val);
1115     if(FAILED(hres)) {
1116         TRACE("EXCEPTION\n");
1117         if(!stat->catch_block)
1118             return hres;
1119
1120         hres = catch_eval(ctx, stat->catch_block, rt, &val);
1121         if(FAILED(hres))
1122             return hres;
1123     }
1124
1125     if(stat->finally_statement) {
1126         VariantClear(&val);
1127         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1128         if(FAILED(hres))
1129             return hres;
1130     }
1131
1132     *ret = val;
1133     return S_OK;
1134 }
1135
1136 static HRESULT return_bool(exprval_t *ret, DWORD b)
1137 {
1138     ret->type = EXPRVAL_VARIANT;
1139     V_VT(&ret->u.var) = VT_BOOL;
1140     V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
1141
1142     return S_OK;
1143 }
1144
1145 static HRESULT get_binary_expr_values(exec_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
1146 {
1147     exprval_t exprval;
1148     HRESULT hres;
1149
1150     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1151     if(FAILED(hres))
1152         return hres;
1153
1154     hres = exprval_to_value(ctx->parser->script, &exprval, ei, lval);
1155     exprval_release(&exprval);
1156     if(FAILED(hres))
1157         return hres;
1158
1159     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1160     if(SUCCEEDED(hres)) {
1161         hres = exprval_to_value(ctx->parser->script, &exprval, ei, rval);
1162         exprval_release(&exprval);
1163     }
1164
1165     if(FAILED(hres)) {
1166         VariantClear(lval);
1167         return hres;
1168     }
1169
1170     return S_OK;
1171 }
1172
1173 typedef HRESULT (*oper_t)(exec_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
1174
1175 static HRESULT binary_expr_eval(exec_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
1176         exprval_t *ret)
1177 {
1178     VARIANT lval, rval, retv;
1179     HRESULT hres;
1180
1181     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1182     if(FAILED(hres))
1183         return hres;
1184
1185     hres = oper(ctx, &lval, &rval, ei, &retv);
1186     VariantClear(&lval);
1187     VariantClear(&rval);
1188     if(FAILED(hres))
1189         return hres;
1190
1191     ret->type = EXPRVAL_VARIANT;
1192     ret->u.var = retv;
1193     return S_OK;
1194 }
1195
1196 /* ECMA-262 3rd Edition    11.13.2 */
1197 static HRESULT assign_oper_eval(exec_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
1198                                 jsexcept_t *ei, exprval_t *ret)
1199 {
1200     VARIANT retv, lval, rval;
1201     exprval_t exprval, exprvalr;
1202     HRESULT hres;
1203
1204     hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
1205     if(FAILED(hres))
1206         return hres;
1207
1208     hres = exprval_value(ctx->parser->script, &exprval, ei, &lval);
1209     if(SUCCEEDED(hres)) {
1210         hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
1211         if(SUCCEEDED(hres)) {
1212             hres = exprval_value(ctx->parser->script, &exprvalr, ei, &rval);
1213             exprval_release(&exprvalr);
1214         }
1215         if(SUCCEEDED(hres)) {
1216             hres = oper(ctx, &lval, &rval, ei, &retv);
1217             VariantClear(&rval);
1218         }
1219         VariantClear(&lval);
1220     }
1221
1222     if(SUCCEEDED(hres)) {
1223         hres = put_value(ctx->parser->script, &exprval, &retv, ei);
1224         if(FAILED(hres))
1225             VariantClear(&retv);
1226     }
1227     exprval_release(&exprval);
1228
1229     if(FAILED(hres))
1230         return hres;
1231
1232     ret->type = EXPRVAL_VARIANT;
1233     ret->u.var = retv;
1234     return S_OK;
1235 }
1236
1237 /* ECMA-262 3rd Edition    13 */
1238 HRESULT function_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1239 {
1240     function_expression_t *expr = (function_expression_t*)_expr;
1241     DispatchEx *dispex;
1242     VARIANT var;
1243     HRESULT hres;
1244
1245     TRACE("\n");
1246
1247     hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain,
1248             expr->src_str, expr->src_len, &dispex);
1249     if(FAILED(hres))
1250         return hres;
1251
1252     V_VT(&var) = VT_DISPATCH;
1253     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
1254
1255     if(expr->identifier) {
1256         hres = jsdisp_propput_name(ctx->var_disp, expr->identifier, ctx->parser->script->lcid, &var, ei, NULL/*FIXME*/);
1257         if(FAILED(hres)) {
1258             jsdisp_release(dispex);
1259             return hres;
1260         }
1261     }
1262
1263     ret->type = EXPRVAL_VARIANT;
1264     ret->u.var = var;
1265     return S_OK;
1266 }
1267
1268 /* ECMA-262 3rd Edition    11.12 */
1269 HRESULT conditional_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1270 {
1271     conditional_expression_t *expr = (conditional_expression_t*)_expr;
1272     exprval_t exprval;
1273     VARIANT_BOOL b;
1274     HRESULT hres;
1275
1276     TRACE("\n");
1277
1278     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1279     if(FAILED(hres))
1280         return hres;
1281
1282     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
1283     exprval_release(&exprval);
1284     if(FAILED(hres))
1285         return hres;
1286
1287     return expr_eval(ctx, b ? expr->true_expression : expr->false_expression, flags, ei, ret);
1288 }
1289
1290 /* ECMA-262 3rd Edition    11.2.1 */
1291 HRESULT array_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1292 {
1293     array_expression_t *expr = (array_expression_t*)_expr;
1294     exprval_t exprval;
1295     VARIANT member, val;
1296     DISPID id;
1297     BSTR str;
1298     IDispatch *obj = NULL;
1299     HRESULT hres;
1300
1301     TRACE("\n");
1302
1303     hres = expr_eval(ctx, expr->member_expr, EXPR_NEWREF, ei, &exprval);
1304     if(FAILED(hres))
1305         return hres;
1306
1307     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1308     exprval_release(&exprval);
1309     if(FAILED(hres))
1310         return hres;
1311
1312     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1313     if(SUCCEEDED(hres)) {
1314         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1315         exprval_release(&exprval);
1316     }
1317
1318     if(SUCCEEDED(hres))
1319         hres = to_object(ctx, &member, &obj);
1320     VariantClear(&member);
1321     if(SUCCEEDED(hres)) {
1322         hres = to_string(ctx->parser->script, &val, ei, &str);
1323         if(SUCCEEDED(hres)) {
1324             if(flags & EXPR_STRREF) {
1325                 ret->type = EXPRVAL_NAMEREF;
1326                 ret->u.nameref.disp = obj;
1327                 ret->u.nameref.name = str;
1328                 return S_OK;
1329             }
1330
1331             hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1332         }
1333
1334         if(SUCCEEDED(hres)) {
1335             exprval_set_idref(ret, obj, id);
1336         }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1337             exprval_init(ret);
1338             hres = S_OK;
1339         }
1340
1341         IDispatch_Release(obj);
1342     }
1343
1344     return hres;
1345 }
1346
1347 /* ECMA-262 3rd Edition    11.2.1 */
1348 HRESULT member_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1349 {
1350     member_expression_t *expr = (member_expression_t*)_expr;
1351     IDispatch *obj = NULL;
1352     exprval_t exprval;
1353     VARIANT member;
1354     DISPID id;
1355     BSTR str;
1356     HRESULT hres;
1357
1358     TRACE("\n");
1359
1360     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1361     if(FAILED(hres))
1362         return hres;
1363
1364     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1365     exprval_release(&exprval);
1366     if(FAILED(hres))
1367         return hres;
1368
1369     hres = to_object(ctx, &member, &obj);
1370     VariantClear(&member);
1371     if(FAILED(hres))
1372         return hres;
1373
1374     str = SysAllocString(expr->identifier);
1375     if(flags & EXPR_STRREF) {
1376         ret->type = EXPRVAL_NAMEREF;
1377         ret->u.nameref.disp = obj;
1378         ret->u.nameref.name = str;
1379         return S_OK;
1380     }
1381
1382     hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1383     SysFreeString(str);
1384     if(SUCCEEDED(hres)) {
1385         exprval_set_idref(ret, obj, id);
1386     }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1387         exprval_init(ret);
1388         hres = S_OK;
1389     }
1390
1391     IDispatch_Release(obj);
1392     return hres;
1393 }
1394
1395 static void free_dp(DISPPARAMS *dp)
1396 {
1397     DWORD i;
1398
1399     for(i=0; i < dp->cArgs; i++)
1400         VariantClear(dp->rgvarg+i);
1401     heap_free(dp->rgvarg);
1402 }
1403
1404 static HRESULT args_to_param(exec_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1405 {
1406     VARIANTARG *vargs;
1407     exprval_t exprval;
1408     argument_t *iter;
1409     DWORD cnt = 0, i;
1410     HRESULT hres = S_OK;
1411
1412     memset(dp, 0, sizeof(*dp));
1413     if(!args)
1414         return S_OK;
1415
1416     for(iter = args; iter; iter = iter->next)
1417         cnt++;
1418
1419     vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1420     if(!vargs)
1421         return E_OUTOFMEMORY;
1422
1423     for(i = cnt, iter = args; iter; iter = iter->next) {
1424         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1425         if(FAILED(hres))
1426             break;
1427
1428         hres = exprval_to_value(ctx->parser->script, &exprval, ei, vargs + (--i));
1429         exprval_release(&exprval);
1430         if(FAILED(hres))
1431             break;
1432     }
1433
1434     if(FAILED(hres)) {
1435         free_dp(dp);
1436         return hres;
1437     }
1438
1439     dp->rgvarg = vargs;
1440     dp->cArgs = cnt;
1441     return S_OK;
1442 }
1443
1444 /* ECMA-262 3rd Edition    11.2.2 */
1445 HRESULT new_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1446 {
1447     call_expression_t *expr = (call_expression_t*)_expr;
1448     exprval_t exprval;
1449     VARIANT constr, var;
1450     DISPPARAMS dp;
1451     HRESULT hres;
1452
1453     TRACE("\n");
1454
1455     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1456     if(FAILED(hres))
1457         return hres;
1458
1459     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1460     if(SUCCEEDED(hres))
1461         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &constr);
1462     exprval_release(&exprval);
1463     if(FAILED(hres))
1464         return hres;
1465
1466     if(V_VT(&constr) != VT_DISPATCH) {
1467         FIXME("throw TypeError\n");
1468         VariantClear(&constr);
1469         return E_FAIL;
1470     }
1471
1472     hres = disp_call(V_DISPATCH(&constr), DISPID_VALUE, ctx->parser->script->lcid,
1473                      DISPATCH_CONSTRUCT, &dp, &var, ei, NULL/*FIXME*/);
1474     IDispatch_Release(V_DISPATCH(&constr));
1475     if(FAILED(hres))
1476         return hres;
1477
1478     ret->type = EXPRVAL_VARIANT;
1479     ret->u.var = var;
1480     return S_OK;
1481 }
1482
1483 /* ECMA-262 3rd Edition    11.2.3 */
1484 HRESULT call_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     VARIANT func, var;
1488     exprval_t exprval;
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         switch(exprval.type) {
1501         case EXPRVAL_IDREF:
1502             hres = disp_call(exprval.u.idref.disp, exprval.u.idref.id, ctx->parser->script->lcid, DISPATCH_METHOD,
1503                     &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1504             if(flags & EXPR_NOVAL)
1505                 V_VT(&var) = VT_EMPTY;
1506             break;
1507         default:
1508             FIXME("unimplemented type %d\n", V_VT(&func));
1509             hres = E_NOTIMPL;
1510         }
1511
1512         free_dp(&dp);
1513     }
1514
1515     exprval_release(&exprval);
1516     if(FAILED(hres))
1517         return hres;
1518
1519     TRACE("= %s\n", debugstr_variant(&var));
1520     ret->type = EXPRVAL_VARIANT;
1521     ret->u.var = var;
1522     return S_OK;
1523 }
1524
1525 /* ECMA-262 3rd Edition    11.1.1 */
1526 HRESULT this_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1527 {
1528     TRACE("\n");
1529
1530     ret->type = EXPRVAL_VARIANT;
1531     V_VT(&ret->u.var) = VT_DISPATCH;
1532     V_DISPATCH(&ret->u.var) = ctx->this_obj;
1533     IDispatch_AddRef(ctx->this_obj);
1534     return S_OK;
1535 }
1536
1537 /* ECMA-262 3rd Edition    10.1.4 */
1538 HRESULT identifier_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1539 {
1540     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1541     BSTR identifier;
1542     HRESULT hres;
1543
1544     TRACE("\n");
1545
1546     identifier = SysAllocString(expr->identifier);
1547     if(!identifier)
1548         return E_OUTOFMEMORY;
1549
1550     hres = identifier_eval(ctx, identifier, flags, ret);
1551
1552     SysFreeString(identifier);
1553     return hres;
1554 }
1555
1556 /* ECMA-262 3rd Edition    7.8 */
1557 HRESULT literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1558 {
1559     literal_expression_t *expr = (literal_expression_t*)_expr;
1560     VARIANT var;
1561     HRESULT hres;
1562
1563     TRACE("\n");
1564
1565     hres = literal_to_var(expr->literal, &var);
1566     if(FAILED(hres))
1567         return hres;
1568
1569     ret->type = EXPRVAL_VARIANT;
1570     ret->u.var = var;
1571     return S_OK;
1572 }
1573
1574 /* ECMA-262 3rd Edition    11.1.4 */
1575 HRESULT array_literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1576 {
1577     array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
1578     DWORD length = 0, i = 0;
1579     array_element_t *elem;
1580     DispatchEx *array;
1581     exprval_t exprval;
1582     VARIANT val;
1583     HRESULT hres;
1584
1585     TRACE("\n");
1586
1587     for(elem = expr->element_list; elem; elem = elem->next)
1588         length += elem->elision+1;
1589     length += expr->length;
1590
1591     hres = create_array(ctx->parser->script, length, &array);
1592     if(FAILED(hres))
1593         return hres;
1594
1595     for(elem = expr->element_list; elem; elem = elem->next) {
1596         i += elem->elision;
1597
1598         hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
1599         if(FAILED(hres))
1600             break;
1601
1602         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1603         exprval_release(&exprval);
1604         if(FAILED(hres))
1605             break;
1606
1607         hres = jsdisp_propput_idx(array, i, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1608         VariantClear(&val);
1609         if(FAILED(hres))
1610             break;
1611
1612         i++;
1613     }
1614
1615     if(FAILED(hres)) {
1616         jsdisp_release(array);
1617         return hres;
1618     }
1619
1620     ret->type = EXPRVAL_VARIANT;
1621     V_VT(&ret->u.var) = VT_DISPATCH;
1622     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(array);
1623     return S_OK;
1624 }
1625
1626 /* ECMA-262 3rd Edition    11.1.5 */
1627 HRESULT property_value_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1628 {
1629     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1630     VARIANT val, tmp;
1631     DispatchEx *obj;
1632     prop_val_t *iter;
1633     exprval_t exprval;
1634     BSTR name;
1635     HRESULT hres;
1636
1637     TRACE("\n");
1638
1639     hres = create_object(ctx->parser->script, NULL, &obj);
1640     if(FAILED(hres))
1641         return hres;
1642
1643     for(iter = expr->property_list; iter; iter = iter->next) {
1644         hres = literal_to_var(iter->name, &tmp);
1645         if(FAILED(hres))
1646             break;
1647
1648         hres = to_string(ctx->parser->script, &tmp, ei, &name);
1649         VariantClear(&tmp);
1650         if(FAILED(hres))
1651             break;
1652
1653         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1654         if(SUCCEEDED(hres)) {
1655             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1656             exprval_release(&exprval);
1657             if(SUCCEEDED(hres)) {
1658                 hres = jsdisp_propput_name(obj, name, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1659                 VariantClear(&val);
1660             }
1661         }
1662
1663         SysFreeString(name);
1664         if(FAILED(hres))
1665             break;
1666     }
1667
1668     if(FAILED(hres)) {
1669         jsdisp_release(obj);
1670         return hres;
1671     }
1672
1673     ret->type = EXPRVAL_VARIANT;
1674     V_VT(&ret->u.var) = VT_DISPATCH;
1675     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(obj);
1676     return S_OK;
1677 }
1678
1679 /* ECMA-262 3rd Edition    11.14 */
1680 HRESULT comma_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1681 {
1682     binary_expression_t *expr = (binary_expression_t*)_expr;
1683     VARIANT lval, rval;
1684     HRESULT hres;
1685
1686     TRACE("\n");
1687
1688     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1689     if(FAILED(hres))
1690         return hres;
1691
1692     VariantClear(&lval);
1693
1694     ret->type = EXPRVAL_VARIANT;
1695     ret->u.var = rval;
1696     return S_OK;
1697 }
1698
1699 /* ECMA-262 3rd Edition    11.11 */
1700 HRESULT logical_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1701 {
1702     binary_expression_t *expr = (binary_expression_t*)_expr;
1703     exprval_t exprval;
1704     VARIANT_BOOL b;
1705     VARIANT val;
1706     HRESULT hres;
1707
1708     TRACE("\n");
1709
1710     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1711     if(FAILED(hres))
1712         return hres;
1713
1714     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1715     exprval_release(&exprval);
1716     if(FAILED(hres))
1717         return hres;
1718
1719     hres = to_boolean(&val, &b);
1720     if(SUCCEEDED(hres) && b) {
1721         ret->type = EXPRVAL_VARIANT;
1722         ret->u.var = val;
1723         return S_OK;
1724     }
1725
1726     VariantClear(&val);
1727     if(FAILED(hres))
1728         return hres;
1729
1730     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1731     if(FAILED(hres))
1732         return hres;
1733
1734     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1735     exprval_release(&exprval);
1736     if(FAILED(hres))
1737         return hres;
1738
1739     ret->type = EXPRVAL_VARIANT;
1740     ret->u.var = val;
1741     return S_OK;
1742 }
1743
1744 /* ECMA-262 3rd Edition    11.11 */
1745 HRESULT logical_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1746 {
1747     binary_expression_t *expr = (binary_expression_t*)_expr;
1748     exprval_t exprval;
1749     VARIANT_BOOL b;
1750     VARIANT val;
1751     HRESULT hres;
1752
1753     TRACE("\n");
1754
1755     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1756     if(FAILED(hres))
1757         return hres;
1758
1759     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1760     exprval_release(&exprval);
1761     if(FAILED(hres))
1762         return hres;
1763
1764     hres = to_boolean(&val, &b);
1765     if(SUCCEEDED(hres) && !b) {
1766         ret->type = EXPRVAL_VARIANT;
1767         ret->u.var = val;
1768         return S_OK;
1769     }
1770
1771     VariantClear(&val);
1772     if(FAILED(hres))
1773         return hres;
1774
1775     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1776     if(FAILED(hres))
1777         return hres;
1778
1779     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1780     exprval_release(&exprval);
1781     if(FAILED(hres))
1782         return hres;
1783
1784     ret->type = EXPRVAL_VARIANT;
1785     ret->u.var = val;
1786     return S_OK;
1787 }
1788
1789 /* ECMA-262 3rd Edition    11.10 */
1790 static HRESULT bitor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1791 {
1792     INT li, ri;
1793     HRESULT hres;
1794
1795     hres = to_int32(ctx->parser->script, lval, ei, &li);
1796     if(FAILED(hres))
1797         return hres;
1798
1799     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1800     if(FAILED(hres))
1801         return hres;
1802
1803     V_VT(retv) = VT_I4;
1804     V_I4(retv) = li|ri;
1805     return S_OK;
1806 }
1807
1808 /* ECMA-262 3rd Edition    11.10 */
1809 HRESULT binary_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1810 {
1811     binary_expression_t *expr = (binary_expression_t*)_expr;
1812
1813     TRACE("\n");
1814
1815     return binary_expr_eval(ctx, expr, bitor_eval, ei, ret);
1816 }
1817
1818 /* ECMA-262 3rd Edition    11.10 */
1819 static HRESULT xor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1820 {
1821     INT li, ri;
1822     HRESULT hres;
1823
1824     hres = to_int32(ctx->parser->script, lval, ei, &li);
1825     if(FAILED(hres))
1826         return hres;
1827
1828     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1829     if(FAILED(hres))
1830         return hres;
1831
1832     V_VT(retv) = VT_I4;
1833     V_I4(retv) = li^ri;
1834     return S_OK;
1835 }
1836
1837 /* ECMA-262 3rd Edition    11.10 */
1838 HRESULT binary_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1839 {
1840     binary_expression_t *expr = (binary_expression_t*)_expr;
1841
1842     TRACE("\n");
1843
1844     return binary_expr_eval(ctx, expr, xor_eval, ei, ret);
1845 }
1846
1847 /* ECMA-262 3rd Edition    11.10 */
1848 static HRESULT bitand_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1849 {
1850     INT li, ri;
1851     HRESULT hres;
1852
1853     hres = to_int32(ctx->parser->script, lval, ei, &li);
1854     if(FAILED(hres))
1855         return hres;
1856
1857     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1858     if(FAILED(hres))
1859         return hres;
1860
1861     V_VT(retv) = VT_I4;
1862     V_I4(retv) = li&ri;
1863     return S_OK;
1864 }
1865
1866 /* ECMA-262 3rd Edition    11.10 */
1867 HRESULT binary_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1868 {
1869     binary_expression_t *expr = (binary_expression_t*)_expr;
1870
1871     TRACE("\n");
1872
1873     return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
1874 }
1875
1876 /* ECMA-262 3rd Edition    11.8.6 */
1877 HRESULT instanceof_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1878 {
1879     FIXME("\n");
1880     return E_NOTIMPL;
1881 }
1882
1883 /* ECMA-262 3rd Edition    11.8.7 */
1884 HRESULT in_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1885 {
1886     FIXME("\n");
1887     return E_NOTIMPL;
1888 }
1889
1890 /* ECMA-262 3rd Edition    11.6.1 */
1891 static HRESULT add_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1892 {
1893     VARIANT r, l;
1894     HRESULT hres;
1895
1896     hres = to_primitive(ctx->parser->script, lval, ei, &l);
1897     if(FAILED(hres))
1898         return hres;
1899
1900     hres = to_primitive(ctx->parser->script, rval, ei, &r);
1901     if(FAILED(hres)) {
1902         VariantClear(&l);
1903         return hres;
1904     }
1905
1906     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1907         BSTR lstr = NULL, rstr = NULL;
1908
1909         if(V_VT(&l) == VT_BSTR)
1910             lstr = V_BSTR(&l);
1911         else
1912             hres = to_string(ctx->parser->script, &l, ei, &lstr);
1913
1914         if(SUCCEEDED(hres)) {
1915             if(V_VT(&r) == VT_BSTR)
1916                 rstr = V_BSTR(&r);
1917             else
1918                 hres = to_string(ctx->parser->script, &r, ei, &rstr);
1919         }
1920
1921         if(SUCCEEDED(hres)) {
1922             int len1, len2;
1923
1924             len1 = SysStringLen(lstr);
1925             len2 = SysStringLen(rstr);
1926
1927             V_VT(retv) = VT_BSTR;
1928             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1929             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1930             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
1931         }
1932
1933         if(lstr && V_VT(&l) != VT_BSTR)
1934             SysFreeString(lstr);
1935         if(rstr && V_VT(&r) != VT_BSTR)
1936             SysFreeString(rstr);
1937     }else {
1938         VARIANT nl, nr;
1939
1940         hres = to_number(ctx->parser->script, &l, ei, &nl);
1941         if(SUCCEEDED(hres)) {
1942             hres = to_number(ctx->parser->script, &r, ei, &nr);
1943             if(SUCCEEDED(hres))
1944                 num_set_val(retv, num_val(&nl) + num_val(&nr));
1945         }
1946     }
1947
1948     VariantClear(&r);
1949     VariantClear(&l);
1950     return hres;
1951 }
1952
1953 /* ECMA-262 3rd Edition    11.6.1 */
1954 HRESULT add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1955 {
1956     binary_expression_t *expr = (binary_expression_t*)_expr;
1957
1958     TRACE("\n");
1959
1960     return binary_expr_eval(ctx, expr, add_eval, ei, ret);
1961 }
1962
1963 /* ECMA-262 3rd Edition    11.6.2 */
1964 static HRESULT sub_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1965 {
1966     VARIANT lnum, rnum;
1967     HRESULT hres;
1968
1969     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1970     if(FAILED(hres))
1971         return hres;
1972
1973     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1974     if(FAILED(hres))
1975         return hres;
1976
1977     num_set_val(retv, num_val(&lnum) - num_val(&rnum));
1978     return S_OK;
1979 }
1980
1981 /* ECMA-262 3rd Edition    11.6.2 */
1982 HRESULT sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1983 {
1984     binary_expression_t *expr = (binary_expression_t*)_expr;
1985
1986     TRACE("\n");
1987
1988     return binary_expr_eval(ctx, expr, sub_eval, ei, ret);
1989 }
1990
1991 /* ECMA-262 3rd Edition    11.5.1 */
1992 static HRESULT mul_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1993 {
1994     VARIANT lnum, rnum;
1995     HRESULT hres;
1996
1997     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1998     if(FAILED(hres))
1999         return hres;
2000
2001     hres = to_number(ctx->parser->script, rval, ei, &rnum);
2002     if(FAILED(hres))
2003         return hres;
2004
2005     num_set_val(retv, num_val(&lnum) * num_val(&rnum));
2006     return S_OK;
2007 }
2008
2009 /* ECMA-262 3rd Edition    11.5.1 */
2010 HRESULT mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2011 {
2012     binary_expression_t *expr = (binary_expression_t*)_expr;
2013
2014     TRACE("\n");
2015
2016     return binary_expr_eval(ctx, expr, mul_eval, ei, ret);
2017 }
2018
2019 /* ECMA-262 3rd Edition    11.5.2 */
2020 static HRESULT div_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2021 {
2022     VARIANT lnum, rnum;
2023     HRESULT hres;
2024
2025     hres = to_number(ctx->parser->script, lval, ei, &lnum);
2026     if(FAILED(hres))
2027         return hres;
2028
2029     hres = to_number(ctx->parser->script, rval, ei, &rnum);
2030     if(FAILED(hres))
2031         return hres;
2032
2033     num_set_val(retv, num_val(&lnum) / num_val(&rnum));
2034     return S_OK;
2035 }
2036
2037 /* ECMA-262 3rd Edition    11.5.2 */
2038 HRESULT div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2039 {
2040     binary_expression_t *expr = (binary_expression_t*)_expr;
2041
2042     TRACE("\n");
2043
2044     return binary_expr_eval(ctx, expr, div_eval, ei, ret);
2045 }
2046
2047 /* ECMA-262 3rd Edition    11.5.3 */
2048 HRESULT mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2049 {
2050     FIXME("\n");
2051     return E_NOTIMPL;
2052 }
2053
2054 /* ECMA-262 3rd Edition    11.4.2 */
2055 HRESULT delete_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2056 {
2057     unary_expression_t *expr = (unary_expression_t*)_expr;
2058     VARIANT_BOOL b = VARIANT_FALSE;
2059     exprval_t exprval;
2060     HRESULT hres;
2061
2062     TRACE("\n");
2063
2064     hres = expr_eval(ctx, expr->expression, EXPR_STRREF, ei, &exprval);
2065     if(FAILED(hres))
2066         return hres;
2067
2068     switch(exprval.type) {
2069     case EXPRVAL_NAMEREF: {
2070         IDispatchEx *dispex;
2071
2072         hres = IDispatch_QueryInterface(exprval.u.nameref.disp, &IID_IDispatchEx, (void**)&dispex);
2073         if(SUCCEEDED(hres)) {
2074             hres = IDispatchEx_DeleteMemberByName(dispex, exprval.u.nameref.name, fdexNameCaseSensitive);
2075             b = VARIANT_TRUE;
2076             IDispatchEx_Release(dispex);
2077         }
2078         break;
2079     }
2080     default:
2081         FIXME("unsupported type %d\n", exprval.type);
2082         hres = E_NOTIMPL;
2083     }
2084
2085     exprval_release(&exprval);
2086     if(FAILED(hres))
2087         return hres;
2088
2089     return return_bool(ret, b);
2090 }
2091
2092 /* ECMA-262 3rd Edition    11.4.2 */
2093 HRESULT void_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2094 {
2095     unary_expression_t *expr = (unary_expression_t*)_expr;
2096     exprval_t exprval;
2097     VARIANT tmp;
2098     HRESULT hres;
2099
2100     TRACE("\n");
2101
2102     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2103     if(FAILED(hres))
2104         return hres;
2105
2106     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &tmp);
2107     exprval_release(&exprval);
2108     if(FAILED(hres))
2109         return hres;
2110
2111     VariantClear(&tmp);
2112
2113     ret->type = EXPRVAL_VARIANT;
2114     V_VT(&ret->u.var) = VT_EMPTY;
2115     return S_OK;
2116 }
2117
2118 /* ECMA-262 3rd Edition    11.4.3 */
2119 HRESULT typeof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2120 {
2121     unary_expression_t *expr = (unary_expression_t*)_expr;
2122     const WCHAR *str;
2123     exprval_t exprval;
2124     VARIANT val;
2125     HRESULT hres;
2126
2127     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2128     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2129     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2130     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2131     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2132     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2133
2134     TRACE("\n");
2135
2136     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2137     if(FAILED(hres))
2138         return hres;
2139
2140     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2141     exprval_release(&exprval);
2142     if(FAILED(hres))
2143         return hres;
2144
2145     switch(V_VT(&val)) {
2146     case VT_EMPTY:
2147         str = undefinedW;
2148         break;
2149     case VT_NULL:
2150         str = objectW;
2151         break;
2152     case VT_BOOL:
2153         str = booleanW;
2154         break;
2155     case VT_I4:
2156     case VT_R8:
2157         str = numberW;
2158         break;
2159     case VT_BSTR:
2160         str = stringW;
2161         break;
2162     case VT_DISPATCH: {
2163         DispatchEx *dispex;
2164
2165         dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val));
2166         if(dispex) {
2167             str = dispex->builtin_info->class == JSCLASS_FUNCTION ? functionW : objectW;
2168             IDispatchEx_Release(_IDispatchEx_(dispex));
2169         }else {
2170             str = objectW;
2171         }
2172         break;
2173     }
2174     default:
2175         FIXME("unhandled vt %d\n", V_VT(&val));
2176         hres = E_NOTIMPL;
2177     }
2178
2179     VariantClear(&val);
2180     if(FAILED(hres))
2181         return hres;
2182
2183     ret->type = EXPRVAL_VARIANT;
2184     V_VT(&ret->u.var) = VT_BSTR;
2185     V_BSTR(&ret->u.var) = SysAllocString(str);
2186     return S_OK;
2187 }
2188
2189 /* ECMA-262 3rd Edition    11.4.7 */
2190 HRESULT minus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2191 {
2192     unary_expression_t *expr = (unary_expression_t*)_expr;
2193     exprval_t exprval;
2194     VARIANT val, num;
2195     HRESULT hres;
2196
2197     TRACE("\n");
2198
2199     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2200     if(FAILED(hres))
2201         return hres;
2202
2203     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2204     exprval_release(&exprval);
2205     if(FAILED(hres))
2206         return hres;
2207
2208     hres = to_number(ctx->parser->script, &val, ei, &num);
2209     VariantClear(&val);
2210     if(FAILED(hres))
2211         return hres;
2212
2213     ret->type = EXPRVAL_VARIANT;
2214     num_set_val(&ret->u.var, -num_val(&num));
2215     return S_OK;
2216 }
2217
2218 /* ECMA-262 3rd Edition    11.4.6 */
2219 HRESULT plus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2220 {
2221     unary_expression_t *expr = (unary_expression_t*)_expr;
2222     exprval_t exprval;
2223     VARIANT val, num;
2224     HRESULT hres;
2225
2226     TRACE("\n");
2227
2228     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2229     if(FAILED(hres))
2230         return hres;
2231
2232     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2233     exprval_release(&exprval);
2234     if(FAILED(hres))
2235         return hres;
2236
2237     hres = to_number(ctx->parser->script, &val, ei, &num);
2238     if(FAILED(hres))
2239         return hres;
2240
2241     ret->type = EXPRVAL_VARIANT;
2242     ret->u.var = num;
2243     return S_OK;
2244 }
2245
2246 /* ECMA-262 3rd Edition    11.3.1 */
2247 HRESULT post_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2248 {
2249     unary_expression_t *expr = (unary_expression_t*)_expr;
2250     VARIANT val, num;
2251     exprval_t exprval;
2252     HRESULT hres;
2253
2254     TRACE("\n");
2255
2256     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2257     if(FAILED(hres))
2258         return hres;
2259
2260     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2261     if(SUCCEEDED(hres)) {
2262         hres = to_number(ctx->parser->script, &val, ei, &num);
2263         VariantClear(&val);
2264     }
2265
2266     if(SUCCEEDED(hres)) {
2267         VARIANT inc;
2268         num_set_val(&inc, num_val(&num)+1.0);
2269         hres = put_value(ctx->parser->script, &exprval, &inc, ei);
2270     }
2271
2272     exprval_release(&exprval);
2273     if(FAILED(hres))
2274         return hres;
2275
2276     ret->type = EXPRVAL_VARIANT;
2277     ret->u.var = num;
2278     return S_OK;
2279 }
2280
2281 /* ECMA-262 3rd Edition    11.3.2 */
2282 HRESULT post_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2283 {
2284     unary_expression_t *expr = (unary_expression_t*)_expr;
2285     VARIANT val, num;
2286     exprval_t exprval;
2287     HRESULT hres;
2288
2289     TRACE("\n");
2290
2291     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2292     if(FAILED(hres))
2293         return hres;
2294
2295     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2296     if(SUCCEEDED(hres)) {
2297         hres = to_number(ctx->parser->script, &val, ei, &num);
2298         VariantClear(&val);
2299     }
2300
2301     if(SUCCEEDED(hres)) {
2302         VARIANT dec;
2303         num_set_val(&dec, num_val(&num)-1.0);
2304         hres = put_value(ctx->parser->script, &exprval, &dec, ei);
2305     }
2306
2307     exprval_release(&exprval);
2308     if(FAILED(hres))
2309         return hres;
2310
2311     ret->type = EXPRVAL_VARIANT;
2312     ret->u.var = num;
2313     return S_OK;
2314 }
2315
2316 /* ECMA-262 3rd Edition    11.4.4 */
2317 HRESULT pre_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2318 {
2319     unary_expression_t *expr = (unary_expression_t*)_expr;
2320     VARIANT val, num;
2321     exprval_t exprval;
2322     HRESULT hres;
2323
2324     TRACE("\n");
2325
2326     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2327     if(FAILED(hres))
2328         return hres;
2329
2330     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2331     if(SUCCEEDED(hres)) {
2332         hres = to_number(ctx->parser->script, &val, ei, &num);
2333         VariantClear(&val);
2334     }
2335
2336     if(SUCCEEDED(hres)) {
2337         num_set_val(&val, num_val(&num)+1.0);
2338         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2339     }
2340
2341     exprval_release(&exprval);
2342     if(FAILED(hres))
2343         return hres;
2344
2345     ret->type = EXPRVAL_VARIANT;
2346     ret->u.var = val;
2347     return S_OK;
2348 }
2349
2350 /* ECMA-262 3rd Edition    11.4.5 */
2351 HRESULT pre_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2352 {
2353     unary_expression_t *expr = (unary_expression_t*)_expr;
2354     VARIANT val, num;
2355     exprval_t exprval;
2356     HRESULT hres;
2357
2358     TRACE("\n");
2359
2360     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2361     if(FAILED(hres))
2362         return hres;
2363
2364     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2365     if(SUCCEEDED(hres)) {
2366         hres = to_number(ctx->parser->script, &val, ei, &num);
2367         VariantClear(&val);
2368     }
2369
2370     if(SUCCEEDED(hres)) {
2371         num_set_val(&val, num_val(&num)-1.0);
2372         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2373     }
2374
2375     exprval_release(&exprval);
2376     if(FAILED(hres))
2377         return hres;
2378
2379     ret->type = EXPRVAL_VARIANT;
2380     ret->u.var = val;
2381     return S_OK;
2382 }
2383
2384 /* ECMA-262 3rd Edition    11.9.3 */
2385 static HRESULT equal_values(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2386 {
2387     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2388        return equal2_values(lval, rval, ret);
2389
2390     /* FIXME: NULL disps should be handled in more general way */
2391     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2392         VARIANT v;
2393         V_VT(&v) = VT_NULL;
2394         return equal_values(ctx, &v, rval, ei, ret);
2395     }
2396
2397     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2398         VARIANT v;
2399         V_VT(&v) = VT_NULL;
2400         return equal_values(ctx, lval, &v, ei, ret);
2401     }
2402
2403     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2404        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2405         *ret = TRUE;
2406         return S_OK;
2407     }
2408
2409     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2410         VARIANT v;
2411         HRESULT hres;
2412
2413         hres = to_number(ctx->parser->script, lval, ei, &v);
2414         if(FAILED(hres))
2415             return hres;
2416
2417         return equal_values(ctx, &v, rval, ei, ret);
2418     }
2419
2420     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2421         VARIANT v;
2422         HRESULT hres;
2423
2424         hres = to_number(ctx->parser->script, rval, ei, &v);
2425         if(FAILED(hres))
2426             return hres;
2427
2428         return equal_values(ctx, lval, &v, ei, ret);
2429     }
2430
2431     if(V_VT(rval) == VT_BOOL) {
2432         VARIANT v;
2433
2434         V_VT(&v) = VT_I4;
2435         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2436         return equal_values(ctx, lval, &v, ei, ret);
2437     }
2438
2439     if(V_VT(lval) == VT_BOOL) {
2440         VARIANT v;
2441
2442         V_VT(&v) = VT_I4;
2443         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2444         return equal_values(ctx, &v, rval, ei, ret);
2445     }
2446
2447
2448     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2449         VARIANT v;
2450         HRESULT hres;
2451
2452         hres = to_primitive(ctx->parser->script, rval, ei, &v);
2453         if(FAILED(hres))
2454             return hres;
2455
2456         hres = equal_values(ctx, lval, &v, ei, ret);
2457
2458         VariantClear(&v);
2459         return hres;
2460     }
2461
2462
2463     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2464         VARIANT v;
2465         HRESULT hres;
2466
2467         hres = to_primitive(ctx->parser->script, lval, ei, &v);
2468         if(FAILED(hres))
2469             return hres;
2470
2471         hres = equal_values(ctx, &v, rval, ei, ret);
2472
2473         VariantClear(&v);
2474         return hres;
2475     }
2476
2477
2478     *ret = FALSE;
2479     return S_OK;
2480 }
2481
2482 /* ECMA-262 3rd Edition    11.9.1 */
2483 HRESULT equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2484 {
2485     binary_expression_t *expr = (binary_expression_t*)_expr;
2486     VARIANT rval, lval;
2487     BOOL b;
2488     HRESULT hres;
2489
2490     TRACE("\n");
2491
2492     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2493     if(FAILED(hres))
2494         return hres;
2495
2496     hres = equal_values(ctx, &rval, &lval, ei, &b);
2497     if(FAILED(hres))
2498         return hres;
2499
2500     return return_bool(ret, b);
2501 }
2502
2503 /* ECMA-262 3rd Edition    11.9.4 */
2504 HRESULT equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2505 {
2506     binary_expression_t *expr = (binary_expression_t*)_expr;
2507     VARIANT rval, lval;
2508     BOOL b;
2509     HRESULT hres;
2510
2511     TRACE("\n");
2512
2513     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2514     if(FAILED(hres))
2515         return hres;
2516
2517     hres = equal2_values(&rval, &lval, &b);
2518     if(FAILED(hres))
2519         return hres;
2520
2521     return return_bool(ret, b);
2522 }
2523
2524 /* ECMA-262 3rd Edition    11.9.2 */
2525 HRESULT not_equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2526 {
2527     binary_expression_t *expr = (binary_expression_t*)_expr;
2528     VARIANT rval, lval;
2529     BOOL b;
2530     HRESULT hres;
2531
2532     TRACE("\n");
2533
2534     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2535     if(FAILED(hres))
2536         return hres;
2537
2538     hres = equal_values(ctx, &lval, &rval, ei, &b);
2539     if(FAILED(hres))
2540         return hres;
2541
2542     return return_bool(ret, !b);
2543 }
2544
2545 /* ECMA-262 3rd Edition    11.9.5 */
2546 HRESULT not_equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2547 {
2548     binary_expression_t *expr = (binary_expression_t*)_expr;
2549     VARIANT rval, lval;
2550     BOOL b;
2551     HRESULT hres;
2552
2553     TRACE("\n");
2554
2555     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2556     if(FAILED(hres))
2557         return hres;
2558
2559     hres = equal2_values(&lval, &rval, &b);
2560     if(FAILED(hres))
2561         return hres;
2562
2563     return return_bool(ret, !b);
2564 }
2565
2566 /* ECMA-262 3rd Edition    11.8.5 */
2567 static HRESULT less_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2568 {
2569     VARIANT l, r, ln, rn;
2570     HRESULT hres;
2571
2572     hres = to_primitive(ctx->parser->script, lval, ei, &l);
2573     if(FAILED(hres))
2574         return hres;
2575
2576     hres = to_primitive(ctx->parser->script, rval, ei, &r);
2577     if(FAILED(hres)) {
2578         VariantClear(&l);
2579         return hres;
2580     }
2581
2582     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2583         *ret = strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0;
2584         SysFreeString(V_BSTR(&l));
2585         SysFreeString(V_BSTR(&r));
2586         return S_OK;
2587     }
2588
2589     hres = to_number(ctx->parser->script, &l, ei, &ln);
2590     VariantClear(&l);
2591     if(SUCCEEDED(hres))
2592         hres = to_number(ctx->parser->script, &r, ei, &rn);
2593     VariantClear(&r);
2594     if(FAILED(hres))
2595         return hres;
2596
2597     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4)
2598         *ret = V_I4(&ln) < V_I4(&rn);
2599     else
2600         *ret = num_val(&ln) < num_val(&rn);
2601
2602     return S_OK;
2603 }
2604
2605 /* ECMA-262 3rd Edition    11.8.1 */
2606 HRESULT less_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2607 {
2608     binary_expression_t *expr = (binary_expression_t*)_expr;
2609     VARIANT rval, lval;
2610     BOOL b;
2611     HRESULT hres;
2612
2613     TRACE("\n");
2614
2615     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2616     if(FAILED(hres))
2617         return hres;
2618
2619     hres = less_eval(ctx, &lval, &rval, ei, &b);
2620     VariantClear(&lval);
2621     VariantClear(&rval);
2622     if(FAILED(hres))
2623         return hres;
2624
2625     return return_bool(ret, b);
2626 }
2627
2628 /* ECMA-262 3rd Edition    11.8.3 */
2629 HRESULT lesseq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2630 {
2631     binary_expression_t *expr = (binary_expression_t*)_expr;
2632     VARIANT rval, lval;
2633     BOOL b;
2634     HRESULT hres;
2635
2636     TRACE("\n");
2637
2638     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2639     if(FAILED(hres))
2640         return hres;
2641
2642     hres = less_eval(ctx, &rval, &lval, ei, &b);
2643     VariantClear(&lval);
2644     VariantClear(&rval);
2645     if(FAILED(hres))
2646         return hres;
2647
2648     return return_bool(ret, !b);
2649 }
2650
2651 /* ECMA-262 3rd Edition    11.8.2 */
2652 HRESULT greater_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2653 {
2654     binary_expression_t *expr = (binary_expression_t*)_expr;
2655     VARIANT rval, lval;
2656     BOOL b;
2657     HRESULT hres;
2658
2659     TRACE("\n");
2660
2661     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2662     if(FAILED(hres))
2663         return hres;
2664
2665     hres = less_eval(ctx, &rval, &lval, ei, &b);
2666     VariantClear(&lval);
2667     VariantClear(&rval);
2668     if(FAILED(hres))
2669         return hres;
2670
2671     return return_bool(ret, b);
2672 }
2673
2674 /* ECMA-262 3rd Edition    11.8.4 */
2675 HRESULT greatereq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2676 {
2677     binary_expression_t *expr = (binary_expression_t*)_expr;
2678     VARIANT rval, lval;
2679     BOOL b;
2680     HRESULT hres;
2681
2682     TRACE("\n");
2683
2684     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2685     if(FAILED(hres))
2686         return hres;
2687
2688     hres = less_eval(ctx, &lval, &rval, ei, &b);
2689     VariantClear(&lval);
2690     VariantClear(&rval);
2691     if(FAILED(hres))
2692         return hres;
2693
2694     return return_bool(ret, !b);
2695 }
2696
2697 /* ECMA-262 3rd Edition    11.4.8 */
2698 HRESULT binary_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2699 {
2700     unary_expression_t *expr = (unary_expression_t*)_expr;
2701     exprval_t exprval;
2702     VARIANT val;
2703     INT i;
2704     HRESULT hres;
2705
2706     TRACE("\n");
2707
2708     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2709     if(FAILED(hres))
2710         return hres;
2711
2712     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2713     exprval_release(&exprval);
2714     if(FAILED(hres))
2715         return hres;
2716
2717     hres = to_int32(ctx->parser->script, &val, ei, &i);
2718     if(FAILED(hres))
2719         return hres;
2720
2721     ret->type = EXPRVAL_VARIANT;
2722     V_VT(&ret->u.var) = VT_I4;
2723     V_I4(&ret->u.var) = ~i;
2724     return S_OK;
2725 }
2726
2727 /* ECMA-262 3rd Edition    11.4.9 */
2728 HRESULT logical_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2729 {
2730     unary_expression_t *expr = (unary_expression_t*)_expr;
2731     exprval_t exprval;
2732     VARIANT_BOOL b;
2733     HRESULT hres;
2734
2735     TRACE("\n");
2736
2737     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2738     if(FAILED(hres))
2739         return hres;
2740
2741     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
2742     exprval_release(&exprval);
2743     if(FAILED(hres))
2744         return hres;
2745
2746     return return_bool(ret, !b);
2747 }
2748
2749 /* ECMA-262 3rd Edition    11.7.1 */
2750 static HRESULT lshift_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2751 {
2752     DWORD ri;
2753     INT li;
2754     HRESULT hres;
2755
2756     hres = to_int32(ctx->parser->script, lval, ei, &li);
2757     if(FAILED(hres))
2758         return hres;
2759
2760     hres = to_uint32(ctx->parser->script, rval, ei, &ri);
2761     if(FAILED(hres))
2762         return hres;
2763
2764     V_VT(retv) = VT_I4;
2765     V_I4(retv) = li << (ri&0x1f);
2766     return S_OK;
2767 }
2768
2769 /* ECMA-262 3rd Edition    11.7.1 */
2770 HRESULT left_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2771 {
2772     binary_expression_t *expr = (binary_expression_t*)_expr;
2773
2774     TRACE("\n");
2775
2776     return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
2777 }
2778
2779 /* ECMA-262 3rd Edition    11.7.2 */
2780 static HRESULT rshift_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2781 {
2782     DWORD ri;
2783     INT li;
2784     HRESULT hres;
2785
2786     hres = to_int32(ctx->parser->script, lval, ei, &li);
2787     if(FAILED(hres))
2788         return hres;
2789
2790     hres = to_uint32(ctx->parser->script, rval, ei, &ri);
2791     if(FAILED(hres))
2792         return hres;
2793
2794     V_VT(retv) = VT_I4;
2795     V_I4(retv) = li >> (ri&0x1f);
2796     return S_OK;
2797 }
2798
2799 /* ECMA-262 3rd Edition    11.7.2 */
2800 HRESULT right_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2801 {
2802     binary_expression_t *expr = (binary_expression_t*)_expr;
2803
2804     TRACE("\n");
2805
2806     return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
2807 }
2808
2809 /* ECMA-262 3rd Edition    11.7.3 */
2810 static HRESULT rshift2_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2811 {
2812     DWORD li, ri;
2813     HRESULT hres;
2814
2815     hres = to_uint32(ctx->parser->script, lval, ei, &li);
2816     if(FAILED(hres))
2817         return hres;
2818
2819     hres = to_uint32(ctx->parser->script, rval, ei, &ri);
2820     if(FAILED(hres))
2821         return hres;
2822
2823     V_VT(retv) = VT_I4;
2824     V_I4(retv) = li >> (ri&0x1f);
2825     return S_OK;
2826 }
2827
2828 /* ECMA-262 3rd Edition    11.7.3 */
2829 HRESULT right2_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2830 {
2831     binary_expression_t *expr = (binary_expression_t*)_expr;
2832
2833     TRACE("\n");
2834
2835     return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
2836 }
2837
2838 /* ECMA-262 3rd Edition    11.13.1 */
2839 HRESULT assign_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2840 {
2841     binary_expression_t *expr = (binary_expression_t*)_expr;
2842     exprval_t exprval, exprvalr;
2843     VARIANT rval;
2844     HRESULT hres;
2845
2846     TRACE("\n");
2847
2848     hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
2849     if(FAILED(hres))
2850         return hres;
2851
2852     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
2853     if(SUCCEEDED(hres)) {
2854         hres = exprval_to_value(ctx->parser->script, &exprvalr, ei, &rval);
2855         exprval_release(&exprvalr);
2856     }
2857
2858     if(SUCCEEDED(hres))
2859         hres = put_value(ctx->parser->script, &exprval, &rval, ei);
2860
2861     exprval_release(&exprval);
2862     if(FAILED(hres)) {
2863         VariantClear(&rval);
2864         return hres;
2865     }
2866
2867     ret->type = EXPRVAL_VARIANT;
2868     ret->u.var = rval;
2869     return S_OK;
2870 }
2871
2872 /* ECMA-262 3rd Edition    11.13.2 */
2873 HRESULT assign_lshift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2874 {
2875     binary_expression_t *expr = (binary_expression_t*)_expr;
2876
2877     TRACE("\n");
2878
2879     return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
2880 }
2881
2882 /* ECMA-262 3rd Edition    11.13.2 */
2883 HRESULT assign_rshift_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 assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
2890 }
2891
2892 /* ECMA-262 3rd Edition    11.13.2 */
2893 HRESULT assign_rrshift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2894 {
2895     binary_expression_t *expr = (binary_expression_t*)_expr;
2896
2897     TRACE("\n");
2898
2899     return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
2900 }
2901
2902 /* ECMA-262 3rd Edition    11.13.2 */
2903 HRESULT assign_add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2904 {
2905     binary_expression_t *expr = (binary_expression_t*)_expr;
2906
2907     TRACE("\n");
2908
2909     return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
2910 }
2911
2912 /* ECMA-262 3rd Edition    11.13.2 */
2913 HRESULT assign_sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2914 {
2915     binary_expression_t *expr = (binary_expression_t*)_expr;
2916
2917     TRACE("\n");
2918
2919     return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
2920 }
2921
2922 /* ECMA-262 3rd Edition    11.13.2 */
2923 HRESULT assign_mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2924 {
2925     binary_expression_t *expr = (binary_expression_t*)_expr;
2926
2927     TRACE("\n");
2928
2929     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
2930 }
2931
2932 /* ECMA-262 3rd Edition    11.13.2 */
2933 HRESULT assign_div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2934 {
2935     binary_expression_t *expr = (binary_expression_t*)_expr;
2936
2937     TRACE("\n");
2938
2939     return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
2940 }
2941
2942 /* ECMA-262 3rd Edition    11.13.2 */
2943 HRESULT assign_mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2944 {
2945     FIXME("\n");
2946     return E_NOTIMPL;
2947 }
2948
2949 /* ECMA-262 3rd Edition    11.13.2 */
2950 HRESULT assign_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2951 {
2952     binary_expression_t *expr = (binary_expression_t*)_expr;
2953
2954     TRACE("\n");
2955
2956     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
2957 }
2958
2959 /* ECMA-262 3rd Edition    11.13.2 */
2960 HRESULT assign_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2961 {
2962     binary_expression_t *expr = (binary_expression_t*)_expr;
2963
2964     TRACE("\n");
2965
2966     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
2967 }
2968
2969 /* ECMA-262 3rd Edition    11.13.2 */
2970 HRESULT assign_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2971 {
2972     binary_expression_t *expr = (binary_expression_t*)_expr;
2973
2974     TRACE("\n");
2975
2976     return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
2977 }