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