git.oblomov.eu Git - wine/blob - dlls/jscript/engine.c

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