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