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