dlls/jscript/engine.c

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