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