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 static HRESULT interp_var_set(exec_ctx_t *ctx)
 692 {
 693     const BSTR name = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
 694     VARIANT *v;
 695     HRESULT hres;
 696
 697     TRACE("%s\n", debugstr_w(name));
 698
 699     v = stack_pop(ctx);
 700     hres = jsdisp_propput_name(ctx->var_disp, name, v, ctx->ei, NULL/*FIXME*/);
 701     VariantClear(v);
 702     return hres;
 703 }
 704
 705 /* ECMA-262 3rd Edition    12.6.2 */
 706 HRESULT while_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 707 {
 708     while_statement_t *stat = (while_statement_t*)_stat;
 709     VARIANT val, tmp;
 710     VARIANT_BOOL b;
 711     BOOL test_expr;
 712     HRESULT hres;
 713
 714     TRACE("\n");
 715
 716     V_VT(&val) = VT_EMPTY;
 717     test_expr = !stat->do_while;
 718
 719     while(1) {
 720         if(test_expr) {
 721             hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &tmp);
 722             if(FAILED(hres))
 723                 break;
 724
 725             hres = to_boolean(&tmp, &b);
 726             VariantClear(&tmp);
 727             if(FAILED(hres) || !b)
 728                 break;
 729         }else {
 730             test_expr = TRUE;
 731         }
 732
 733         hres = stat_eval(ctx, stat->statement, rt, &tmp);
 734         if(FAILED(hres))
 735             break;
 736
 737         VariantClear(&val);
 738         val = tmp;
 739
 740         if(rt->type == RT_CONTINUE)
 741             rt->type = RT_NORMAL;
 742         if(rt->type != RT_NORMAL)
 743             break;
 744     }
 745
 746     if(FAILED(hres)) {
 747         VariantClear(&val);
 748         return hres;
 749     }
 750
 751     if(rt->type == RT_BREAK)
 752         rt->type = RT_NORMAL;
 753
 754     *ret = val;
 755     return S_OK;
 756 }
 757
 758 /* ECMA-262 3rd Edition    12.6.3 */
 759 HRESULT for_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 760 {
 761     for_statement_t *stat = (for_statement_t*)_stat;
 762     VARIANT val, tmp, retv;
 763     VARIANT_BOOL b;
 764     HRESULT hres;
 765
 766     TRACE("\n");
 767
 768     if(stat->variable_list) {
 769         hres = variable_list_eval(ctx, stat->variable_list, &rt->ei);
 770         if(FAILED(hres))
 771             return hres;
 772     }else if(stat->begin_expr) {
 773         hres = expr_eval(ctx, stat->begin_expr, 0, &rt->ei, &val);
 774         if(FAILED(hres))
 775             return hres;
 776
 777         VariantClear(&val);
 778     }
 779
 780     V_VT(&retv) = VT_EMPTY;
 781
 782     while(1) {
 783         if(stat->expr) {
 784             hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &tmp);
 785             if(FAILED(hres))
 786                 break;
 787
 788             hres = to_boolean(&tmp, &b);
 789             VariantClear(&tmp);
 790             if(FAILED(hres) || !b)
 791                 break;
 792         }
 793
 794         hres = stat_eval(ctx, stat->statement, rt, &tmp);
 795         if(FAILED(hres))
 796             break;
 797
 798         VariantClear(&retv);
 799         retv = tmp;
 800
 801         if(rt->type == RT_CONTINUE)
 802             rt->type = RT_NORMAL;
 803         else if(rt->type != RT_NORMAL)
 804             break;
 805
 806         if(stat->end_expr) {
 807             hres = expr_eval(ctx, stat->end_expr, 0, &rt->ei, &val);
 808             if(FAILED(hres))
 809                 break;
 810
 811             VariantClear(&val);
 812         }
 813     }
 814
 815     if(FAILED(hres)) {
 816         VariantClear(&retv);
 817         return hres;
 818     }
 819
 820     if(rt->type == RT_BREAK)
 821         rt->type = RT_NORMAL;
 822
 823     *ret = retv;
 824     return S_OK;
 825 }
 826
 827 static HRESULT array_expression_eval(script_ctx_t*,expression_t*,jsexcept_t*,exprval_t*);
 828 static HRESULT member_expression_eval(script_ctx_t*,expression_t*,jsexcept_t*,exprval_t*);
 829 static HRESULT identifier_expression_eval(script_ctx_t*,expression_t*,jsexcept_t*,exprval_t*);
 830
 831 /* ECMA-262 3rd Edition    12.6.4 */
 832 HRESULT forin_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 833 {
 834     forin_statement_t *stat = (forin_statement_t*)_stat;
 835     VARIANT val, name, retv, tmp;
 836     DISPID id = DISPID_STARTENUM;
 837     BSTR str, identifier = NULL;
 838     IDispatchEx *in_obj;
 839     exprval_t exprval;
 840     HRESULT hres;
 841
 842     TRACE("\n");
 843
 844     if(stat->variable) {
 845         hres = variable_list_eval(ctx, stat->variable, &rt->ei);
 846         if(FAILED(hres))
 847             return hres;
 848     }
 849
 850     hres = expr_eval(ctx, stat->in_expr, 0, &rt->ei, &val);
 851     if(FAILED(hres))
 852         return hres;
 853
 854     if(V_VT(&val) != VT_DISPATCH) {
 855         TRACE("in vt %d\n", V_VT(&val));
 856         VariantClear(&val);
 857         V_VT(ret) = VT_EMPTY;
 858         return S_OK;
 859     }
 860
 861     hres = IDispatch_QueryInterface(V_DISPATCH(&val), &IID_IDispatchEx, (void**)&in_obj);
 862     IDispatch_Release(V_DISPATCH(&val));
 863     if(FAILED(hres)) {
 864         TRACE("Object doesn't support IDispatchEx\n");
 865         V_VT(ret) = VT_EMPTY;
 866         return S_OK;
 867     }
 868
 869     V_VT(&retv) = VT_EMPTY;
 870
 871     if(stat->variable)
 872         identifier = SysAllocString(stat->variable->identifier);
 873
 874     while(1) {
 875         hres = IDispatchEx_GetNextDispID(in_obj, fdexEnumDefault, id, &id);
 876         if(FAILED(hres) || hres == S_FALSE)
 877             break;
 878
 879         hres = IDispatchEx_GetMemberName(in_obj, id, &str);
 880         if(FAILED(hres))
 881             break;
 882
 883         TRACE("iter %s\n", debugstr_w(str));
 884
 885         if(stat->variable) {
 886             hres = identifier_eval(ctx, identifier, 0, NULL, &exprval);
 887         }else {
 888             switch(stat->expr->type) {
 889             case EXPR_ARRAY:
 890                 hres = array_expression_eval(ctx, stat->expr, &rt->ei, &exprval);
 891                 break;
 892             case EXPR_IDENT:
 893                 hres = identifier_expression_eval(ctx, stat->expr, &rt->ei, &exprval);
 894                 break;
 895             case EXPR_MEMBER:
 896                 hres = member_expression_eval(ctx, stat->expr, &rt->ei, &exprval);
 897                 break;
 898             default:
 899                 hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &tmp);
 900                 if(FAILED(hres))
 901                     break;
 902
 903                 VariantClear(&tmp);
 904                 hres = throw_reference_error(ctx, &rt->ei, JS_E_ILLEGAL_ASSIGN, NULL);
 905                 break;
 906             }
 907         }
 908         if(SUCCEEDED(hres)) {
 909             V_VT(&name) = VT_BSTR;
 910             V_BSTR(&name) = str;
 911             hres = put_value(ctx, &exprval, &name, &rt->ei);
 912             exprval_release(&exprval);
 913         }
 914         SysFreeString(str);
 915         if(FAILED(hres))
 916             break;
 917
 918         hres = stat_eval(ctx, stat->statement, rt, &tmp);
 919         if(FAILED(hres))
 920             break;
 921
 922         VariantClear(&retv);
 923         retv = tmp;
 924
 925         if(rt->type == RT_CONTINUE)
 926             rt->type = RT_NORMAL;
 927         else if(rt->type != RT_NORMAL)
 928             break;
 929     }
 930
 931     SysFreeString(identifier);
 932     IDispatchEx_Release(in_obj);
 933     if(FAILED(hres)) {
 934         VariantClear(&retv);
 935         return hres;
 936     }
 937
 938     if(rt->type == RT_BREAK)
 939         rt->type = RT_NORMAL;
 940
 941     *ret = retv;
 942     return S_OK;
 943 }
 944
 945 /* ECMA-262 3rd Edition    12.7 */
 946 HRESULT continue_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 947 {
 948     branch_statement_t *stat = (branch_statement_t*)_stat;
 949
 950     TRACE("\n");
 951
 952     if(stat->identifier) {
 953         FIXME("indentifier not implemented\n");
 954         return E_NOTIMPL;
 955     }
 956
 957     rt->type = RT_CONTINUE;
 958     V_VT(ret) = VT_EMPTY;
 959     return S_OK;
 960 }
 961
 962 /* ECMA-262 3rd Edition    12.8 */
 963 HRESULT break_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 964 {
 965     branch_statement_t *stat = (branch_statement_t*)_stat;
 966
 967     TRACE("\n");
 968
 969     if(stat->identifier) {
 970         FIXME("indentifier not implemented\n");
 971         return E_NOTIMPL;
 972     }
 973
 974     rt->type = RT_BREAK;
 975     V_VT(ret) = VT_EMPTY;
 976     return S_OK;
 977 }
 978
 979 /* ECMA-262 3rd Edition    12.9 */
 980 HRESULT return_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
 981 {
 982     expression_statement_t *stat = (expression_statement_t*)_stat;
 983     HRESULT hres;
 984
 985     TRACE("\n");
 986
 987     if(stat->expr) {
 988         hres = expr_eval(ctx, stat->expr, 0, &rt->ei, ret);
 989         if(FAILED(hres))
 990             return hres;
 991     }else {
 992         V_VT(ret) = VT_EMPTY;
 993     }
 994
 995     TRACE("= %s\n", debugstr_variant(ret));
 996     rt->type = RT_RETURN;
 997     return S_OK;
 998 }
 999
1000 /* ECMA-262 3rd Edition    12.10 */
1001 HRESULT with_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1002 {
1003     with_statement_t *stat = (with_statement_t*)_stat;
1004     IDispatch *disp;
1005     jsdisp_t *obj;
1006     VARIANT val;
1007     HRESULT hres;
1008
1009     TRACE("\n");
1010
1011     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &val);
1012     if(FAILED(hres))
1013         return hres;
1014
1015     hres = to_object(ctx, &val, &disp);
1016     VariantClear(&val);
1017     if(FAILED(hres))
1018         return hres;
1019
1020     obj = iface_to_jsdisp((IUnknown*)disp);
1021     IDispatch_Release(disp);
1022     if(!obj) {
1023         FIXME("disp id not jsdisp\n");
1024         return E_NOTIMPL;
1025     }
1026
1027     hres = scope_push(ctx->exec_ctx->scope_chain, obj, &ctx->exec_ctx->scope_chain);
1028     jsdisp_release(obj);
1029     if(FAILED(hres))
1030         return hres;
1031
1032     hres = stat_eval(ctx, stat->statement, rt, ret);
1033
1034     scope_pop(&ctx->exec_ctx->scope_chain);
1035     return hres;
1036 }
1037
1038 /* ECMA-262 3rd Edition    12.12 */
1039 HRESULT labelled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
1040 {
1041     FIXME("\n");
1042     return E_NOTIMPL;
1043 }
1044
1045 /* ECMA-262 3rd Edition    12.13 */
1046 HRESULT switch_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1047 {
1048     switch_statement_t *stat = (switch_statement_t*)_stat;
1049     case_clausule_t *iter, *default_clausule = NULL;
1050     statement_t *stat_iter;
1051     VARIANT val, cval;
1052     BOOL b;
1053     HRESULT hres;
1054
1055     TRACE("\n");
1056
1057     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &val);
1058     if(FAILED(hres))
1059         return hres;
1060
1061     for(iter = stat->case_list; iter; iter = iter->next) {
1062         if(!iter->expr) {
1063             default_clausule = iter;
1064             continue;
1065         }
1066
1067         hres = expr_eval(ctx, iter->expr, 0, &rt->ei, &cval);
1068         if(FAILED(hres))
1069             break;
1070
1071         hres = equal2_values(&val, &cval, &b);
1072         VariantClear(&cval);
1073         if(FAILED(hres) || b)
1074             break;
1075     }
1076
1077     VariantClear(&val);
1078     if(FAILED(hres))
1079         return hres;
1080
1081     if(!iter)
1082         iter = default_clausule;
1083
1084     V_VT(&val) = VT_EMPTY;
1085     if(iter) {
1086         VARIANT tmp;
1087
1088         for(stat_iter = iter->stat; stat_iter; stat_iter = stat_iter->next) {
1089             hres = stat_eval(ctx, stat_iter, rt, &tmp);
1090             if(FAILED(hres))
1091                 break;
1092
1093             VariantClear(&val);
1094             val = tmp;
1095
1096             if(rt->type != RT_NORMAL)
1097                 break;
1098         }
1099     }
1100
1101     if(FAILED(hres)) {
1102         VariantClear(&val);
1103         return hres;
1104     }
1105
1106     if(rt->type == RT_BREAK)
1107         rt->type = RT_NORMAL;
1108
1109     *ret = val;
1110     return S_OK;
1111 }
1112
1113 /* ECMA-262 3rd Edition    12.13 */
1114 HRESULT throw_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1115 {
1116     expression_statement_t *stat = (expression_statement_t*)_stat;
1117     VARIANT val;
1118     HRESULT hres;
1119
1120     TRACE("\n");
1121
1122     hres = expr_eval(ctx, stat->expr, 0, &rt->ei, &val);
1123     if(FAILED(hres))
1124         return hres;
1125
1126     rt->ei.var = val;
1127     return DISP_E_EXCEPTION;
1128 }
1129
1130 static HRESULT interp_throw(exec_ctx_t *ctx)
1131 {
1132     const HRESULT arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1133
1134     TRACE("%08x\n", arg);
1135
1136     return throw_reference_error(ctx->parser->script, ctx->ei, arg, NULL);
1137 }
1138
1139 static HRESULT interp_throw_type(exec_ctx_t *ctx)
1140 {
1141     const HRESULT hres = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1142     const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg2.str;
1143
1144     TRACE("%08x %s\n", hres, debugstr_w(str));
1145
1146     return throw_type_error(ctx->parser->script, ctx->ei, hres, str);
1147 }
1148
1149 /* ECMA-262 3rd Edition    12.14 */
1150 static HRESULT catch_eval(script_ctx_t *ctx, catch_block_t *block, return_type_t *rt, VARIANT *ret)
1151 {
1152     jsdisp_t *var_disp;
1153     VARIANT ex, val;
1154     HRESULT hres;
1155
1156     ex = rt->ei.var;
1157     memset(&rt->ei, 0, sizeof(jsexcept_t));
1158
1159     hres = create_dispex(ctx, NULL, NULL, &var_disp);
1160     if(SUCCEEDED(hres)) {
1161         hres = jsdisp_propput_name(var_disp, block->identifier, &ex, &rt->ei, NULL/*FIXME*/);
1162         if(SUCCEEDED(hres)) {
1163             hres = scope_push(ctx->exec_ctx->scope_chain, var_disp, &ctx->exec_ctx->scope_chain);
1164             if(SUCCEEDED(hres)) {
1165                 hres = stat_eval(ctx, block->statement, rt, &val);
1166                 scope_pop(&ctx->exec_ctx->scope_chain);
1167             }
1168         }
1169
1170         jsdisp_release(var_disp);
1171     }
1172
1173     VariantClear(&ex);
1174     if(FAILED(hres))
1175         return hres;
1176
1177     *ret = val;
1178     return S_OK;
1179 }
1180
1181 /* ECMA-262 3rd Edition    12.14 */
1182 HRESULT try_statement_eval(script_ctx_t *ctx, statement_t *_stat, return_type_t *rt, VARIANT *ret)
1183 {
1184     try_statement_t *stat = (try_statement_t*)_stat;
1185     VARIANT val;
1186     HRESULT hres;
1187
1188     TRACE("\n");
1189
1190     hres = stat_eval(ctx, stat->try_statement, rt, &val);
1191     if(FAILED(hres)) {
1192         TRACE("EXCEPTION\n");
1193         if(!stat->catch_block)
1194             return hres;
1195
1196         hres = catch_eval(ctx, stat->catch_block, rt, &val);
1197         if(FAILED(hres))
1198             return hres;
1199     }
1200
1201     if(stat->finally_statement) {
1202         VariantClear(&val);
1203         hres = stat_eval(ctx, stat->finally_statement, rt, &val);
1204         if(FAILED(hres))
1205             return hres;
1206     }
1207
1208     *ret = val;
1209     return S_OK;
1210 }
1211
1212 /* ECMA-262 3rd Edition    13 */
1213 static HRESULT interp_func(exec_ctx_t *ctx)
1214 {
1215     function_expression_t *expr = ctx->parser->code->instrs[ctx->ip].arg1.func;
1216     jsdisp_t *dispex;
1217     VARIANT v;
1218     HRESULT hres;
1219
1220     TRACE("\n");
1221
1222     hres = create_source_function(ctx->parser, expr->parameter_list, expr->source_elements, ctx->scope_chain,
1223             expr->src_str, expr->src_len, &dispex);
1224     if(FAILED(hres))
1225         return hres;
1226
1227     var_set_jsdisp(&v, dispex);
1228     return stack_push(ctx, &v);
1229 }
1230
1231 /* ECMA-262 3rd Edition    11.2.1 */
1232 static HRESULT array_expression_eval(script_ctx_t *ctx, expression_t *_expr, jsexcept_t *ei, exprval_t *ret)
1233 {
1234     binary_expression_t *expr = (binary_expression_t*)_expr;
1235     VARIANT member, val;
1236     DISPID id;
1237     BSTR str;
1238     IDispatch *obj = NULL;
1239     HRESULT hres;
1240
1241     TRACE("\n");
1242
1243     hres = expr_eval(ctx, expr->expression1, 0, ei, &member);
1244     if(FAILED(hres))
1245         return hres;
1246
1247     hres = expr_eval(ctx, expr->expression2, 0, ei, &val);
1248     if(SUCCEEDED(hres)) {
1249         hres = to_object(ctx, &member, &obj);
1250         if(FAILED(hres))
1251             VariantClear(&val);
1252     }
1253     VariantClear(&member);
1254     if(SUCCEEDED(hres)) {
1255         hres = to_string(ctx, &val, ei, &str);
1256         VariantClear(&val);
1257         if(SUCCEEDED(hres)) {
1258             hres = disp_get_id(ctx, obj, str, fdexNameEnsure, &id);
1259             SysFreeString(str);
1260         }
1261
1262         if(SUCCEEDED(hres))
1263             exprval_set_idref(ret, obj, id);
1264
1265         IDispatch_Release(obj);
1266     }
1267
1268     return hres;
1269 }
1270
1271 /* ECMA-262 3rd Edition    11.2.1 */
1272 static HRESULT interp_array(exec_ctx_t *ctx)
1273 {
1274     VARIANT v, *namev;
1275     IDispatch *obj;
1276     DISPID id;
1277     BSTR name;
1278     HRESULT hres;
1279
1280     TRACE("\n");
1281
1282     namev = stack_pop(ctx);
1283
1284     hres = stack_pop_object(ctx, &obj);
1285     if(FAILED(hres)) {
1286         VariantClear(namev);
1287         return hres;
1288     }
1289
1290     hres = to_string(ctx->parser->script, namev, ctx->ei, &name);
1291     VariantClear(namev);
1292     if(FAILED(hres)) {
1293         IDispatch_Release(obj);
1294         return hres;
1295     }
1296
1297     hres = disp_get_id(ctx->parser->script, obj, name, 0, &id);
1298     SysFreeString(name);
1299     if(SUCCEEDED(hres)) {
1300         hres = disp_propget(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
1301     }else if(hres == DISP_E_UNKNOWNNAME) {
1302         V_VT(&v) = VT_EMPTY;
1303         hres = S_OK;
1304     }
1305     IDispatch_Release(obj);
1306     if(FAILED(hres))
1307         return hres;
1308
1309     return stack_push(ctx, &v);
1310 }
1311
1312 /* ECMA-262 3rd Edition    11.2.1 */
1313 static HRESULT member_expression_eval(script_ctx_t *ctx, expression_t *_expr, jsexcept_t *ei, exprval_t *ret)
1314 {
1315     member_expression_t *expr = (member_expression_t*)_expr;
1316     IDispatch *obj = NULL;
1317     VARIANT member;
1318     DISPID id;
1319     BSTR str;
1320     HRESULT hres;
1321
1322     TRACE("\n");
1323
1324     hres = expr_eval(ctx, expr->expression, 0, ei, &member);
1325     if(FAILED(hres))
1326         return hres;
1327
1328     hres = to_object(ctx, &member, &obj);
1329     VariantClear(&member);
1330     if(FAILED(hres))
1331         return hres;
1332
1333     str = SysAllocString(expr->identifier);
1334     if(!str) {
1335         IDispatch_Release(obj);
1336         return E_OUTOFMEMORY;
1337     }
1338
1339     hres = disp_get_id(ctx, obj, str, fdexNameEnsure, &id);
1340     SysFreeString(str);
1341     if(SUCCEEDED(hres))
1342         exprval_set_idref(ret, obj, id);
1343
1344     IDispatch_Release(obj);
1345     return hres;
1346 }
1347
1348 /* ECMA-262 3rd Edition    11.2.1 */
1349 static HRESULT interp_member(exec_ctx_t *ctx)
1350 {
1351     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1352     IDispatch *obj;
1353     VARIANT v;
1354     DISPID id;
1355     HRESULT hres;
1356
1357     TRACE("\n");
1358
1359     hres = stack_pop_object(ctx, &obj);
1360     if(FAILED(hres))
1361         return hres;
1362
1363     hres = disp_get_id(ctx->parser->script, obj, arg, 0, &id);
1364     if(SUCCEEDED(hres)) {
1365         V_VT(&v) = VT_EMPTY;
1366         hres = disp_propget(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
1367     }else if(hres == DISP_E_UNKNOWNNAME) {
1368         V_VT(&v) = VT_EMPTY;
1369         hres = S_OK;
1370     }
1371     IDispatch_Release(obj);
1372     if(FAILED(hres))
1373         return hres;
1374
1375     return stack_push(ctx, &v);
1376 }
1377
1378 /* ECMA-262 3rd Edition    11.2.1 */
1379 static HRESULT interp_memberid(exec_ctx_t *ctx)
1380 {
1381     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1382     VARIANT *objv, *namev;
1383     IDispatch *obj;
1384     BSTR name;
1385     DISPID id;
1386     HRESULT hres;
1387
1388     TRACE("%x\n", arg);
1389
1390     namev = stack_pop(ctx);
1391     objv = stack_pop(ctx);
1392
1393     hres = to_object(ctx->parser->script, objv, &obj);
1394     VariantClear(objv);
1395     if(SUCCEEDED(hres)) {
1396         hres = to_string(ctx->parser->script, namev, ctx->ei, &name);
1397         if(FAILED(hres))
1398             IDispatch_Release(obj);
1399     }
1400     VariantClear(namev);
1401     if(FAILED(hres))
1402         return hres;
1403
1404     hres = disp_get_id(ctx->parser->script, obj, name, arg, &id);
1405     SysFreeString(name);
1406     if(FAILED(hres)) {
1407         IDispatch_Release(obj);
1408         if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1409             obj = NULL;
1410             id = JS_E_INVALID_PROPERTY;
1411         }else {
1412             return hres;
1413         }
1414     }
1415
1416     return stack_push_objid(ctx, obj, id);
1417 }
1418
1419 /* ECMA-262 3rd Edition    11.2.1 */
1420 static HRESULT interp_refval(exec_ctx_t *ctx)
1421 {
1422     IDispatch *disp;
1423     VARIANT v;
1424     DISPID id;
1425     HRESULT hres;
1426
1427     TRACE("\n");
1428
1429     disp = stack_topn_objid(ctx, 0, &id);
1430     if(!disp)
1431         return throw_reference_error(ctx->parser->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1432
1433     hres = disp_propget(ctx->parser->script, disp, id, &v, ctx->ei, NULL/*FIXME*/);
1434     if(FAILED(hres))
1435         return hres;
1436
1437     return stack_push(ctx, &v);
1438 }
1439
1440 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1441 {
1442     VARIANT tmp;
1443     unsigned i;
1444
1445     dp->cArgs = arg_cnt;
1446     dp->rgdispidNamedArgs = NULL;
1447     dp->cNamedArgs = 0;
1448
1449     assert(ctx->top >= arg_cnt);
1450
1451     for(i=1; i*2 <= arg_cnt; i++) {
1452         tmp = ctx->stack[ctx->top-i];
1453         ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1454         ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1455     }
1456
1457     dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1458 }
1459
1460 /* ECMA-262 3rd Edition    11.2.2 */
1461 static HRESULT interp_new(exec_ctx_t *ctx)
1462 {
1463     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1464     VARIANT *constr, v;
1465     DISPPARAMS dp;
1466     HRESULT hres;
1467
1468     TRACE("%d\n", arg);
1469
1470     constr = stack_topn(ctx, arg);
1471
1472     /* NOTE: Should use to_object here */
1473
1474     if(V_VT(constr) == VT_NULL)
1475         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1476     else if(V_VT(constr) != VT_DISPATCH)
1477         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_INVALID_ACTION, NULL);
1478     else if(!V_DISPATCH(constr))
1479         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1480
1481     jsstack_to_dp(ctx, arg, &dp);
1482     hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1483             DISPATCH_CONSTRUCT, &dp, &v, ctx->ei, NULL/*FIXME*/);
1484     if(FAILED(hres))
1485         return hres;
1486
1487     stack_popn(ctx, arg+1);
1488     return stack_push(ctx, &v);
1489 }
1490
1491 /* ECMA-262 3rd Edition    11.2.3 */
1492 static HRESULT interp_call(exec_ctx_t *ctx)
1493 {
1494     const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1495     const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1496     VARIANT v, *objv;
1497     DISPPARAMS dp;
1498     HRESULT hres;
1499
1500     TRACE("%d %d\n", argn, do_ret);
1501
1502     objv = stack_topn(ctx, argn);
1503     if(V_VT(objv) != VT_DISPATCH)
1504         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1505
1506     jsstack_to_dp(ctx, argn, &dp);
1507     hres = disp_call(ctx->parser->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1508             do_ret ? &v : NULL, ctx->ei, NULL/*FIXME*/);
1509     if(FAILED(hres))
1510         return hres;
1511
1512     stack_popn(ctx, argn+1);
1513     return do_ret ? stack_push(ctx, &v) : S_OK;
1514
1515 }
1516
1517 /* ECMA-262 3rd Edition    11.2.3 */
1518 static HRESULT interp_call_member(exec_ctx_t *ctx)
1519 {
1520     const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1521     const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1522     IDispatch *obj;
1523     DISPPARAMS dp;
1524     VARIANT v;
1525     DISPID id;
1526     HRESULT hres;
1527
1528     TRACE("%d %d\n", argn, do_ret);
1529
1530     obj = stack_topn_objid(ctx, argn, &id);
1531     if(!obj)
1532         return throw_type_error(ctx->parser->script, ctx->ei, id, NULL);
1533
1534     jsstack_to_dp(ctx, argn, &dp);
1535     hres = disp_call(ctx->parser->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, ctx->ei, NULL/*FIXME*/);
1536     if(FAILED(hres))
1537         return hres;
1538
1539     stack_popn(ctx, argn+2);
1540     return do_ret ? stack_push(ctx, &v) : S_OK;
1541
1542 }
1543
1544 /* ECMA-262 3rd Edition    11.1.1 */
1545 static HRESULT interp_this(exec_ctx_t *ctx)
1546 {
1547     VARIANT v;
1548
1549     TRACE("\n");
1550
1551     V_VT(&v) = VT_DISPATCH;
1552     V_DISPATCH(&v) = ctx->this_obj;
1553     IDispatch_AddRef(ctx->this_obj);
1554     return stack_push(ctx, &v);
1555 }
1556
1557 /* ECMA-262 3rd Edition    10.1.4 */
1558 static HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, jsexcept_t *ei, exprval_t *ret)
1559 {
1560     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1561     BSTR identifier;
1562     HRESULT hres;
1563
1564     TRACE("\n");
1565
1566     identifier = SysAllocString(expr->identifier);
1567     if(!identifier)
1568         return E_OUTOFMEMORY;
1569
1570     hres = identifier_eval(ctx, identifier, fdexNameEnsure, ei, ret);
1571
1572     SysFreeString(identifier);
1573     return hres;
1574 }
1575
1576 /* ECMA-262 3rd Edition    10.1.4 */
1577 static HRESULT interp_ident(exec_ctx_t *ctx)
1578 {
1579     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1580     exprval_t exprval;
1581     VARIANT v;
1582     HRESULT hres;
1583
1584     TRACE("%s\n", debugstr_w(arg));
1585
1586     hres = identifier_eval(ctx->parser->script, arg, 0, ctx->ei, &exprval);
1587     if(FAILED(hres))
1588         return hres;
1589
1590     hres = exprval_to_value(ctx->parser->script, &exprval, ctx->ei, &v);
1591     exprval_release(&exprval);
1592     if(FAILED(hres))
1593         return hres;
1594
1595     return stack_push(ctx, &v);
1596 }
1597
1598 /* ECMA-262 3rd Edition    10.1.4 */
1599 static HRESULT interp_identid(exec_ctx_t *ctx)
1600 {
1601     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1602     const unsigned flags = ctx->parser->code->instrs[ctx->ip].arg2.uint;
1603     exprval_t exprval;
1604     HRESULT hres;
1605
1606     TRACE("%s %x\n", debugstr_w(arg), flags);
1607
1608     hres = identifier_eval(ctx->parser->script, arg, flags, ctx->ei, &exprval);
1609     if(FAILED(hres))
1610         return hres;
1611
1612     if(exprval.type != EXPRVAL_IDREF) {
1613         WARN("invalid ref\n");
1614         exprval_release(&exprval);
1615         return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1616     }
1617
1618     return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1619 }
1620
1621 /* ECMA-262 3rd Edition    7.8.1 */
1622 static HRESULT interp_null(exec_ctx_t *ctx)
1623 {
1624     VARIANT v;
1625
1626     TRACE("\n");
1627
1628     V_VT(&v) = VT_NULL;
1629     return stack_push(ctx, &v);
1630 }
1631
1632 /* ECMA-262 3rd Edition    7.8.2 */
1633 static HRESULT interp_bool(exec_ctx_t *ctx)
1634 {
1635     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1636
1637     TRACE("%s\n", arg ? "true" : "false");
1638
1639     return stack_push_bool(ctx, arg);
1640 }
1641
1642 /* ECMA-262 3rd Edition    7.8.3 */
1643 static HRESULT interp_int(exec_ctx_t *ctx)
1644 {
1645     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1646     VARIANT v;
1647
1648     TRACE("%d\n", arg);
1649
1650     V_VT(&v) = VT_I4;
1651     V_I4(&v) = arg;
1652     return stack_push(ctx, &v);
1653 }
1654
1655 /* ECMA-262 3rd Edition    7.8.3 */
1656 static HRESULT interp_double(exec_ctx_t *ctx)
1657 {
1658     const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1659     VARIANT v;
1660
1661     TRACE("%lf\n", arg);
1662
1663     V_VT(&v) = VT_R8;
1664     V_R8(&v) = arg;
1665     return stack_push(ctx, &v);
1666 }
1667
1668 /* ECMA-262 3rd Edition    7.8.4 */
1669 static HRESULT interp_str(exec_ctx_t *ctx)
1670 {
1671     const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1672     VARIANT v;
1673
1674     TRACE("%s\n", debugstr_w(str));
1675
1676     V_VT(&v) = VT_BSTR;
1677     V_BSTR(&v) = SysAllocString(str);
1678     if(!V_BSTR(&v))
1679         return E_OUTOFMEMORY;
1680
1681     return stack_push(ctx, &v);
1682 }
1683
1684 /* ECMA-262 3rd Edition    7.8 */
1685 static HRESULT interp_regexp(exec_ctx_t *ctx)
1686 {
1687     const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1688     const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1689     jsdisp_t *regexp;
1690     VARIANT v;
1691     HRESULT hres;
1692
1693     TRACE("%s %x\n", debugstr_w(source), flags);
1694
1695     hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, &regexp);
1696     if(FAILED(hres))
1697         return hres;
1698
1699     var_set_jsdisp(&v, regexp);
1700     return stack_push(ctx, &v);
1701 }
1702
1703 /* ECMA-262 3rd Edition    11.1.4 */
1704 static HRESULT interp_carray(exec_ctx_t *ctx)
1705 {
1706     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1707     jsdisp_t *array;
1708     VARIANT *v, r;
1709     unsigned i;
1710     HRESULT hres;
1711
1712     TRACE("%u\n", arg);
1713
1714     hres = create_array(ctx->parser->script, arg, &array);
1715     if(FAILED(hres))
1716         return hres;
1717
1718     i = arg;
1719     while(i--) {
1720         v = stack_pop(ctx);
1721         hres = jsdisp_propput_idx(array, i, v, ctx->ei, NULL/*FIXME*/);
1722         VariantClear(v);
1723         if(FAILED(hres)) {
1724             jsdisp_release(array);
1725             return hres;
1726         }
1727     }
1728
1729     var_set_jsdisp(&r, array);
1730     return stack_push(ctx, &r);
1731 }
1732
1733 /* ECMA-262 3rd Edition    11.1.5 */
1734 HRESULT interp_new_obj(exec_ctx_t *ctx)
1735 {
1736     jsdisp_t *obj;
1737     VARIANT v;
1738     HRESULT hres;
1739
1740     TRACE("\n");
1741
1742     hres = create_object(ctx->parser->script, NULL, &obj);
1743     if(FAILED(hres))
1744         return hres;
1745
1746     var_set_jsdisp(&v, obj);
1747     return stack_push(ctx, &v);
1748 }
1749
1750 /* ECMA-262 3rd Edition    11.1.5 */
1751 HRESULT interp_obj_prop(exec_ctx_t *ctx)
1752 {
1753     const BSTR name = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1754     jsdisp_t *obj;
1755     VARIANT *v;
1756     HRESULT hres;
1757
1758     TRACE("%s\n", debugstr_w(name));
1759
1760     v = stack_pop(ctx);
1761
1762     assert(V_VT(stack_top(ctx)) == VT_DISPATCH);
1763     obj = as_jsdisp(V_DISPATCH(stack_top(ctx)));
1764
1765     hres = jsdisp_propput_name(obj, name, v, ctx->ei, NULL/*FIXME*/);
1766     VariantClear(v);
1767     return hres;
1768 }
1769
1770 /* ECMA-262 3rd Edition    11.11 */
1771 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
1772 {
1773     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1774     VARIANT_BOOL b;
1775     HRESULT hres;
1776
1777     TRACE("\n");
1778
1779     hres = to_boolean(stack_top(ctx), &b);
1780     if(FAILED(hres))
1781         return hres;
1782
1783     if(b) {
1784         ctx->ip = arg;
1785     }else {
1786         stack_popn(ctx, 1);
1787         ctx->ip++;
1788     }
1789     return S_OK;
1790 }
1791
1792 /* ECMA-262 3rd Edition    11.11 */
1793 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
1794 {
1795     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1796     VARIANT_BOOL b;
1797     HRESULT hres;
1798
1799     TRACE("\n");
1800
1801     hres = to_boolean(stack_top(ctx), &b);
1802     if(FAILED(hres))
1803         return hres;
1804
1805     if(b) {
1806         stack_popn(ctx, 1);
1807         ctx->ip++;
1808     }else {
1809         ctx->ip = arg;
1810     }
1811     return S_OK;
1812 }
1813
1814 /* ECMA-262 3rd Edition    11.10 */
1815 static HRESULT interp_or(exec_ctx_t *ctx)
1816 {
1817     INT l, r;
1818     HRESULT hres;
1819
1820     TRACE("\n");
1821
1822     hres = stack_pop_int(ctx, &r);
1823     if(FAILED(hres))
1824         return hres;
1825
1826     hres = stack_pop_int(ctx, &l);
1827     if(FAILED(hres))
1828         return hres;
1829
1830     return stack_push_int(ctx, l|r);
1831 }
1832
1833 /* ECMA-262 3rd Edition    11.10 */
1834 static HRESULT interp_xor(exec_ctx_t *ctx)
1835 {
1836     INT l, r;
1837     HRESULT hres;
1838
1839     TRACE("\n");
1840
1841     hres = stack_pop_int(ctx, &r);
1842     if(FAILED(hres))
1843         return hres;
1844
1845     hres = stack_pop_int(ctx, &l);
1846     if(FAILED(hres))
1847         return hres;
1848
1849     return stack_push_int(ctx, l^r);
1850 }
1851
1852 /* ECMA-262 3rd Edition    11.10 */
1853 static HRESULT interp_and(exec_ctx_t *ctx)
1854 {
1855     INT l, r;
1856     HRESULT hres;
1857
1858     TRACE("\n");
1859
1860     hres = stack_pop_int(ctx, &r);
1861     if(FAILED(hres))
1862         return hres;
1863
1864     hres = stack_pop_int(ctx, &l);
1865     if(FAILED(hres))
1866         return hres;
1867
1868     return stack_push_int(ctx, l&r);
1869 }
1870
1871 /* ECMA-262 3rd Edition    11.8.6 */
1872 static HRESULT interp_instanceof(exec_ctx_t *ctx)
1873 {
1874     jsdisp_t *obj, *iter, *tmp = NULL;
1875     VARIANT prot, *v;
1876     BOOL ret = FALSE;
1877     HRESULT hres;
1878
1879     static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
1880
1881     v = stack_pop(ctx);
1882     if(V_VT(v) != VT_DISPATCH || !V_DISPATCH(v)) {
1883         VariantClear(v);
1884         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1885     }
1886
1887     obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1888     IDispatch_Release(V_DISPATCH(v));
1889     if(!obj) {
1890         FIXME("non-jsdisp objects not supported\n");
1891         return E_FAIL;
1892     }
1893
1894     if(is_class(obj, JSCLASS_FUNCTION)) {
1895         hres = jsdisp_propget_name(obj, prototypeW, &prot, ctx->ei, NULL/*FIXME*/);
1896     }else {
1897         hres = throw_type_error(ctx->parser->script, ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
1898     }
1899     jsdisp_release(obj);
1900     if(FAILED(hres))
1901         return hres;
1902
1903     v = stack_pop(ctx);
1904
1905     if(V_VT(&prot) == VT_DISPATCH) {
1906         if(V_VT(v) == VT_DISPATCH)
1907             tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
1908         for(iter = tmp; !ret && iter; iter = iter->prototype) {
1909             hres = disp_cmp(V_DISPATCH(&prot), to_disp(iter), &ret);
1910             if(FAILED(hres))
1911                 break;
1912         }
1913
1914         if(tmp)
1915             jsdisp_release(tmp);
1916     }else {
1917         FIXME("prototype is not an object\n");
1918         hres = E_FAIL;
1919     }
1920
1921     VariantClear(&prot);
1922     VariantClear(v);
1923     if(FAILED(hres))
1924         return hres;
1925
1926     return stack_push_bool(ctx, ret);
1927 }
1928
1929 /* ECMA-262 3rd Edition    11.8.7 */
1930 static HRESULT interp_in(exec_ctx_t *ctx)
1931 {
1932     VARIANT *obj, *v;
1933     DISPID id = 0;
1934     BOOL ret;
1935     BSTR str;
1936     HRESULT hres;
1937
1938     TRACE("\n");
1939
1940     obj = stack_pop(ctx);
1941     v = stack_pop(ctx);
1942
1943     if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
1944         VariantClear(obj);
1945         VariantClear(v);
1946         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1947     }
1948
1949     hres = to_string(ctx->parser->script, v, ctx->ei, &str);
1950     VariantClear(v);
1951     if(FAILED(hres)) {
1952         IDispatch_Release(V_DISPATCH(obj));
1953         return hres;
1954     }
1955
1956     hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
1957     IDispatch_Release(V_DISPATCH(obj));
1958     SysFreeString(str);
1959     if(SUCCEEDED(hres))
1960         ret = TRUE;
1961     else if(hres == DISP_E_UNKNOWNNAME)
1962         ret = FALSE;
1963     else
1964         return hres;
1965
1966     return stack_push_bool(ctx, ret);
1967 }
1968
1969 /* ECMA-262 3rd Edition    11.6.1 */
1970 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
1971 {
1972     VARIANT r, l;
1973     HRESULT hres;
1974
1975     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
1976     if(FAILED(hres))
1977         return hres;
1978
1979     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
1980     if(FAILED(hres)) {
1981         VariantClear(&l);
1982         return hres;
1983     }
1984
1985     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
1986         BSTR lstr = NULL, rstr = NULL;
1987
1988         if(V_VT(&l) == VT_BSTR)
1989             lstr = V_BSTR(&l);
1990         else
1991             hres = to_string(ctx, &l, ei, &lstr);
1992
1993         if(SUCCEEDED(hres)) {
1994             if(V_VT(&r) == VT_BSTR)
1995                 rstr = V_BSTR(&r);
1996             else
1997                 hres = to_string(ctx, &r, ei, &rstr);
1998         }
1999
2000         if(SUCCEEDED(hres)) {
2001             int len1, len2;
2002
2003             len1 = SysStringLen(lstr);
2004             len2 = SysStringLen(rstr);
2005
2006             V_VT(retv) = VT_BSTR;
2007             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2008             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2009             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2010         }
2011
2012         if(V_VT(&l) != VT_BSTR)
2013             SysFreeString(lstr);
2014         if(V_VT(&r) != VT_BSTR)
2015             SysFreeString(rstr);
2016     }else {
2017         VARIANT nl, nr;
2018
2019         hres = to_number(ctx, &l, ei, &nl);
2020         if(SUCCEEDED(hres)) {
2021             hres = to_number(ctx, &r, ei, &nr);
2022             if(SUCCEEDED(hres))
2023                 num_set_val(retv, num_val(&nl) + num_val(&nr));
2024         }
2025     }
2026
2027     VariantClear(&r);
2028     VariantClear(&l);
2029     return hres;
2030 }
2031
2032 /* ECMA-262 3rd Edition    11.6.1 */
2033 static HRESULT interp_add(exec_ctx_t *ctx)
2034 {
2035     VARIANT *l, *r, ret;
2036     HRESULT hres;
2037
2038     r = stack_pop(ctx);
2039     l = stack_pop(ctx);
2040
2041     TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2042
2043     hres = add_eval(ctx->parser->script, l, r, ctx->ei, &ret);
2044     VariantClear(l);
2045     VariantClear(r);
2046     if(FAILED(hres))
2047         return hres;
2048
2049     return stack_push(ctx, &ret);
2050 }
2051
2052 /* ECMA-262 3rd Edition    11.6.2 */
2053 static HRESULT interp_sub(exec_ctx_t *ctx)
2054 {
2055     VARIANT l, r;
2056     HRESULT hres;
2057
2058     TRACE("\n");
2059
2060     hres = stack_pop_number(ctx, &r);
2061     if(FAILED(hres))
2062         return hres;
2063
2064     hres = stack_pop_number(ctx, &l);
2065     if(FAILED(hres))
2066         return hres;
2067
2068     return stack_push_number(ctx, num_val(&l)-num_val(&r));
2069 }
2070
2071 /* ECMA-262 3rd Edition    11.5.1 */
2072 static HRESULT interp_mul(exec_ctx_t *ctx)
2073 {
2074     VARIANT l, r;
2075     HRESULT hres;
2076
2077     TRACE("\n");
2078
2079     hres = stack_pop_number(ctx, &r);
2080     if(FAILED(hres))
2081         return hres;
2082
2083     hres = stack_pop_number(ctx, &l);
2084     if(FAILED(hres))
2085         return hres;
2086
2087     return stack_push_number(ctx, num_val(&l)*num_val(&r));
2088 }
2089
2090 /* ECMA-262 3rd Edition    11.5.2 */
2091 static HRESULT interp_div(exec_ctx_t *ctx)
2092 {
2093     VARIANT l, r;
2094     HRESULT hres;
2095
2096     TRACE("\n");
2097
2098     hres = stack_pop_number(ctx, &r);
2099     if(FAILED(hres))
2100         return hres;
2101
2102     hres = stack_pop_number(ctx, &l);
2103     if(FAILED(hres))
2104         return hres;
2105
2106     return stack_push_number(ctx, num_val(&l)/num_val(&r));
2107 }
2108
2109 /* ECMA-262 3rd Edition    11.5.3 */
2110 static HRESULT interp_mod(exec_ctx_t *ctx)
2111 {
2112     VARIANT l, r;
2113     HRESULT hres;
2114
2115     TRACE("\n");
2116
2117     hres = stack_pop_number(ctx, &r);
2118     if(FAILED(hres))
2119         return hres;
2120
2121     hres = stack_pop_number(ctx, &l);
2122     if(FAILED(hres))
2123         return hres;
2124
2125     return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2126 }
2127
2128 /* ECMA-262 3rd Edition    11.4.2 */
2129 static HRESULT interp_delete(exec_ctx_t *ctx)
2130 {
2131     VARIANT *obj_var, *name_var;
2132     IDispatchEx *dispex;
2133     IDispatch *obj;
2134     BSTR name;
2135     BOOL ret;
2136     HRESULT hres;
2137
2138     TRACE("\n");
2139
2140     name_var = stack_pop(ctx);
2141     obj_var = stack_pop(ctx);
2142
2143     hres = to_object(ctx->parser->script, obj_var, &obj);
2144     VariantClear(obj_var);
2145     if(FAILED(hres)) {
2146         VariantClear(name_var);
2147         return hres;
2148     }
2149
2150     hres = to_string(ctx->parser->script, name_var, ctx->ei, &name);
2151     VariantClear(name_var);
2152     if(FAILED(hres)) {
2153         IDispatch_Release(obj);
2154         return hres;
2155     }
2156
2157     hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2158     if(SUCCEEDED(hres)) {
2159         hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2160         ret = TRUE;
2161         IDispatchEx_Release(dispex);
2162     }else {
2163         hres = S_OK;
2164         ret = FALSE;
2165     }
2166
2167     IDispatch_Release(obj);
2168     SysFreeString(name);
2169     if(FAILED(hres))
2170         return hres;
2171
2172     return stack_push_bool(ctx, ret);
2173 }
2174
2175 /* ECMA-262 3rd Edition    11.4.2 */
2176 static HRESULT interp_delete_ident(exec_ctx_t *ctx)
2177 {
2178     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
2179     IDispatchEx *dispex;
2180     exprval_t exprval;
2181     BOOL ret = FALSE;
2182     HRESULT hres;
2183
2184     TRACE("%s\n", debugstr_w(arg));
2185
2186     hres = identifier_eval(ctx->parser->script, arg, 0, ctx->ei, &exprval);
2187     if(FAILED(hres))
2188         return hres;
2189
2190     if(exprval.type != EXPRVAL_IDREF) {
2191         FIXME("Unsupported exprval\n");
2192         exprval_release(&exprval);
2193         return E_NOTIMPL;
2194     }
2195
2196     hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2197     IDispatch_Release(exprval.u.idref.disp);
2198     if(SUCCEEDED(hres)) {
2199         hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2200         IDispatchEx_Release(dispex);
2201         if(FAILED(hres))
2202             return hres;
2203
2204         ret = TRUE;
2205     }
2206
2207     return stack_push_bool(ctx, ret);
2208 }
2209
2210 /* ECMA-262 3rd Edition    11.4.2 */
2211 static HRESULT interp_void(exec_ctx_t *ctx)
2212 {
2213     VARIANT v;
2214
2215     TRACE("\n");
2216
2217     stack_popn(ctx, 1);
2218
2219     V_VT(&v) = VT_EMPTY;
2220     return stack_push(ctx, &v);
2221 }
2222
2223 /* ECMA-262 3rd Edition    11.4.3 */
2224 static HRESULT typeof_string(VARIANT *v, const WCHAR **ret)
2225 {
2226     switch(V_VT(v)) {
2227     case VT_EMPTY:
2228         *ret = undefinedW;
2229         break;
2230     case VT_NULL:
2231         *ret = objectW;
2232         break;
2233     case VT_BOOL:
2234         *ret = booleanW;
2235         break;
2236     case VT_I4:
2237     case VT_R8:
2238         *ret = numberW;
2239         break;
2240     case VT_BSTR:
2241         *ret = stringW;
2242         break;
2243     case VT_DISPATCH: {
2244         jsdisp_t *dispex;
2245
2246         if(V_DISPATCH(v) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(v)))) {
2247             *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2248             jsdisp_release(dispex);
2249         }else {
2250             *ret = objectW;
2251         }
2252         break;
2253     }
2254     default:
2255         FIXME("unhandled vt %d\n", V_VT(v));
2256         return E_NOTIMPL;
2257     }
2258
2259     return S_OK;
2260 }
2261
2262 /* ECMA-262 3rd Edition    11.4.3 */
2263 static HRESULT interp_typeofid(exec_ctx_t *ctx)
2264 {
2265     const WCHAR *ret;
2266     IDispatch *obj;
2267     VARIANT v;
2268     DISPID id;
2269     HRESULT hres;
2270
2271     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2272
2273     TRACE("\n");
2274
2275     obj = stack_pop_objid(ctx, &id);
2276     if(!obj)
2277         return stack_push_string(ctx, undefinedW);
2278
2279     V_VT(&v) = VT_EMPTY;
2280     hres = disp_propget(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
2281     IDispatch_Release(obj);
2282     if(FAILED(hres))
2283         return stack_push_string(ctx, unknownW);
2284
2285     hres = typeof_string(&v, &ret);
2286     VariantClear(&v);
2287     if(FAILED(hres))
2288         return hres;
2289
2290     return stack_push_string(ctx, ret);
2291 }
2292
2293 /* ECMA-262 3rd Edition    11.4.3 */
2294 static HRESULT interp_typeofident(exec_ctx_t *ctx)
2295 {
2296     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
2297     exprval_t exprval;
2298     const WCHAR *ret;
2299     VARIANT v;
2300     HRESULT hres;
2301
2302     TRACE("%s\n", debugstr_w(arg));
2303
2304     hres = identifier_eval(ctx->parser->script, arg, 0, ctx->ei, &exprval);
2305     if(FAILED(hres))
2306         return hres;
2307
2308     if(exprval.type == EXPRVAL_INVALID) {
2309         hres = stack_push_string(ctx, undefinedW);
2310         exprval_release(&exprval);
2311         return hres;
2312     }
2313
2314     hres = exprval_to_value(ctx->parser->script, &exprval, ctx->ei, &v);
2315     exprval_release(&exprval);
2316     if(FAILED(hres))
2317         return hres;
2318
2319     hres = typeof_string(&v, &ret);
2320     VariantClear(&v);
2321     if(FAILED(hres))
2322         return hres;
2323
2324     return stack_push_string(ctx, ret);
2325 }
2326
2327 /* ECMA-262 3rd Edition    11.4.3 */
2328 static HRESULT interp_typeof(exec_ctx_t *ctx)
2329 {
2330     const WCHAR *ret;
2331     VARIANT *v;
2332     HRESULT hres;
2333
2334     TRACE("\n");
2335
2336     v = stack_pop(ctx);
2337     hres = typeof_string(v, &ret);
2338     VariantClear(v);
2339     if(FAILED(hres))
2340         return hres;
2341
2342     return stack_push_string(ctx, ret);
2343 }
2344
2345 /* ECMA-262 3rd Edition    11.4.7 */
2346 static HRESULT interp_minus(exec_ctx_t *ctx)
2347 {
2348     VARIANT n;
2349     HRESULT hres;
2350
2351     TRACE("\n");
2352
2353     hres = stack_pop_number(ctx, &n);
2354     if(FAILED(hres))
2355         return hres;
2356
2357     return stack_push_number(ctx, -num_val(&n));
2358 }
2359
2360 /* ECMA-262 3rd Edition    11.4.6 */
2361 static HRESULT interp_tonum(exec_ctx_t *ctx)
2362 {
2363     VARIANT *v, num;
2364     HRESULT hres;
2365
2366     TRACE("\n");
2367
2368     v = stack_pop(ctx);
2369     hres = to_number(ctx->parser->script, v, ctx->ei, &num);
2370     VariantClear(v);
2371     if(FAILED(hres))
2372         return hres;
2373
2374     return stack_push(ctx, &num);
2375 }
2376
2377 /* ECMA-262 3rd Edition    11.3.1 */
2378 static HRESULT interp_postinc(exec_ctx_t *ctx)
2379 {
2380     const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2381     IDispatch *obj;
2382     DISPID id;
2383     VARIANT v;
2384     HRESULT hres;
2385
2386     TRACE("%d\n", arg);
2387
2388     obj = stack_pop_objid(ctx, &id);
2389     if(!obj)
2390         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2391
2392     hres = disp_propget(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
2393     if(SUCCEEDED(hres)) {
2394         VARIANT n, inc;
2395
2396         hres = to_number(ctx->parser->script, &v, ctx->ei, &n);
2397         if(SUCCEEDED(hres)) {
2398             num_set_val(&inc, num_val(&n)+(double)arg);
2399             hres = disp_propput(ctx->parser->script, obj, id, &inc, ctx->ei, NULL/*FIXME*/);
2400         }
2401         if(FAILED(hres))
2402             VariantClear(&v);
2403     }
2404     IDispatch_Release(obj);
2405     if(FAILED(hres))
2406         return hres;
2407
2408     return stack_push(ctx, &v);
2409 }
2410
2411 /* ECMA-262 3rd Edition    11.4.4, 11.4.5 */
2412 static HRESULT interp_preinc(exec_ctx_t *ctx)
2413 {
2414     const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2415     IDispatch *obj;
2416     DISPID id;
2417     VARIANT v;
2418     HRESULT hres;
2419
2420     TRACE("%d\n", arg);
2421
2422     obj = stack_pop_objid(ctx, &id);
2423     if(!obj)
2424         return throw_type_error(ctx->parser->script, ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2425
2426     hres = disp_propget(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
2427     if(SUCCEEDED(hres)) {
2428         VARIANT n;
2429
2430         hres = to_number(ctx->parser->script, &v, ctx->ei, &n);
2431         VariantClear(&v);
2432         if(SUCCEEDED(hres)) {
2433             num_set_val(&v, num_val(&n)+(double)arg);
2434             hres = disp_propput(ctx->parser->script, obj, id, &v, ctx->ei, NULL/*FIXME*/);
2435         }
2436     }
2437     IDispatch_Release(obj);
2438     if(FAILED(hres))
2439         return hres;
2440
2441     return stack_push(ctx, &v);
2442 }
2443
2444 /* ECMA-262 3rd Edition    11.9.3 */
2445 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2446 {
2447     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2448        return equal2_values(lval, rval, ret);
2449
2450     /* FIXME: NULL disps should be handled in more general way */
2451     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2452         VARIANT v;
2453         V_VT(&v) = VT_NULL;
2454         return equal_values(ctx, &v, rval, ei, ret);
2455     }
2456
2457     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2458         VARIANT v;
2459         V_VT(&v) = VT_NULL;
2460         return equal_values(ctx, lval, &v, ei, ret);
2461     }
2462
2463     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2464        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2465         *ret = TRUE;
2466         return S_OK;
2467     }
2468
2469     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2470         VARIANT v;
2471         HRESULT hres;
2472
2473         hres = to_number(ctx, lval, ei, &v);
2474         if(FAILED(hres))
2475             return hres;
2476
2477         return equal_values(ctx, &v, rval, ei, ret);
2478     }
2479
2480     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2481         VARIANT v;
2482         HRESULT hres;
2483
2484         hres = to_number(ctx, rval, ei, &v);
2485         if(FAILED(hres))
2486             return hres;
2487
2488         return equal_values(ctx, lval, &v, ei, ret);
2489     }
2490
2491     if(V_VT(rval) == VT_BOOL) {
2492         VARIANT v;
2493
2494         V_VT(&v) = VT_I4;
2495         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2496         return equal_values(ctx, lval, &v, ei, ret);
2497     }
2498
2499     if(V_VT(lval) == VT_BOOL) {
2500         VARIANT v;
2501
2502         V_VT(&v) = VT_I4;
2503         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2504         return equal_values(ctx, &v, rval, ei, ret);
2505     }
2506
2507
2508     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2509         VARIANT v;
2510         HRESULT hres;
2511
2512         hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2513         if(FAILED(hres))
2514             return hres;
2515
2516         hres = equal_values(ctx, lval, &v, ei, ret);
2517
2518         VariantClear(&v);
2519         return hres;
2520     }
2521
2522
2523     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2524         VARIANT v;
2525         HRESULT hres;
2526
2527         hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2528         if(FAILED(hres))
2529             return hres;
2530
2531         hres = equal_values(ctx, &v, rval, ei, ret);
2532
2533         VariantClear(&v);
2534         return hres;
2535     }
2536
2537
2538     *ret = FALSE;
2539     return S_OK;
2540 }
2541
2542 /* ECMA-262 3rd Edition    11.9.1 */
2543 static HRESULT interp_eq(exec_ctx_t *ctx)
2544 {
2545     VARIANT *l, *r;
2546     BOOL b;
2547     HRESULT hres;
2548
2549     r = stack_pop(ctx);
2550     l = stack_pop(ctx);
2551
2552     TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2553
2554     hres = equal_values(ctx->parser->script, l, r, ctx->ei, &b);
2555     VariantClear(l);
2556     VariantClear(r);
2557     if(FAILED(hres))
2558         return hres;
2559
2560     return stack_push_bool(ctx, b);
2561 }
2562
2563 /* ECMA-262 3rd Edition    11.9.2 */
2564 static HRESULT interp_neq(exec_ctx_t *ctx)
2565 {
2566     VARIANT *l, *r;
2567     BOOL b;
2568     HRESULT hres;
2569
2570     r = stack_pop(ctx);
2571     l = stack_pop(ctx);
2572
2573     TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2574
2575     hres = equal_values(ctx->parser->script, l, r, ctx->ei, &b);
2576     VariantClear(l);
2577     VariantClear(r);
2578     if(FAILED(hres))
2579         return hres;
2580
2581     return stack_push_bool(ctx, !b);
2582 }
2583
2584 /* ECMA-262 3rd Edition    11.9.4 */
2585 static HRESULT interp_eq2(exec_ctx_t *ctx)
2586 {
2587     VARIANT *l, *r;
2588     BOOL b;
2589     HRESULT hres;
2590
2591     TRACE("\n");
2592
2593     r = stack_pop(ctx);
2594     l = stack_pop(ctx);
2595
2596     hres = equal2_values(r, l, &b);
2597     VariantClear(l);
2598     VariantClear(r);
2599     if(FAILED(hres))
2600         return hres;
2601
2602     return stack_push_bool(ctx, b);
2603 }
2604
2605 /* ECMA-262 3rd Edition    11.9.5 */
2606 static HRESULT interp_neq2(exec_ctx_t *ctx)
2607 {
2608     VARIANT *l, *r;
2609     BOOL b;
2610     HRESULT hres;
2611
2612     TRACE("\n");
2613
2614     r = stack_pop(ctx);
2615     l = stack_pop(ctx);
2616
2617     hres = equal2_values(r, l, &b);
2618     VariantClear(l);
2619     VariantClear(r);
2620     if(FAILED(hres))
2621         return hres;
2622
2623     return stack_push_bool(ctx, !b);
2624 }
2625
2626 /* ECMA-262 3rd Edition    11.8.5 */
2627 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2628 {
2629     VARIANT l, r, ln, rn;
2630     HRESULT hres;
2631
2632     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2633     if(FAILED(hres))
2634         return hres;
2635
2636     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2637     if(FAILED(hres)) {
2638         VariantClear(&l);
2639         return hres;
2640     }
2641
2642     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2643         *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2644         SysFreeString(V_BSTR(&l));
2645         SysFreeString(V_BSTR(&r));
2646         return S_OK;
2647     }
2648
2649     hres = to_number(ctx, &l, ei, &ln);
2650     VariantClear(&l);
2651     if(SUCCEEDED(hres))
2652         hres = to_number(ctx, &r, ei, &rn);
2653     VariantClear(&r);
2654     if(FAILED(hres))
2655         return hres;
2656
2657     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
2658         *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
2659     }else  {
2660         DOUBLE ld = num_val(&ln);
2661         DOUBLE rd = num_val(&rn);
2662
2663         *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
2664     }
2665
2666     return S_OK;
2667 }
2668
2669 /* ECMA-262 3rd Edition    11.8.1 */
2670 static HRESULT interp_lt(exec_ctx_t *ctx)
2671 {
2672     VARIANT *l, *r;
2673     BOOL b;
2674     HRESULT hres;
2675
2676     r = stack_pop(ctx);
2677     l = stack_pop(ctx);
2678
2679     TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2680
2681     hres = less_eval(ctx->parser->script, l, r, FALSE, ctx->ei, &b);
2682     VariantClear(l);
2683     VariantClear(r);
2684     if(FAILED(hres))
2685         return hres;
2686
2687     return stack_push_bool(ctx, b);
2688 }
2689
2690 /* ECMA-262 3rd Edition    11.8.1 */
2691 static HRESULT interp_lteq(exec_ctx_t *ctx)
2692 {
2693     VARIANT *l, *r;
2694     BOOL b;
2695     HRESULT hres;
2696
2697     r = stack_pop(ctx);
2698     l = stack_pop(ctx);
2699
2700     TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
2701
2702     hres = less_eval(ctx->parser->script, r, l, TRUE, ctx->ei, &b);
2703     VariantClear(l);
2704     VariantClear(r);
2705     if(FAILED(hres))
2706         return hres;
2707
2708     return stack_push_bool(ctx, b);
2709 }
2710
2711 /* ECMA-262 3rd Edition    11.8.2 */
2712 static HRESULT interp_gt(exec_ctx_t *ctx)
2713 {
2714     VARIANT *l, *r;
2715     BOOL b;
2716     HRESULT hres;
2717
2718     r = stack_pop(ctx);
2719     l = stack_pop(ctx);
2720
2721     TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
2722
2723     hres = less_eval(ctx->parser->script, r, l, FALSE, ctx->ei, &b);
2724     VariantClear(l);
2725     VariantClear(r);
2726     if(FAILED(hres))
2727         return hres;
2728
2729     return stack_push_bool(ctx, b);
2730 }
2731
2732 /* ECMA-262 3rd Edition    11.8.4 */
2733 static HRESULT interp_gteq(exec_ctx_t *ctx)
2734 {
2735     VARIANT *l, *r;
2736     BOOL b;
2737     HRESULT hres;
2738
2739     r = stack_pop(ctx);
2740     l = stack_pop(ctx);
2741
2742     TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
2743
2744     hres = less_eval(ctx->parser->script, l, r, TRUE, ctx->ei, &b);
2745     VariantClear(l);
2746     VariantClear(r);
2747     if(FAILED(hres))
2748         return hres;
2749
2750     return stack_push_bool(ctx, b);
2751 }
2752
2753 /* ECMA-262 3rd Edition    11.4.8 */
2754 static HRESULT interp_bneg(exec_ctx_t *ctx)
2755 {
2756     VARIANT *v, r;
2757     INT i;
2758     HRESULT hres;
2759
2760     TRACE("\n");
2761
2762     v = stack_pop(ctx);
2763     hres = to_int32(ctx->parser->script, v, ctx->ei, &i);
2764     VariantClear(v);
2765     if(FAILED(hres))
2766         return hres;
2767
2768     V_VT(&r) = VT_I4;
2769     V_I4(&r) = ~i;
2770     return stack_push(ctx, &r);
2771 }
2772
2773 /* ECMA-262 3rd Edition    11.4.9 */
2774 static HRESULT interp_neg(exec_ctx_t *ctx)
2775 {
2776     VARIANT *v;
2777     VARIANT_BOOL b;
2778     HRESULT hres;
2779
2780     TRACE("\n");
2781
2782     v = stack_pop(ctx);
2783     hres = to_boolean(v, &b);
2784     VariantClear(v);
2785     if(FAILED(hres))
2786         return hres;
2787
2788     return stack_push_bool(ctx, !b);
2789 }
2790
2791 /* ECMA-262 3rd Edition    11.7.1 */
2792 static HRESULT interp_lshift(exec_ctx_t *ctx)
2793 {
2794     DWORD r;
2795     INT l;
2796     HRESULT hres;
2797
2798     hres = stack_pop_uint(ctx, &r);
2799     if(FAILED(hres))
2800         return hres;
2801
2802     hres = stack_pop_int(ctx, &l);
2803     if(FAILED(hres))
2804         return hres;
2805
2806     return stack_push_int(ctx, l << (r&0x1f));
2807 }
2808
2809 /* ECMA-262 3rd Edition    11.7.2 */
2810 static HRESULT interp_rshift(exec_ctx_t *ctx)
2811 {
2812     DWORD r;
2813     INT l;
2814     HRESULT hres;
2815
2816     hres = stack_pop_uint(ctx, &r);
2817     if(FAILED(hres))
2818         return hres;
2819
2820     hres = stack_pop_int(ctx, &l);
2821     if(FAILED(hres))
2822         return hres;
2823
2824     return stack_push_int(ctx, l >> (r&0x1f));
2825 }
2826
2827 /* ECMA-262 3rd Edition    11.7.3 */
2828 static HRESULT interp_rshift2(exec_ctx_t *ctx)
2829 {
2830     DWORD r, l;
2831     HRESULT hres;
2832
2833     hres = stack_pop_uint(ctx, &r);
2834     if(FAILED(hres))
2835         return hres;
2836
2837     hres = stack_pop_uint(ctx, &l);
2838     if(FAILED(hres))
2839         return hres;
2840
2841     return stack_push_int(ctx, l >> (r&0x1f));
2842 }
2843
2844 /* ECMA-262 3rd Edition    11.13.1 */
2845 static HRESULT interp_assign(exec_ctx_t *ctx)
2846 {
2847     IDispatch *disp;
2848     DISPID id;
2849     VARIANT *v;
2850     HRESULT hres;
2851
2852     TRACE("\n");
2853
2854     v = stack_pop(ctx);
2855     disp = stack_pop_objid(ctx, &id);
2856
2857     if(!disp)
2858         return throw_reference_error(ctx->parser->script, ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
2859
2860     hres = disp_propput(ctx->parser->script, disp, id, v, ctx->ei, NULL/*FIXME*/);
2861     IDispatch_Release(disp);
2862     if(FAILED(hres)) {
2863         VariantClear(v);
2864         return hres;
2865     }
2866
2867     return stack_push(ctx, v);
2868 }
2869
2870 static HRESULT interp_undefined(exec_ctx_t *ctx)
2871 {
2872     VARIANT v;
2873
2874     TRACE("\n");
2875
2876     V_VT(&v) = VT_EMPTY;
2877     return stack_push(ctx, &v);
2878 }
2879
2880 static HRESULT interp_jmp(exec_ctx_t *ctx)
2881 {
2882     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2883
2884     TRACE("\n");
2885
2886     ctx->ip = arg;
2887     return S_OK;
2888 }
2889
2890 static HRESULT interp_pop(exec_ctx_t *ctx)
2891 {
2892     TRACE("\n");
2893
2894     stack_popn(ctx, 1);
2895     return S_OK;
2896 }
2897
2898 static HRESULT interp_ret(exec_ctx_t *ctx)
2899 {
2900     TRACE("\n");
2901
2902     ctx->ip = -1;
2903     return S_OK;
2904 }
2905
2906 static HRESULT interp_tree(exec_ctx_t *ctx)
2907 {
2908     instr_t *instr = ctx->parser->code->instrs+ctx->ip;
2909     VARIANT v;
2910     HRESULT hres;
2911
2912     TRACE("\n");
2913
2914     hres = stat_eval(ctx->parser->script, instr->arg1.stat, ctx->rt, &v);
2915     if(FAILED(hres))
2916         return hres;
2917
2918     return stack_push(ctx, &v);
2919 }
2920
2921 typedef HRESULT (*op_func_t)(exec_ctx_t*);
2922
2923 static const op_func_t op_funcs[] = {
2924 #define X(x,a,b,c) interp_##x,
2925 OP_LIST
2926 #undef X
2927 };
2928
2929 static const unsigned op_move[] = {
2930 #define X(a,x,b,c) x,
2931 OP_LIST
2932 #undef X
2933 };
2934
2935 HRESULT compiled_statement_eval(script_ctx_t *ctx, statement_t *stat, return_type_t *rt, VARIANT *ret)
2936 {
2937     exec_ctx_t *exec_ctx = ctx->exec_ctx;
2938     unsigned prev_ip, prev_top;
2939     return_type_t *prev_rt;
2940     jsexcept_t *prev_ei;
2941     jsop_t op;
2942     HRESULT hres = S_OK;
2943
2944     TRACE("\n");
2945
2946     if(stat->instr_off == -1) {
2947         hres = compile_subscript_stat(exec_ctx->parser, stat, FALSE, &stat->instr_off);
2948         if(FAILED(hres))
2949             return hres;
2950     }
2951
2952     prev_rt = exec_ctx->rt;
2953     prev_top = exec_ctx->top;
2954     prev_ip = exec_ctx->ip;
2955     prev_ei = exec_ctx->ei;
2956     exec_ctx->ip = stat->instr_off;
2957     exec_ctx->rt = rt;
2958     exec_ctx->ei = &rt->ei;
2959
2960     while(exec_ctx->ip != -1 && exec_ctx->rt->type == RT_NORMAL) {
2961         op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
2962         hres = op_funcs[op](exec_ctx);
2963         if(FAILED(hres))
2964             break;
2965         exec_ctx->ip += op_move[op];
2966     }
2967
2968     exec_ctx->rt = prev_rt;
2969     exec_ctx->ip = prev_ip;
2970     exec_ctx->ei = prev_ei;
2971
2972     if(FAILED(hres)) {
2973         stack_popn(exec_ctx, exec_ctx->top-prev_top);
2974         return hres;
2975     }
2976
2977     assert(exec_ctx->top == prev_top+1 || exec_ctx->top == prev_top);
2978
2979     if(exec_ctx->top == prev_top)
2980         V_VT(ret) = VT_EMPTY;
2981     else
2982         *ret = *stack_pop(exec_ctx);
2983     return S_OK;
2984 }
2985
2986 static HRESULT expr_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, VARIANT *ret)
2987 {
2988     exec_ctx_t *exec_ctx = ctx->exec_ctx;
2989     unsigned prev_ip, prev_top;
2990     jsexcept_t *prev_ei;
2991     jsop_t op;
2992     HRESULT hres = S_OK;
2993
2994     TRACE("\n");
2995
2996     if(expr->instr_off == -1) {
2997         hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
2998         if(FAILED(hres))
2999             return hres;
3000     }
3001
3002     prev_top = exec_ctx->top;
3003     prev_ip = exec_ctx->ip;
3004     prev_ei = exec_ctx->ei;
3005     exec_ctx->ip = expr->instr_off;
3006     exec_ctx->ei = ei;
3007
3008     while(exec_ctx->ip != -1) {
3009         op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3010         hres = op_funcs[op](exec_ctx);
3011         if(FAILED(hres))
3012             break;
3013         exec_ctx->ip += op_move[op];
3014     }
3015
3016     exec_ctx->ip = prev_ip;
3017     exec_ctx->ei = prev_ei;
3018
3019     if(FAILED(hres)) {
3020         stack_popn(exec_ctx, exec_ctx->top-prev_top);
3021         return hres;
3022     }
3023
3024     assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3025
3026     if(exec_ctx->top == prev_top)
3027         V_VT(ret) = VT_EMPTY;
3028     else
3029         *ret = *stack_pop(exec_ctx);
3030     return S_OK;
3031 }