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 static inline BOOL is_num_vt(enum VARENUM vt)
 282 {
 283     return vt == VT_I4 || vt == VT_R8;
 284 }
 285
 286 static inline DOUBLE num_val(const VARIANT *v)
 287 {
 288     return V_VT(v) == VT_I4 ? V_I4(v) : V_R8(v);
 289 }
 290
 291 static inline void num_set_val(VARIANT *v, DOUBLE d)
 292 {
 293     if(d == (DOUBLE)(INT)d) {
 294         V_VT(v) = VT_I4;
 295         V_I4(v) = d;
 296     }else {
 297         V_VT(v) = VT_R8;
 298         V_R8(v) = d;
 299     }
 300 }
 301
 302 /* ECMA-262 3rd Edition    11.9.6 */
 303 HRESULT equal2_values(VARIANT *lval, VARIANT *rval, BOOL *ret)
 304 {
 305     TRACE("\n");
 306
 307     if(V_VT(lval) != V_VT(rval)) {
 308         if(is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))) {
 309             *ret = num_val(lval) == num_val(rval);
 310             return S_OK;
 311         }
 312
 313         *ret = FALSE;
 314         return S_OK;
 315     }
 316
 317     switch(V_VT(lval)) {
 318     case VT_EMPTY:
 319     case VT_NULL:
 320         *ret = VARIANT_TRUE;
 321         break;
 322     case VT_I4:
 323         *ret = V_I4(lval) == V_I4(rval);
 324         break;
 325     case VT_R8:
 326         *ret = V_R8(lval) == V_R8(rval);
 327         break;
 328     case VT_BSTR:
 329         *ret = !strcmpW(V_BSTR(lval), V_BSTR(rval));
 330         break;
 331     case VT_DISPATCH:
 332         return disp_cmp(V_DISPATCH(lval), V_DISPATCH(rval), ret);
 333     case VT_BOOL:
 334         *ret = !V_BOOL(lval) == !V_BOOL(rval);
 335         break;
 336     default:
 337         FIXME("unimplemented vt %d\n", V_VT(lval));
 338         return E_NOTIMPL;
 339     }
 340
 341     return S_OK;
 342 }
 343
 344 static HRESULT literal_to_var(literal_t *literal, VARIANT *v)
 345 {
 346     V_VT(v) = literal->vt;
 347
 348     switch(V_VT(v)) {
 349     case VT_EMPTY:
 350     case VT_NULL:
 351         break;
 352     case VT_I4:
 353         V_I4(v) = literal->u.lval;
 354         break;
 355     case VT_R8:
 356         V_R8(v) = literal->u.dval;
 357         break;
 358     case VT_BSTR:
 359         V_BSTR(v) = SysAllocString(literal->u.wstr);
 360         break;
 361     case VT_BOOL:
 362         V_BOOL(v) = literal->u.bval;
 363         break;
 364     case VT_DISPATCH:
 365         IDispatch_AddRef(literal->u.disp);
 366         V_DISPATCH(v) = literal->u.disp;
 367         break;
 368     default:
 369         ERR("wrong type %d\n", V_VT(v));
 370         return E_NOTIMPL;
 371     }
 372
 373     return S_OK;
 374 }
 375
 376 HRESULT exec_source(exec_ctx_t *ctx, parser_ctx_t *parser, source_elements_t *source, jsexcept_t *ei, VARIANT *retv)
 377 {
 378     script_ctx_t *script = parser->script;
 379     function_declaration_t *func;
 380     parser_ctx_t *prev_parser;
 381     VARIANT val, tmp;
 382     statement_t *stat;
 383     exec_ctx_t *prev_ctx;
 384     return_type_t rt;
 385     HRESULT hres = S_OK;
 386
 387     for(func = source->functions; func; func = func->next) {
 388         DispatchEx *func_obj;
 389         VARIANT var;
 390
 391         hres = create_source_function(parser, func->parameter_list, func->source_elements, ctx->scope_chain, &func_obj);
 392         if(FAILED(hres))
 393             return hres;
 394
 395         V_VT(&var) = VT_DISPATCH;
 396         V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(func_obj);
 397         hres = jsdisp_propput_name(ctx->var_disp, func->identifier, script->lcid, &var, ei, NULL);
 398         IDispatchEx_Release(_IDispatchEx_(func_obj));
 399         if(FAILED(hres))
 400             return hres;
 401     }
 402
 403     prev_ctx = script->exec_ctx;
 404     script->exec_ctx = ctx;
 405
 406     prev_parser = ctx->parser;
 407     ctx->parser = parser;
 408
 409     V_VT(&val) = VT_EMPTY;
 410     memset(&rt, 0, sizeof(rt));
 411     rt.type = RT_NORMAL;
 412
 413     for(stat = source->statement; stat; stat = stat->next) {
 414         hres = stat_eval(ctx, stat, &rt, &tmp);
 415         if(FAILED(hres))
 416             break;
 417
 418         VariantClear(&val);
 419         val = tmp;
 420         if(rt.type != RT_NORMAL)
 421             break;
 422     }
 423
 424     script->exec_ctx = prev_ctx;
 425     ctx->parser = prev_parser;
 426
 427     if(rt.type != RT_NORMAL && rt.type != RT_RETURN) {
 428         FIXME("wrong rt %d\n", rt.type);
 429         hres = E_FAIL;
 430     }
 431
 432     *ei = rt.ei;
 433     if(FAILED(hres)) {
 434         VariantClear(&val);
 435         return hres;
 436     }
 437
 438     if(retv)
 439         *retv = val;
 440     else
 441         VariantClear(&val);
 442     return S_OK;
 443 }
 444
 445 /* ECMA-262 3rd Edition    10.1.4 */
 446 static HRESULT identifier_eval(exec_ctx_t *ctx, BSTR identifier, DWORD flags, exprval_t *ret)
 447 {
 448     scope_chain_t *scope;
 449     named_item_t *item;
 450     DISPID id = 0;
 451     HRESULT hres;
 452
 453     TRACE("%s\n", debugstr_w(identifier));
 454
 455     for(scope = ctx->scope_chain; scope; scope = scope->next) {
 456         hres = dispex_get_id(_IDispatchEx_(scope->obj), identifier, 0, &id);
 457         if(SUCCEEDED(hres))
 458             break;
 459     }
 460
 461     if(scope) {
 462         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(scope->obj), id);
 463         return S_OK;
 464     }
 465
 466     hres = dispex_get_id(_IDispatchEx_(ctx->parser->script->global), identifier, 0, &id);
 467     if(SUCCEEDED(hres)) {
 468         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->global), id);
 469         return S_OK;
 470     }
 471
 472     for(item = ctx->parser->script->named_items; item; item = item->next) {
 473         hres = disp_get_id(item->disp, identifier, 0, &id);
 474         if(SUCCEEDED(hres))
 475             break;
 476     }
 477
 478     if(item) {
 479         exprval_set_idref(ret, (IDispatch*)item->disp, id);
 480         return S_OK;
 481     }
 482
 483     hres = dispex_get_id(_IDispatchEx_(ctx->parser->script->script_disp), identifier, 0, &id);
 484     if(SUCCEEDED(hres)) {
 485         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->parser->script->script_disp), id);
 486         return S_OK;
 487     }
 488
 489     if(flags & EXPR_NEWREF) {
 490         hres = dispex_get_id(_IDispatchEx_(ctx->var_disp), identifier, fdexNameEnsure, &id);
 491         if(FAILED(hres))
 492             return hres;
 493
 494         exprval_set_idref(ret, (IDispatch*)_IDispatchEx_(ctx->var_disp), id);
 495         return S_OK;
 496     }
 497
 498     WARN("Could not find identifier %s\n", debugstr_w(identifier));
 499     return E_FAIL;
 500 }
 501
 502 /* ECMA-262 3rd Edition    12.1 */
 503 HRESULT block_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 504 {
 505     block_statement_t *stat = (block_statement_t*)_stat;
 506     VARIANT val, tmp;
 507     statement_t *iter;
 508     HRESULT hres = S_OK;
 509
 510     TRACE("\n");
 511
 512     V_VT(&val) = VT_EMPTY;
 513     for(iter = stat->stat_list; iter; iter = iter->next) {
 514         hres = stat_eval(ctx, iter, rt, &tmp);
 515         if(FAILED(hres))
 516             break;
 517
 518         VariantClear(&val);
 519         val = tmp;
 520         if(rt->type != RT_NORMAL)
 521             break;
 522     }
 523
 524     if(FAILED(hres)) {
 525         VariantClear(&val);
 526         return hres;
 527     }
 528
 529     *ret = val;
 530     return S_OK;
 531 }
 532
 533 /* ECMA-262 3rd Edition    12.2 */
 534 static HRESULT variable_list_eval(exec_ctx_t *ctx, variable_declaration_t *var_list, jsexcept_t *ei)
 535 {
 536     variable_declaration_t *iter;
 537     HRESULT hres = E_FAIL;
 538
 539     for(iter = var_list; iter; iter = iter->next) {
 540         VARIANT val;
 541
 542         if(iter->expr) {
 543             exprval_t exprval;
 544
 545             hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
 546             if(FAILED(hres))
 547                 break;
 548
 549             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
 550             exprval_release(&exprval);
 551             if(FAILED(hres))
 552                 break;
 553         }else {
 554             V_VT(&val) = VT_EMPTY;
 555         }
 556
 557         hres = jsdisp_propput_name(ctx->var_disp, iter->identifier, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
 558         VariantClear(&val);
 559         if(FAILED(hres))
 560             break;
 561     }
 562
 563     return hres;
 564 }
 565
 566 /* ECMA-262 3rd Edition    12.2 */
 567 HRESULT var_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 568 {
 569     var_statement_t *stat = (var_statement_t*)_stat;
 570     HRESULT hres;
 571
 572     TRACE("\n");
 573
 574     hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
 575     if(FAILED(hres))
 576         return hres;
 577
 578     V_VT(ret) = VT_EMPTY;
 579     return S_OK;
 580 }
 581
 582 /* ECMA-262 3rd Edition    12.3 */
 583 HRESULT empty_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 584 {
 585     TRACE("\n");
 586
 587     V_VT(ret) = VT_EMPTY;
 588     return S_OK;
 589 }
 590
 591 /* ECMA-262 3rd Edition    12.4 */
 592 HRESULT expression_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 593 {
 594     expression_statement_t *stat = (expression_statement_t*)_stat;
 595     exprval_t exprval;
 596     VARIANT val;
 597     HRESULT hres;
 598
 599     TRACE("\n");
 600
 601     hres = expr_eval(ctx, stat->expr, EXPR_NOVAL, &rt->ei, &exprval);
 602     if(FAILED(hres))
 603         return hres;
 604
 605     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 606     exprval_release(&exprval);
 607     if(FAILED(hres))
 608         return hres;
 609
 610     *ret = val;
 611     TRACE("= %s\n", debugstr_variant(ret));
 612     return S_OK;
 613 }
 614
 615 /* ECMA-262 3rd Edition    12.5 */
 616 HRESULT if_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 617 {
 618     if_statement_t *stat = (if_statement_t*)_stat;
 619     exprval_t exprval;
 620     VARIANT_BOOL b;
 621     HRESULT hres;
 622
 623     TRACE("\n");
 624
 625     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 626     if(FAILED(hres))
 627         return hres;
 628
 629     hres = exprval_to_boolean(ctx->parser->script, &exprval, &rt->ei, &b);
 630     exprval_release(&exprval);
 631     if(FAILED(hres))
 632         return hres;
 633
 634     if(b)
 635         hres = stat_eval(ctx, stat->if_stat, rt, ret);
 636     else if(stat->else_stat)
 637         hres = stat_eval(ctx, stat->else_stat, rt, ret);
 638     else
 639         V_VT(ret) = VT_EMPTY;
 640
 641     return hres;
 642 }
 643
 644 HRESULT dowhile_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 645 {
 646     FIXME("\n");
 647     return E_NOTIMPL;
 648 }
 649
 650 HRESULT while_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 651 {
 652     FIXME("\n");
 653     return E_NOTIMPL;
 654 }
 655
 656 HRESULT for_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 657 {
 658     FIXME("\n");
 659     return E_NOTIMPL;
 660 }
 661
 662 HRESULT forin_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 663 {
 664     FIXME("\n");
 665     return E_NOTIMPL;
 666 }
 667
 668 HRESULT continue_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 669 {
 670     FIXME("\n");
 671     return E_NOTIMPL;
 672 }
 673
 674 /* ECMA-262 3rd Edition    12.8 */
 675 HRESULT break_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 676 {
 677     branch_statement_t *stat = (branch_statement_t*)_stat;
 678
 679     TRACE("\n");
 680
 681     if(stat->identifier) {
 682         FIXME("indentifier not implemented\n");
 683         return E_NOTIMPL;
 684     }
 685
 686     rt->type = RT_BREAK;
 687     V_VT(ret) = VT_EMPTY;
 688     return S_OK;
 689 }
 690
 691 /* ECMA-262 3rd Edition    12.9 */
 692 HRESULT return_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 693 {
 694     expression_statement_t *stat = (expression_statement_t*)_stat;
 695     HRESULT hres;
 696
 697     TRACE("\n");
 698
 699     if(stat->expr) {
 700         exprval_t exprval;
 701
 702         hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 703         if(FAILED(hres))
 704             return hres;
 705
 706         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, ret);
 707         exprval_release(&exprval);
 708         if(FAILED(hres))
 709             return hres;
 710     }else {
 711         V_VT(ret) = VT_EMPTY;
 712     }
 713
 714     TRACE("= %s\n", debugstr_variant(ret));
 715     rt->type = RT_RETURN;
 716     return S_OK;
 717 }
 718
 719 HRESULT with_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 720 {
 721     FIXME("\n");
 722     return E_NOTIMPL;
 723 }
 724
 725 HRESULT labelled_statement_eval(exec_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
 726 {
 727     FIXME("\n");
 728     return E_NOTIMPL;
 729 }
 730
 731 /* ECMA-262 3rd Edition    12.13 */
 732 HRESULT switch_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 733 {
 734     switch_statement_t *stat = (switch_statement_t*)_stat;
 735     case_clausule_t *iter, *default_clausule = NULL;
 736     statement_t *stat_iter;
 737     VARIANT val, cval;
 738     exprval_t exprval;
 739     BOOL b;
 740     HRESULT hres;
 741
 742     TRACE("\n");
 743
 744     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 745     if(FAILED(hres))
 746         return hres;
 747
 748     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 749     exprval_release(&exprval);
 750     if(FAILED(hres))
 751         return hres;
 752
 753     for(iter = stat->case_list; iter; iter = iter->next) {
 754         if(!iter->expr) {
 755             default_clausule = iter;
 756             continue;
 757         }
 758
 759         hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &exprval);
 760         if(FAILED(hres))
 761             break;
 762
 763         hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &cval);
 764         exprval_release(&exprval);
 765         if(FAILED(hres))
 766             break;
 767
 768         hres = equal2_values(&val, &cval, &b);
 769         VariantClear(&cval);
 770         if(FAILED(hres) || b)
 771             break;
 772     }
 773
 774     VariantClear(&val);
 775     if(FAILED(hres))
 776         return hres;
 777
 778     if(!iter)
 779         iter = default_clausule;
 780
 781     V_VT(&val) = VT_EMPTY;
 782     if(iter) {
 783         VARIANT tmp;
 784
 785         for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
 786             hres = stat_eval(ctx, stat_iter, rt, &tmp);
 787             if(FAILED(hres))
 788                 break;
 789
 790             VariantClear(&val);
 791             val = tmp;
 792
 793             if(rt->type != RT_NORMAL)
 794                 break;
 795         }
 796     }
 797
 798     if(FAILED(hres)) {
 799         VariantClear(&val);
 800         return hres;
 801     }
 802
 803     if(rt->type == RT_BREAK)
 804         rt->type = RT_NORMAL;
 805
 806     *ret = val;
 807     return S_OK;
 808 }
 809
 810 /* ECMA-262 3rd Edition    12.13 */
 811 HRESULT throw_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 812 {
 813     expression_statement_t *stat = (expression_statement_t*)_stat;
 814     exprval_t exprval;
 815     VARIANT val;
 816     HRESULT hres;
 817
 818     TRACE("\n");
 819
 820     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &exprval);
 821     if(FAILED(hres))
 822         return hres;
 823
 824     hres = exprval_to_value(ctx->parser->script, &exprval, &rt->ei, &val);
 825     exprval_release(&exprval);
 826     if(FAILED(hres))
 827         return hres;
 828
 829     rt->ei.var = val;
 830     return DISP_E_EXCEPTION;
 831 }
 832
 833 /* ECMA-262 3rd Edition    12.14 */
 834 static HRESULT catch_eval(exec_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
 835 {
 836     DispatchEx *var_disp;
 837     VARIANT ex, val;
 838     HRESULT hres;
 839
 840     ex = rt->ei.var;
 841     memset(&rt->ei, 0, sizeof(jsexcept_t));
 842
 843     hres = create_dispex(ctx->parser->script, NULL, NULL, &var_disp);
 844     if(SUCCEEDED(hres)) {
 845         hres = jsdisp_propput_name(var_disp, block->identifier, ctx->parser->script->lcid,
 846                 &ex, &rt->ei, NULL/*FIXME*/);
 847         if(SUCCEEDED(hres)) {
 848             hres = scope_push(ctx->scope_chain, var_disp, &ctx->scope_chain);
 849             if(SUCCEEDED(hres)) {
 850                 hres = stat_eval(ctx, block->statement, rt, &val);
 851                 scope_pop(&ctx->scope_chain);
 852             }
 853         }
 854
 855         jsdisp_release(var_disp);
 856     }
 857
 858     VariantClear(&ex);
 859     if(FAILED(hres))
 860         return hres;
 861
 862     *ret = val;
 863     return S_OK;
 864 }
 865
 866 /* ECMA-262 3rd Edition    12.14 */
 867 HRESULT try_statement_eval(exec_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 868 {
 869     try_statement_t *stat = (try_statement_t*)_stat;
 870     VARIANT val;
 871     HRESULT hres;
 872
 873     TRACE("\n");
 874
 875     hres = stat_eval(ctx, stat->try_statement, rt, &val);
 876     if(FAILED(hres)) {
 877         TRACE("EXCEPTION\n");
 878         if(!stat->catch_block)
 879             return hres;
 880
 881         hres = catch_eval(ctx, stat->catch_block, rt, &val);
 882         if(FAILED(hres))
 883             return hres;
 884     }
 885
 886     if(stat->finally_statement) {
 887         VariantClear(&val);
 888         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
 889         if(FAILED(hres))
 890             return hres;
 891     }
 892
 893     *ret = val;
 894     return S_OK;
 895 }
 896
 897 static HRESULT return_bool(exprval_t *ret, DWORD b)
 898 {
 899     ret->type = EXPRVAL_VARIANT;
 900     V_VT(&ret->u.var) = VT_BOOL;
 901     V_BOOL(&ret->u.var) = b ? VARIANT_TRUE : VARIANT_FALSE;
 902
 903     return S_OK;
 904 }
 905
 906 static HRESULT get_binary_expr_values(exec_ctx_t *ctx, binary_expression_t *expr, jsexcept_t *ei, VARIANT *lval, VARIANT *rval)
 907 {
 908     exprval_t exprval;
 909     HRESULT hres;
 910
 911     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
 912     if(FAILED(hres))
 913         return hres;
 914
 915     hres = exprval_to_value(ctx->parser->script, &exprval, ei, lval);
 916     exprval_release(&exprval);
 917     if(FAILED(hres))
 918         return hres;
 919
 920     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
 921     if(SUCCEEDED(hres)) {
 922         hres = exprval_to_value(ctx->parser->script, &exprval, ei, rval);
 923         exprval_release(&exprval);
 924     }
 925
 926     if(FAILED(hres)) {
 927         VariantClear(lval);
 928         return hres;
 929     }
 930
 931     return S_OK;
 932 }
 933
 934 typedef HRESULT (*oper_t)(exec_ctx_t*,VARIANT*,VARIANT*,jsexcept_t*,VARIANT*);
 935
 936 static HRESULT binary_expr_eval(exec_ctx_t *ctx, binary_expression_t *expr, oper_t oper, jsexcept_t *ei,
 937         exprval_t *ret)
 938 {
 939     VARIANT lval, rval, retv;
 940     HRESULT hres;
 941
 942     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
 943     if(FAILED(hres))
 944         return hres;
 945
 946     hres = oper(ctx, &lval, &rval, ei, &retv);
 947     VariantClear(&lval);
 948     VariantClear(&rval);
 949     if(FAILED(hres))
 950         return hres;
 951
 952     ret->type = EXPRVAL_VARIANT;
 953     ret->u.var = retv;
 954     return S_OK;
 955 }
 956
 957 /* ECMA-262 3rd Edition    11.13.2 */
 958 static HRESULT assign_oper_eval(exec_ctx_t *ctx, expression_t *lexpr, expression_t *rexpr, oper_t oper,
 959                                 jsexcept_t *ei, exprval_t *ret)
 960 {
 961     VARIANT retv, lval, rval;
 962     exprval_t exprval, exprvalr;
 963     HRESULT hres;
 964
 965     hres = expr_eval(ctx, lexpr, EXPR_NEWREF, ei, &exprval);
 966     if(FAILED(hres))
 967         return hres;
 968
 969     hres = exprval_value(ctx->parser->script, &exprval, ei, &lval);
 970     if(SUCCEEDED(hres)) {
 971         hres = expr_eval(ctx, rexpr, 0, ei, &exprvalr);
 972         if(SUCCEEDED(hres)) {
 973             hres = exprval_value(ctx->parser->script, &exprvalr, ei, &rval);
 974             exprval_release(&exprvalr);
 975         }
 976         if(SUCCEEDED(hres)) {
 977             hres = oper(ctx, &lval, &rval, ei, &retv);
 978             VariantClear(&rval);
 979         }
 980         VariantClear(&lval);
 981     }
 982
 983     if(SUCCEEDED(hres)) {
 984         hres = put_value(ctx->parser->script, &exprval, &retv, ei);
 985         if(FAILED(hres))
 986             VariantClear(&retv);
 987     }
 988     exprval_release(&exprval);
 989
 990     if(FAILED(hres))
 991         return hres;
 992
 993     ret->type = EXPRVAL_VARIANT;
 994     ret->u.var = retv;
 995     return S_OK;
 996 }
 997
 998 /* ECMA-262 3rd Edition    13 */
 999 HRESULT function_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1000 {
1001     function_expression_t *expr = (function_expression_t*)_expr;
1002     DispatchEx *dispex;
1003     VARIANT var;
1004     HRESULT hres;
1005
1006     TRACE("\n");
1007
1008     hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain, &dispex);
1009     if(FAILED(hres))
1010         return hres;
1011
1012     V_VT(&var) = VT_DISPATCH;
1013     V_DISPATCH(&var) = (IDispatch*)_IDispatchEx_(dispex);
1014
1015     if(expr->identifier) {
1016         hres = jsdisp_propput_name(ctx->var_disp, expr->identifier, ctx->parser->script->lcid, &var, ei, NULL/*FIXME*/);
1017         if(FAILED(hres)) {
1018             jsdisp_release(dispex);
1019             return hres;
1020         }
1021     }
1022
1023     ret->type = EXPRVAL_VARIANT;
1024     ret->u.var = var;
1025     return S_OK;
1026 }
1027
1028 /* ECMA-262 3rd Edition    11.12 */
1029 HRESULT conditional_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1030 {
1031     conditional_expression_t *expr = (conditional_expression_t*)_expr;
1032     exprval_t exprval;
1033     VARIANT_BOOL b;
1034     HRESULT hres;
1035
1036     TRACE("\n");
1037
1038     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1039     if(FAILED(hres))
1040         return hres;
1041
1042     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
1043     exprval_release(&exprval);
1044     if(FAILED(hres))
1045         return hres;
1046
1047     return expr_eval(ctx, b ? expr->true_expression : expr->false_expression, flags, ei, ret);
1048 }
1049
1050 /* ECMA-262 3rd Edition    11.2.1 */
1051 HRESULT array_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1052 {
1053     array_expression_t *expr = (array_expression_t*)_expr;
1054     exprval_t exprval;
1055     VARIANT member, val;
1056     DISPID id;
1057     BSTR str;
1058     IDispatch *obj = NULL;
1059     HRESULT hres;
1060
1061     TRACE("\n");
1062
1063     hres = expr_eval(ctx, expr->member_expr, EXPR_NEWREF, ei, &exprval);
1064     if(FAILED(hres))
1065         return hres;
1066
1067     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1068     exprval_release(&exprval);
1069     if(FAILED(hres))
1070         return hres;
1071
1072     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1073     if(SUCCEEDED(hres)) {
1074         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1075         exprval_release(&exprval);
1076     }
1077
1078     if(SUCCEEDED(hres))
1079         hres = to_object(ctx, &member, &obj);
1080     VariantClear(&member);
1081     if(SUCCEEDED(hres)) {
1082         hres = to_string(ctx->parser->script, &val, ei, &str);
1083         if(SUCCEEDED(hres)) {
1084             if(flags & EXPR_STRREF) {
1085                 ret->type = EXPRVAL_NAMEREF;
1086                 ret->u.nameref.disp = obj;
1087                 ret->u.nameref.name = str;
1088                 return S_OK;
1089             }
1090
1091             hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1092         }
1093
1094         if(SUCCEEDED(hres)) {
1095             exprval_set_idref(ret, obj, id);
1096         }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1097             exprval_init(ret);
1098             hres = S_OK;
1099         }
1100
1101         IDispatch_Release(obj);
1102     }
1103
1104     return hres;
1105 }
1106
1107 /* ECMA-262 3rd Edition    11.2.1 */
1108 HRESULT member_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1109 {
1110     member_expression_t *expr = (member_expression_t*)_expr;
1111     IDispatch *obj = NULL;
1112     exprval_t exprval;
1113     VARIANT member;
1114     DISPID id;
1115     BSTR str;
1116     HRESULT hres;
1117
1118     TRACE("\n");
1119
1120     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1121     if(FAILED(hres))
1122         return hres;
1123
1124     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &member);
1125     exprval_release(&exprval);
1126     if(FAILED(hres))
1127         return hres;
1128
1129     hres = to_object(ctx, &member, &obj);
1130     VariantClear(&member);
1131     if(FAILED(hres))
1132         return hres;
1133
1134     str = SysAllocString(expr->identifier);
1135     if(flags & EXPR_STRREF) {
1136         ret->type = EXPRVAL_NAMEREF;
1137         ret->u.nameref.disp = obj;
1138         ret->u.nameref.name = str;
1139         return S_OK;
1140     }
1141
1142     hres = disp_get_id(obj, str, flags & EXPR_NEWREF ? fdexNameEnsure : 0, &id);
1143     SysFreeString(str);
1144     if(SUCCEEDED(hres)) {
1145         exprval_set_idref(ret, obj, id);
1146     }else if(!(flags & EXPR_NEWREF) && hres == DISP_E_UNKNOWNNAME) {
1147         exprval_init(ret);
1148         hres = S_OK;
1149     }
1150
1151     IDispatch_Release(obj);
1152     return hres;
1153 }
1154
1155 static void free_dp(DISPPARAMS *dp)
1156 {
1157     DWORD i;
1158
1159     for(i=0; i < dp->cArgs; i++)
1160         VariantClear(dp->rgvarg+i);
1161     heap_free(dp->rgvarg);
1162 }
1163
1164 static HRESULT args_to_param(exec_ctx_t *ctx, argument_t *args, jsexcept_t *ei, DISPPARAMS *dp)
1165 {
1166     VARIANTARG *vargs;
1167     exprval_t exprval;
1168     argument_t *iter;
1169     DWORD cnt = 0, i;
1170     HRESULT hres = S_OK;
1171
1172     memset(dp, 0, sizeof(*dp));
1173     if(!args)
1174         return S_OK;
1175
1176     for(iter = args; iter; iter = iter->next)
1177         cnt++;
1178
1179     vargs = heap_alloc_zero(cnt * sizeof(*vargs));
1180     if(!vargs)
1181         return E_OUTOFMEMORY;
1182
1183     for(i = cnt, iter = args; iter; iter = iter->next) {
1184         hres = expr_eval(ctx, iter->expr, 0, ei, &exprval);
1185         if(FAILED(hres))
1186             break;
1187
1188         hres = exprval_to_value(ctx->parser->script, &exprval, ei, vargs + (--i));
1189         exprval_release(&exprval);
1190         if(FAILED(hres))
1191             break;
1192     }
1193
1194     if(FAILED(hres)) {
1195         free_dp(dp);
1196         return hres;
1197     }
1198
1199     dp->rgvarg = vargs;
1200     dp->cArgs = cnt;
1201     return S_OK;
1202 }
1203
1204 /* ECMA-262 3rd Edition    11.2.2 */
1205 HRESULT new_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1206 {
1207     call_expression_t *expr = (call_expression_t*)_expr;
1208     exprval_t exprval;
1209     VARIANT constr, var;
1210     DISPPARAMS dp;
1211     HRESULT hres;
1212
1213     TRACE("\n");
1214
1215     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1216     if(FAILED(hres))
1217         return hres;
1218
1219     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1220     if(SUCCEEDED(hres))
1221         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &constr);
1222     exprval_release(&exprval);
1223     if(FAILED(hres))
1224         return hres;
1225
1226     if(V_VT(&constr) != VT_DISPATCH) {
1227         FIXME("throw TypeError\n");
1228         VariantClear(&constr);
1229         return E_FAIL;
1230     }
1231
1232     hres = disp_call(V_DISPATCH(&constr), DISPID_VALUE, ctx->parser->script->lcid,
1233                      DISPATCH_CONSTRUCT, &dp, &var, ei, NULL/*FIXME*/);
1234     IDispatch_Release(V_DISPATCH(&constr));
1235     if(FAILED(hres))
1236         return hres;
1237
1238     ret->type = EXPRVAL_VARIANT;
1239     ret->u.var = var;
1240     return S_OK;
1241 }
1242
1243 HRESULT call_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1244 {
1245     call_expression_t *expr = (call_expression_t*)_expr;
1246     VARIANT func, var;
1247     exprval_t exprval;
1248     DISPPARAMS dp;
1249     HRESULT hres;
1250
1251     TRACE("\n");
1252
1253     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1254     if(FAILED(hres))
1255         return hres;
1256
1257     hres = args_to_param(ctx, expr->argument_list, ei, &dp);
1258     if(SUCCEEDED(hres)) {
1259         switch(exprval.type) {
1260         case EXPRVAL_IDREF:
1261             hres = disp_call(exprval.u.idref.disp, exprval.u.idref.id, ctx->parser->script->lcid, DISPATCH_METHOD,
1262                     &dp, flags & EXPR_NOVAL ? NULL : &var, ei, NULL/*FIXME*/);
1263             if(flags & EXPR_NOVAL)
1264                 V_VT(&var) = VT_EMPTY;
1265             break;
1266         default:
1267             FIXME("unimplemented type %d\n", V_VT(&func));
1268             hres = E_NOTIMPL;
1269         }
1270
1271         free_dp(&dp);
1272     }
1273
1274     exprval_release(&exprval);
1275     if(FAILED(hres))
1276         return hres;
1277
1278     TRACE("= %s\n", debugstr_variant(&var));
1279     ret->type = EXPRVAL_VARIANT;
1280     ret->u.var = var;
1281     return S_OK;
1282 }
1283
1284 HRESULT this_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1285 {
1286     TRACE("\n");
1287
1288     ret->type = EXPRVAL_VARIANT;
1289     V_VT(&ret->u.var) = VT_DISPATCH;
1290     V_DISPATCH(&ret->u.var) = ctx->this_obj;
1291     IDispatch_AddRef(ctx->this_obj);
1292     return S_OK;
1293 }
1294
1295 /* ECMA-262 3rd Edition    10.1.4 */
1296 HRESULT identifier_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1297 {
1298     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1299     BSTR identifier;
1300     HRESULT hres;
1301
1302     TRACE("\n");
1303
1304     identifier = SysAllocString(expr->identifier);
1305     if(!identifier)
1306         return E_OUTOFMEMORY;
1307
1308     hres = identifier_eval(ctx, identifier, flags, ret);
1309
1310     SysFreeString(identifier);
1311     return hres;
1312 }
1313
1314 /* ECMA-262 3rd Edition    7.8 */
1315 HRESULT literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1316 {
1317     literal_expression_t *expr = (literal_expression_t*)_expr;
1318     VARIANT var;
1319     HRESULT hres;
1320
1321     TRACE("\n");
1322
1323     hres = literal_to_var(expr->literal, &var);
1324     if(FAILED(hres))
1325         return hres;
1326
1327     ret->type = EXPRVAL_VARIANT;
1328     ret->u.var = var;
1329     return S_OK;
1330 }
1331
1332 /* ECMA-262 3rd Edition    11.1.4 */
1333 HRESULT array_literal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1334 {
1335     array_literal_expression_t *expr = (array_literal_expression_t*)_expr;
1336     DWORD length = 0, i = 0;
1337     array_element_t *elem;
1338     DispatchEx *array;
1339     exprval_t exprval;
1340     VARIANT val;
1341     HRESULT hres;
1342
1343     TRACE("\n");
1344
1345     for(elem = expr->element_list; elem; elem = elem->next)
1346         length += elem->elision+1;
1347     length += expr->length;
1348
1349     hres = create_array(ctx->parser->script, length, &array);
1350     if(FAILED(hres))
1351         return hres;
1352
1353     for(elem = expr->element_list; elem; elem = elem->next) {
1354         i += elem->elision;
1355
1356         hres = expr_eval(ctx, elem->expr, 0, ei, &exprval);
1357         if(FAILED(hres))
1358             break;
1359
1360         hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1361         exprval_release(&exprval);
1362         if(FAILED(hres))
1363             break;
1364
1365         hres = jsdisp_propput_idx(array, i, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1366         VariantClear(&val);
1367         if(FAILED(hres))
1368             break;
1369
1370         i++;
1371     }
1372
1373     if(FAILED(hres)) {
1374         jsdisp_release(array);
1375         return hres;
1376     }
1377
1378     ret->type = EXPRVAL_VARIANT;
1379     V_VT(&ret->u.var) = VT_DISPATCH;
1380     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(array);
1381     return S_OK;
1382 }
1383
1384 /* ECMA-262 3rd Edition    11.1.5 */
1385 HRESULT property_value_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1386 {
1387     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1388     VARIANT val, tmp;
1389     DispatchEx *obj;
1390     prop_val_t *iter;
1391     exprval_t exprval;
1392     BSTR name;
1393     HRESULT hres;
1394
1395     TRACE("\n");
1396
1397     hres = create_object(ctx->parser->script, NULL, &obj);
1398     if(FAILED(hres))
1399         return hres;
1400
1401     for(iter = expr->property_list; iter; iter = iter->next) {
1402         hres = literal_to_var(iter->name, &tmp);
1403         if(FAILED(hres))
1404             break;
1405
1406         hres = to_string(ctx->parser->script, &tmp, ei, &name);
1407         VariantClear(&tmp);
1408         if(FAILED(hres))
1409             break;
1410
1411         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1412         if(SUCCEEDED(hres)) {
1413             hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1414             exprval_release(&exprval);
1415             if(SUCCEEDED(hres)) {
1416                 hres = jsdisp_propput_name(obj, name, ctx->parser->script->lcid, &val, ei, NULL/*FIXME*/);
1417                 VariantClear(&val);
1418             }
1419         }
1420
1421         SysFreeString(name);
1422         if(FAILED(hres))
1423             break;
1424     }
1425
1426     if(FAILED(hres)) {
1427         jsdisp_release(obj);
1428         return hres;
1429     }
1430
1431     ret->type = EXPRVAL_VARIANT;
1432     V_VT(&ret->u.var) = VT_DISPATCH;
1433     V_DISPATCH(&ret->u.var) = (IDispatch*)_IDispatchEx_(obj);
1434     return S_OK;
1435 }
1436
1437 /* ECMA-262 3rd Edition    11.14 */
1438 HRESULT comma_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1439 {
1440     binary_expression_t *expr = (binary_expression_t*)_expr;
1441     VARIANT lval, rval;
1442     HRESULT hres;
1443
1444     TRACE("\n");
1445
1446     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
1447     if(FAILED(hres))
1448         return hres;
1449
1450     VariantClear(&lval);
1451
1452     ret->type = EXPRVAL_VARIANT;
1453     ret->u.var = rval;
1454     return S_OK;
1455 }
1456
1457 /* ECMA-262 3rd Edition    11.11 */
1458 HRESULT logical_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1459 {
1460     binary_expression_t *expr = (binary_expression_t*)_expr;
1461     exprval_t exprval;
1462     VARIANT_BOOL b;
1463     VARIANT val;
1464     HRESULT hres;
1465
1466     TRACE("\n");
1467
1468     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1469     if(FAILED(hres))
1470         return hres;
1471
1472     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1473     exprval_release(&exprval);
1474     if(FAILED(hres))
1475         return hres;
1476
1477     hres = to_boolean(&val, &b);
1478     if(SUCCEEDED(hres) && b) {
1479         ret->type = EXPRVAL_VARIANT;
1480         ret->u.var = val;
1481         return S_OK;
1482     }
1483
1484     VariantClear(&val);
1485     if(FAILED(hres))
1486         return hres;
1487
1488     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1489     if(FAILED(hres))
1490         return hres;
1491
1492     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1493     exprval_release(&exprval);
1494     if(FAILED(hres))
1495         return hres;
1496
1497     ret->type = EXPRVAL_VARIANT;
1498     ret->u.var = val;
1499     return S_OK;
1500 }
1501
1502 /* ECMA-262 3rd Edition    11.11 */
1503 HRESULT logical_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1504 {
1505     binary_expression_t *expr = (binary_expression_t*)_expr;
1506     exprval_t exprval;
1507     VARIANT_BOOL b;
1508     VARIANT val;
1509     HRESULT hres;
1510
1511     TRACE("\n");
1512
1513     hres = expr_eval(ctx, expr->expression1, 0, ei, &exprval);
1514     if(FAILED(hres))
1515         return hres;
1516
1517     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1518     exprval_release(&exprval);
1519     if(FAILED(hres))
1520         return hres;
1521
1522     hres = to_boolean(&val, &b);
1523     if(SUCCEEDED(hres) && !b) {
1524         ret->type = EXPRVAL_VARIANT;
1525         ret->u.var = val;
1526         return S_OK;
1527     }
1528
1529     VariantClear(&val);
1530     if(FAILED(hres))
1531         return hres;
1532
1533     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprval);
1534     if(FAILED(hres))
1535         return hres;
1536
1537     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1538     exprval_release(&exprval);
1539     if(FAILED(hres))
1540         return hres;
1541
1542     ret->type = EXPRVAL_VARIANT;
1543     ret->u.var = val;
1544     return S_OK;
1545 }
1546
1547 /* ECMA-262 3rd Edition    11.10 */
1548 static HRESULT bitor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1549 {
1550     INT li, ri;
1551     HRESULT hres;
1552
1553     hres = to_int32(ctx->parser->script, lval, ei, &li);
1554     if(FAILED(hres))
1555         return hres;
1556
1557     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1558     if(FAILED(hres))
1559         return hres;
1560
1561     V_VT(retv) = VT_I4;
1562     V_I4(retv) = li|ri;
1563     return S_OK;
1564 }
1565
1566 /* ECMA-262 3rd Edition    11.10 */
1567 HRESULT binary_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1568 {
1569     binary_expression_t *expr = (binary_expression_t*)_expr;
1570
1571     TRACE("\n");
1572
1573     return binary_expr_eval(ctx, expr, bitor_eval, ei, ret);
1574 }
1575
1576 /* ECMA-262 3rd Edition    11.10 */
1577 static HRESULT xor_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1578 {
1579     INT li, ri;
1580     HRESULT hres;
1581
1582     hres = to_int32(ctx->parser->script, lval, ei, &li);
1583     if(FAILED(hres))
1584         return hres;
1585
1586     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1587     if(FAILED(hres))
1588         return hres;
1589
1590     V_VT(retv) = VT_I4;
1591     V_I4(retv) = li^ri;
1592     return S_OK;
1593 }
1594
1595 /* ECMA-262 3rd Edition    11.10 */
1596 HRESULT binary_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1597 {
1598     binary_expression_t *expr = (binary_expression_t*)_expr;
1599
1600     TRACE("\n");
1601
1602     return binary_expr_eval(ctx, expr, xor_eval, ei, ret);
1603 }
1604
1605 /* ECMA-262 3rd Edition    11.10 */
1606 static HRESULT bitand_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1607 {
1608     INT li, ri;
1609     HRESULT hres;
1610
1611     hres = to_int32(ctx->parser->script, lval, ei, &li);
1612     if(FAILED(hres))
1613         return hres;
1614
1615     hres = to_int32(ctx->parser->script, rval, ei, &ri);
1616     if(FAILED(hres))
1617         return hres;
1618
1619     V_VT(retv) = VT_I4;
1620     V_I4(retv) = li&ri;
1621     return S_OK;
1622 }
1623
1624 /* ECMA-262 3rd Edition    11.10 */
1625 HRESULT binary_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1626 {
1627     binary_expression_t *expr = (binary_expression_t*)_expr;
1628
1629     TRACE("\n");
1630
1631     return binary_expr_eval(ctx, expr, bitand_eval, ei, ret);
1632 }
1633
1634 HRESULT instanceof_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1635 {
1636     FIXME("\n");
1637     return E_NOTIMPL;
1638 }
1639
1640 HRESULT in_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1641 {
1642     FIXME("\n");
1643     return E_NOTIMPL;
1644 }
1645
1646 /* ECMA-262 3rd Edition    11.6.1 */
1647 static HRESULT add_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1648 {
1649     VARIANT r, l;
1650     HRESULT hres;
1651
1652     hres = to_primitive(ctx->parser->script, lval, ei, &l);
1653     if(FAILED(hres))
1654         return hres;
1655
1656     hres = to_primitive(ctx->parser->script, rval, ei, &r);
1657     if(FAILED(hres)) {
1658         VariantClear(&l);
1659         return hres;
1660     }
1661
1662     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1663         BSTR lstr = NULL, rstr = NULL;
1664
1665         if(V_VT(&l) == VT_BSTR)
1666             lstr = V_BSTR(&l);
1667         else
1668             hres = to_string(ctx->parser->script, &l, ei, &lstr);
1669
1670         if(SUCCEEDED(hres)) {
1671             if(V_VT(&r) == VT_BSTR)
1672                 rstr = V_BSTR(&r);
1673             else
1674                 hres = to_string(ctx->parser->script, &r, ei, &rstr);
1675         }
1676
1677         if(SUCCEEDED(hres)) {
1678             int len1, len2;
1679
1680             len1 = SysStringLen(lstr);
1681             len2 = SysStringLen(rstr);
1682
1683             V_VT(retv) = VT_BSTR;
1684             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
1685             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
1686             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
1687         }
1688
1689         if(lstr && V_VT(&l) != VT_BSTR)
1690             SysFreeString(lstr);
1691         if(rstr && V_VT(&r) != VT_BSTR)
1692             SysFreeString(rstr);
1693     }else {
1694         VARIANT nl, nr;
1695
1696         hres = to_number(ctx->parser->script, &l, ei, &nl);
1697         if(SUCCEEDED(hres)) {
1698             hres = to_number(ctx->parser->script, &r, ei, &nr);
1699             if(SUCCEEDED(hres))
1700                 num_set_val(retv, num_val(&nl) + num_val(&nr));
1701         }
1702     }
1703
1704     VariantClear(&r);
1705     VariantClear(&l);
1706     return hres;
1707 }
1708
1709 /* ECMA-262 3rd Edition    11.6.1 */
1710 HRESULT add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1711 {
1712     binary_expression_t *expr = (binary_expression_t*)_expr;
1713
1714     TRACE("\n");
1715
1716     return binary_expr_eval(ctx, expr, add_eval, ei, ret);
1717 }
1718
1719 /* ECMA-262 3rd Edition    11.6.2 */
1720 static HRESULT sub_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1721 {
1722     VARIANT lnum, rnum;
1723     HRESULT hres;
1724
1725     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1726     if(FAILED(hres))
1727         return hres;
1728
1729     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1730     if(FAILED(hres))
1731         return hres;
1732
1733     num_set_val(retv, num_val(&lnum) - num_val(&rnum));
1734     return S_OK;
1735 }
1736
1737 /* ECMA-262 3rd Edition    11.6.2 */
1738 HRESULT sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1739 {
1740     binary_expression_t *expr = (binary_expression_t*)_expr;
1741
1742     TRACE("\n");
1743
1744     return binary_expr_eval(ctx, expr, sub_eval, ei, ret);
1745 }
1746
1747 /* ECMA-262 3rd Edition    11.5.1 */
1748 static HRESULT mul_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1749 {
1750     VARIANT lnum, rnum;
1751     HRESULT hres;
1752
1753     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1754     if(FAILED(hres))
1755         return hres;
1756
1757     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1758     if(FAILED(hres))
1759         return hres;
1760
1761     num_set_val(retv, num_val(&lnum) * num_val(&rnum));
1762     return S_OK;
1763 }
1764
1765 /* ECMA-262 3rd Edition    11.5.1 */
1766 HRESULT mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1767 {
1768     binary_expression_t *expr = (binary_expression_t*)_expr;
1769
1770     TRACE("\n");
1771
1772     return binary_expr_eval(ctx, expr, mul_eval, ei, ret);
1773 }
1774
1775 /* ECMA-262 3rd Edition    11.5.2 */
1776 static HRESULT div_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1777 {
1778     VARIANT lnum, rnum;
1779     HRESULT hres;
1780
1781     hres = to_number(ctx->parser->script, lval, ei, &lnum);
1782     if(FAILED(hres))
1783         return hres;
1784
1785     hres = to_number(ctx->parser->script, rval, ei, &rnum);
1786     if(FAILED(hres))
1787         return hres;
1788
1789     num_set_val(retv, num_val(&lnum) / num_val(&rnum));
1790     return S_OK;
1791 }
1792
1793 /* ECMA-262 3rd Edition    11.5.2 */
1794 HRESULT div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1795 {
1796     binary_expression_t *expr = (binary_expression_t*)_expr;
1797
1798     TRACE("\n");
1799
1800     return binary_expr_eval(ctx, expr, div_eval, ei, ret);
1801 }
1802
1803 HRESULT mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1804 {
1805     FIXME("\n");
1806     return E_NOTIMPL;
1807 }
1808
1809 HRESULT delete_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1810 {
1811     FIXME("\n");
1812     return E_NOTIMPL;
1813 }
1814
1815 HRESULT void_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1816 {
1817     FIXME("\n");
1818     return E_NOTIMPL;
1819 }
1820
1821 HRESULT typeof_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1822 {
1823     unary_expression_t *expr = (unary_expression_t*)_expr;
1824     const WCHAR *str;
1825     exprval_t exprval;
1826     VARIANT val;
1827     HRESULT hres;
1828
1829     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
1830     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
1831     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
1832     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
1833     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
1834     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
1835
1836     TRACE("\n");
1837
1838     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1839     if(FAILED(hres))
1840         return hres;
1841
1842     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1843     exprval_release(&exprval);
1844     if(FAILED(hres))
1845         return hres;
1846
1847     switch(V_VT(&val)) {
1848     case VT_EMPTY:
1849         str = undefinedW;
1850         break;
1851     case VT_NULL:
1852         str = objectW;
1853         break;
1854     case VT_BOOL:
1855         str = booleanW;
1856         break;
1857     case VT_I4:
1858     case VT_R8:
1859         str = numberW;
1860         break;
1861     case VT_BSTR:
1862         str = stringW;
1863         break;
1864     case VT_DISPATCH: {
1865         DispatchEx *dispex;
1866
1867         dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val));
1868         if(dispex) {
1869             str = dispex->builtin_info->class == JSCLASS_FUNCTION ? functionW : objectW;
1870             IDispatchEx_Release(_IDispatchEx_(dispex));
1871         }else {
1872             str = objectW;
1873         }
1874         break;
1875     }
1876     default:
1877         FIXME("unhandled vt %d\n", V_VT(&val));
1878         hres = E_NOTIMPL;
1879     }
1880
1881     VariantClear(&val);
1882     if(FAILED(hres))
1883         return hres;
1884
1885     ret->type = EXPRVAL_VARIANT;
1886     V_VT(&ret->u.var) = VT_BSTR;
1887     V_BSTR(&ret->u.var) = SysAllocString(str);
1888     return S_OK;
1889 }
1890
1891 /* ECMA-262 3rd Edition    11.4.7 */
1892 HRESULT minus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1893 {
1894     unary_expression_t *expr = (unary_expression_t*)_expr;
1895     exprval_t exprval;
1896     VARIANT val, num;
1897     HRESULT hres;
1898
1899     TRACE("\n");
1900
1901     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
1902     if(FAILED(hres))
1903         return hres;
1904
1905     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1906     exprval_release(&exprval);
1907     if(FAILED(hres))
1908         return hres;
1909
1910     hres = to_number(ctx->parser->script, &val, ei, &num);
1911     VariantClear(&val);
1912     if(FAILED(hres))
1913         return hres;
1914
1915     ret->type = EXPRVAL_VARIANT;
1916     num_set_val(&ret->u.var, -num_val(&num));
1917     return S_OK;
1918 }
1919
1920 /* ECMA-262 3rd Edition    11.4.6 */
1921 HRESULT plus_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1922 {
1923     unary_expression_t *expr = (unary_expression_t*)_expr;
1924     exprval_t exprval;
1925     VARIANT val, num;
1926     HRESULT hres;
1927
1928     TRACE("\n");
1929
1930     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1931     if(FAILED(hres))
1932         return hres;
1933
1934     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
1935     exprval_release(&exprval);
1936     if(FAILED(hres))
1937         return hres;
1938
1939     hres = to_number(ctx->parser->script, &val, ei, &num);
1940     if(FAILED(hres))
1941         return hres;
1942
1943     ret->type = EXPRVAL_VARIANT;
1944     ret->u.var = num;
1945     return S_OK;
1946 }
1947
1948 /* ECMA-262 3rd Edition    11.3.1 */
1949 HRESULT post_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1950 {
1951     unary_expression_t *expr = (unary_expression_t*)_expr;
1952     VARIANT val, num;
1953     exprval_t exprval;
1954     HRESULT hres;
1955
1956     TRACE("\n");
1957
1958     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1959     if(FAILED(hres))
1960         return hres;
1961
1962     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1963     if(SUCCEEDED(hres)) {
1964         hres = to_number(ctx->parser->script, &val, ei, &num);
1965         VariantClear(&val);
1966     }
1967
1968     if(SUCCEEDED(hres)) {
1969         VARIANT inc;
1970         num_set_val(&inc, num_val(&num)+1.0);
1971         hres = put_value(ctx->parser->script, &exprval, &inc, ei);
1972     }
1973
1974     exprval_release(&exprval);
1975     if(FAILED(hres))
1976         return hres;
1977
1978     ret->type = EXPRVAL_VARIANT;
1979     ret->u.var = num;
1980     return S_OK;
1981 }
1982
1983 /* ECMA-262 3rd Edition    11.3.2 */
1984 HRESULT post_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1985 {
1986     unary_expression_t *expr = (unary_expression_t*)_expr;
1987     VARIANT val, num;
1988     exprval_t exprval;
1989     HRESULT hres;
1990
1991     TRACE("\n");
1992
1993     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
1994     if(FAILED(hres))
1995         return hres;
1996
1997     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
1998     if(SUCCEEDED(hres)) {
1999         hres = to_number(ctx->parser->script, &val, ei, &num);
2000         VariantClear(&val);
2001     }
2002
2003     if(SUCCEEDED(hres)) {
2004         VARIANT dec;
2005         num_set_val(&dec, num_val(&num)-1.0);
2006         hres = put_value(ctx->parser->script, &exprval, &dec, ei);
2007     }
2008
2009     exprval_release(&exprval);
2010     if(FAILED(hres))
2011         return hres;
2012
2013     ret->type = EXPRVAL_VARIANT;
2014     ret->u.var = num;
2015     return S_OK;
2016 }
2017
2018 /* ECMA-262 3rd Edition    11.4.4 */
2019 HRESULT pre_increment_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2020 {
2021     unary_expression_t *expr = (unary_expression_t*)_expr;
2022     VARIANT val, num;
2023     exprval_t exprval;
2024     HRESULT hres;
2025
2026     TRACE("\n");
2027
2028     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2029     if(FAILED(hres))
2030         return hres;
2031
2032     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2033     if(SUCCEEDED(hres)) {
2034         hres = to_number(ctx->parser->script, &val, ei, &num);
2035         VariantClear(&val);
2036     }
2037
2038     if(SUCCEEDED(hres)) {
2039         num_set_val(&val, num_val(&num)+1.0);
2040         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2041     }
2042
2043     exprval_release(&exprval);
2044     if(FAILED(hres))
2045         return hres;
2046
2047     ret->type = EXPRVAL_VARIANT;
2048     ret->u.var = val;
2049     return S_OK;
2050 }
2051
2052 /* ECMA-262 3rd Edition    11.4.5 */
2053 HRESULT pre_decrement_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2054 {
2055     unary_expression_t *expr = (unary_expression_t*)_expr;
2056     VARIANT val, num;
2057     exprval_t exprval;
2058     HRESULT hres;
2059
2060     TRACE("\n");
2061
2062     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2063     if(FAILED(hres))
2064         return hres;
2065
2066     hres = exprval_value(ctx->parser->script, &exprval, ei, &val);
2067     if(SUCCEEDED(hres)) {
2068         hres = to_number(ctx->parser->script, &val, ei, &num);
2069         VariantClear(&val);
2070     }
2071
2072     if(SUCCEEDED(hres)) {
2073         num_set_val(&val, num_val(&num)-1.0);
2074         hres = put_value(ctx->parser->script, &exprval, &val, ei);
2075     }
2076
2077     exprval_release(&exprval);
2078     if(FAILED(hres))
2079         return hres;
2080
2081     ret->type = EXPRVAL_VARIANT;
2082     ret->u.var = val;
2083     return S_OK;
2084 }
2085
2086 /* ECMA-262 3rd Edition    11.9.3 */
2087 static HRESULT equal_values(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2088 {
2089     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2090        return equal2_values(lval, rval, ret);
2091
2092     /* FIXME: NULL disps should be handled in more general way */
2093     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2094         VARIANT v;
2095         V_VT(&v) = VT_NULL;
2096         return equal_values(ctx, &v, rval, ei, ret);
2097     }
2098
2099     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2100         VARIANT v;
2101         V_VT(&v) = VT_NULL;
2102         return equal_values(ctx, lval, &v, ei, ret);
2103     }
2104
2105     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2106        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2107         *ret = TRUE;
2108         return S_OK;
2109     }
2110
2111     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2112         VARIANT v;
2113         HRESULT hres;
2114
2115         hres = to_number(ctx->parser->script, lval, ei, &v);
2116         if(FAILED(hres))
2117             return hres;
2118
2119         return equal_values(ctx, &v, rval, ei, ret);
2120     }
2121
2122     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2123         VARIANT v;
2124         HRESULT hres;
2125
2126         hres = to_number(ctx->parser->script, rval, ei, &v);
2127         if(FAILED(hres))
2128             return hres;
2129
2130         return equal_values(ctx, lval, &v, ei, ret);
2131     }
2132
2133     if(V_VT(rval) == VT_BOOL) {
2134         VARIANT v;
2135
2136         V_VT(&v) = VT_I4;
2137         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2138         return equal_values(ctx, lval, &v, ei, ret);
2139     }
2140
2141     if(V_VT(lval) == VT_BOOL) {
2142         VARIANT v;
2143
2144         V_VT(&v) = VT_I4;
2145         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2146         return equal_values(ctx, &v, rval, ei, ret);
2147     }
2148
2149
2150     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2151         VARIANT v;
2152         HRESULT hres;
2153
2154         hres = to_primitive(ctx->parser->script, rval, ei, &v);
2155         if(FAILED(hres))
2156             return hres;
2157
2158         hres = equal_values(ctx, lval, &v, ei, ret);
2159
2160         VariantClear(&v);
2161         return hres;
2162     }
2163
2164
2165     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2166         VARIANT v;
2167         HRESULT hres;
2168
2169         hres = to_primitive(ctx->parser->script, lval, ei, &v);
2170         if(FAILED(hres))
2171             return hres;
2172
2173         hres = equal_values(ctx, &v, rval, ei, ret);
2174
2175         VariantClear(&v);
2176         return hres;
2177     }
2178
2179
2180     *ret = FALSE;
2181     return S_OK;
2182 }
2183
2184 /* ECMA-262 3rd Edition    11.9.1 */
2185 HRESULT equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2186 {
2187     binary_expression_t *expr = (binary_expression_t*)_expr;
2188     VARIANT rval, lval;
2189     BOOL b;
2190     HRESULT hres;
2191
2192     TRACE("\n");
2193
2194     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2195     if(FAILED(hres))
2196         return hres;
2197
2198     hres = equal_values(ctx, &rval, &lval, ei, &b);
2199     if(FAILED(hres))
2200         return hres;
2201
2202     return return_bool(ret, b);
2203 }
2204
2205 /* ECMA-262 3rd Edition    11.9.4 */
2206 HRESULT equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2207 {
2208     binary_expression_t *expr = (binary_expression_t*)_expr;
2209     VARIANT rval, lval;
2210     BOOL b;
2211     HRESULT hres;
2212
2213     TRACE("\n");
2214
2215     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2216     if(FAILED(hres))
2217         return hres;
2218
2219     hres = equal2_values(&rval, &lval, &b);
2220     if(FAILED(hres))
2221         return hres;
2222
2223     return return_bool(ret, b);
2224 }
2225
2226 /* ECMA-262 3rd Edition    11.9.2 */
2227 HRESULT not_equal_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2228 {
2229     binary_expression_t *expr = (binary_expression_t*)_expr;
2230     VARIANT rval, lval;
2231     BOOL b;
2232     HRESULT hres;
2233
2234     TRACE("\n");
2235
2236     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2237     if(FAILED(hres))
2238         return hres;
2239
2240     hres = equal_values(ctx, &lval, &rval, ei, &b);
2241     if(FAILED(hres))
2242         return hres;
2243
2244     return return_bool(ret, !b);
2245 }
2246
2247 /* ECMA-262 3rd Edition    11.9.5 */
2248 HRESULT not_equal2_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2249 {
2250     binary_expression_t *expr = (binary_expression_t*)_expr;
2251     VARIANT rval, lval;
2252     BOOL b;
2253     HRESULT hres;
2254
2255     TRACE("\n");
2256
2257     hres = get_binary_expr_values(ctx, expr, ei, &rval, &lval);
2258     if(FAILED(hres))
2259         return hres;
2260
2261     hres = equal2_values(&rval, &lval, &b);
2262     if(FAILED(hres))
2263         return hres;
2264
2265     return return_bool(ret, !b);
2266 }
2267
2268 /* ECMA-262 3rd Edition    11.8.5 */
2269 static HRESULT less_eval(exec_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2270 {
2271     VARIANT l, r, ln, rn;
2272     HRESULT hres;
2273
2274     hres = to_primitive(ctx->parser->script, lval, ei, &l);
2275     if(FAILED(hres))
2276         return hres;
2277
2278     hres = to_primitive(ctx->parser->script, rval, ei, &r);
2279     if(FAILED(hres)) {
2280         VariantClear(&l);
2281         return hres;
2282     }
2283
2284     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2285         *ret = strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0;
2286         SysFreeString(V_BSTR(&l));
2287         SysFreeString(V_BSTR(&r));
2288         return S_OK;
2289     }
2290
2291     hres = to_number(ctx->parser->script, &l, ei, &ln);
2292     VariantClear(&l);
2293     if(SUCCEEDED(hres))
2294         hres = to_number(ctx->parser->script, &r, ei, &rn);
2295     VariantClear(&r);
2296     if(FAILED(hres))
2297         return hres;
2298
2299     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4)
2300         *ret = V_I4(&ln) < V_I4(&rn);
2301     else
2302         *ret = num_val(&ln) < num_val(&rn);
2303
2304     return S_OK;
2305 }
2306
2307 /* ECMA-262 3rd Edition    11.8.1 */
2308 HRESULT less_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2309 {
2310     binary_expression_t *expr = (binary_expression_t*)_expr;
2311     VARIANT rval, lval;
2312     BOOL b;
2313     HRESULT hres;
2314
2315     TRACE("\n");
2316
2317     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2318     if(FAILED(hres))
2319         return hres;
2320
2321     hres = less_eval(ctx, &lval, &rval, ei, &b);
2322     VariantClear(&lval);
2323     VariantClear(&rval);
2324     if(FAILED(hres))
2325         return hres;
2326
2327     return return_bool(ret, b);
2328 }
2329
2330 /* ECMA-262 3rd Edition    11.8.3 */
2331 HRESULT lesseq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2332 {
2333     binary_expression_t *expr = (binary_expression_t*)_expr;
2334     VARIANT rval, lval;
2335     BOOL b;
2336     HRESULT hres;
2337
2338     TRACE("\n");
2339
2340     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2341     if(FAILED(hres))
2342         return hres;
2343
2344     hres = less_eval(ctx, &rval, &lval, ei, &b);
2345     VariantClear(&lval);
2346     VariantClear(&rval);
2347     if(FAILED(hres))
2348         return hres;
2349
2350     return return_bool(ret, !b);
2351 }
2352
2353 /* ECMA-262 3rd Edition    11.8.2 */
2354 HRESULT greater_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2355 {
2356     binary_expression_t *expr = (binary_expression_t*)_expr;
2357     VARIANT rval, lval;
2358     BOOL b;
2359     HRESULT hres;
2360
2361     TRACE("\n");
2362
2363     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2364     if(FAILED(hres))
2365         return hres;
2366
2367     hres = less_eval(ctx, &rval, &lval, ei, &b);
2368     VariantClear(&lval);
2369     VariantClear(&rval);
2370     if(FAILED(hres))
2371         return hres;
2372
2373     return return_bool(ret, b);
2374 }
2375
2376 /* ECMA-262 3rd Edition    11.8.4 */
2377 HRESULT greatereq_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2378 {
2379     binary_expression_t *expr = (binary_expression_t*)_expr;
2380     VARIANT rval, lval;
2381     BOOL b;
2382     HRESULT hres;
2383
2384     TRACE("\n");
2385
2386     hres = get_binary_expr_values(ctx, expr, ei, &lval, &rval);
2387     if(FAILED(hres))
2388         return hres;
2389
2390     hres = less_eval(ctx, &lval, &rval, ei, &b);
2391     VariantClear(&lval);
2392     VariantClear(&rval);
2393     if(FAILED(hres))
2394         return hres;
2395
2396     return return_bool(ret, !b);
2397 }
2398
2399 /* ECMA-262 3rd Edition    11.4.8 */
2400 HRESULT binary_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2401 {
2402     unary_expression_t *expr = (unary_expression_t*)_expr;
2403     exprval_t exprval;
2404     VARIANT val;
2405     INT i;
2406     HRESULT hres;
2407
2408     TRACE("\n");
2409
2410     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2411     if(FAILED(hres))
2412         return hres;
2413
2414     hres = exprval_to_value(ctx->parser->script, &exprval, ei, &val);
2415     exprval_release(&exprval);
2416     if(FAILED(hres))
2417         return hres;
2418
2419     hres = to_int32(ctx->parser->script, &val, ei, &i);
2420     if(FAILED(hres))
2421         return hres;
2422
2423     ret->type = EXPRVAL_VARIANT;
2424     V_VT(&ret->u.var) = VT_I4;
2425     V_I4(&ret->u.var) = ~i;
2426     return S_OK;
2427 }
2428
2429 /* ECMA-262 3rd Edition    11.4.9 */
2430 HRESULT logical_negation_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2431 {
2432     unary_expression_t *expr = (unary_expression_t*)_expr;
2433     exprval_t exprval;
2434     VARIANT_BOOL b;
2435     HRESULT hres;
2436
2437     TRACE("\n");
2438
2439     hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2440     if(FAILED(hres))
2441         return hres;
2442
2443     hres = exprval_to_boolean(ctx->parser->script, &exprval, ei, &b);
2444     exprval_release(&exprval);
2445     if(FAILED(hres))
2446         return hres;
2447
2448     return return_bool(ret, !b);
2449 }
2450
2451 HRESULT left_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2452 {
2453     FIXME("\n");
2454     return E_NOTIMPL;
2455 }
2456
2457 HRESULT right_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2458 {
2459     FIXME("\n");
2460     return E_NOTIMPL;
2461 }
2462
2463 HRESULT right2_shift_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2464 {
2465     FIXME("\n");
2466     return E_NOTIMPL;
2467 }
2468
2469 /* ECMA-262 3rd Edition    11.13.1 */
2470 HRESULT assign_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2471 {
2472     binary_expression_t *expr = (binary_expression_t*)_expr;
2473     exprval_t exprval, exprvalr;
2474     VARIANT rval;
2475     HRESULT hres;
2476
2477     TRACE("\n");
2478
2479     hres = expr_eval(ctx, expr->expression1, EXPR_NEWREF, ei, &exprval);
2480     if(FAILED(hres))
2481         return hres;
2482
2483     hres = expr_eval(ctx, expr->expression2, 0, ei, &exprvalr);
2484     if(SUCCEEDED(hres)) {
2485         hres = exprval_to_value(ctx->parser->script, &exprvalr, ei, &rval);
2486         exprval_release(&exprvalr);
2487     }
2488
2489     if(SUCCEEDED(hres))
2490         hres = put_value(ctx->parser->script, &exprval, &rval, ei);
2491
2492     exprval_release(&exprval);
2493     if(FAILED(hres)) {
2494         VariantClear(&rval);
2495         return hres;
2496     }
2497
2498     ret->type = EXPRVAL_VARIANT;
2499     ret->u.var = rval;
2500     return S_OK;
2501 }
2502
2503 HRESULT assign_lshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2504 {
2505     FIXME("\n");
2506     return E_NOTIMPL;
2507 }
2508
2509 HRESULT assign_rshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2510 {
2511     FIXME("\n");
2512     return E_NOTIMPL;
2513 }
2514
2515 HRESULT assign_rrshift_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2516 {
2517     FIXME("\n");
2518     return E_NOTIMPL;
2519 }
2520
2521 /* ECMA-262 3rd Edition    11.13.2 */
2522 HRESULT assign_add_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2523 {
2524     binary_expression_t *expr = (binary_expression_t*)_expr;
2525
2526     TRACE("\n");
2527
2528     return assign_oper_eval(ctx, expr->expression1, expr->expression2, add_eval, ei, ret);
2529 }
2530
2531 /* ECMA-262 3rd Edition    11.13.2 */
2532 HRESULT assign_sub_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2533 {
2534     binary_expression_t *expr = (binary_expression_t*)_expr;
2535
2536     TRACE("\n");
2537
2538     return assign_oper_eval(ctx, expr->expression1, expr->expression2, sub_eval, ei, ret);
2539 }
2540
2541 /* ECMA-262 3rd Edition    11.13.2 */
2542 HRESULT assign_mul_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2543 {
2544     binary_expression_t *expr = (binary_expression_t*)_expr;
2545
2546     TRACE("\n");
2547
2548     return assign_oper_eval(ctx, expr->expression1, expr->expression2, mul_eval, ei, ret);
2549 }
2550
2551 /* ECMA-262 3rd Edition    11.13.2 */
2552 HRESULT assign_div_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2553 {
2554     binary_expression_t *expr = (binary_expression_t*)_expr;
2555
2556     TRACE("\n");
2557
2558     return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
2559 }
2560
2561 HRESULT assign_mod_expression_eval(exec_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2562 {
2563     FIXME("\n");
2564     return E_NOTIMPL;
2565 }
2566
2567 /* ECMA-262 3rd Edition    11.13.2 */
2568 HRESULT assign_and_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2569 {
2570     binary_expression_t *expr = (binary_expression_t*)_expr;
2571
2572     TRACE("\n");
2573
2574     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
2575 }
2576
2577 /* ECMA-262 3rd Edition    11.13.2 */
2578 HRESULT assign_or_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2579 {
2580     binary_expression_t *expr = (binary_expression_t*)_expr;
2581
2582     TRACE("\n");
2583
2584     return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
2585 }
2586
2587 /* ECMA-262 3rd Edition    11.13.2 */
2588 HRESULT assign_xor_expression_eval(exec_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2589 {
2590     binary_expression_t *expr = (binary_expression_t*)_expr;
2591
2592     TRACE("\n");
2593
2594     return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
2595 }