git.oblomov.eu Git - wine/blob - dlls/jscript/engine.c

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