jscript: Initialize VARIANT before passing it to disp_propget.
[wine] / 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         V_VT(&v) = VT_EMPTY;
1583         hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
1584     }else if(hres == DISP_E_UNKNOWNNAME) {
1585         V_VT(&v) = VT_EMPTY;
1586         hres = S_OK;
1587     }
1588     IDispatch_Release(obj);
1589     if(FAILED(hres))
1590         return hres;
1591
1592     return stack_push(ctx, &v);
1593 }
1594
1595 /* ECMA-262 3rd Edition    11.2.1 */
1596 static HRESULT interp_memberid(exec_ctx_t *ctx)
1597 {
1598     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1599     VARIANT *objv, *namev;
1600     IDispatch *obj;
1601     BSTR name;
1602     DISPID id;
1603     HRESULT hres;
1604
1605     TRACE("%x\n", arg);
1606
1607     namev = stack_pop(ctx);
1608     objv = stack_pop(ctx);
1609
1610     hres = to_object(ctx->parser->script, objv, &obj);
1611     VariantClear(objv);
1612     if(SUCCEEDED(hres)) {
1613         hres = to_string(ctx->parser->script, namev, &ctx->ei, &name);
1614         if(FAILED(hres))
1615             IDispatch_Release(obj);
1616     }
1617     VariantClear(namev);
1618     if(FAILED(hres))
1619         return hres;
1620
1621     hres = disp_get_id(ctx->parser->script, obj, name, arg, &id);
1622     SysFreeString(name);
1623     if(FAILED(hres)) {
1624         IDispatch_Release(obj);
1625         if(hres == DISP_E_UNKNOWNNAME && !(arg & fdexNameEnsure)) {
1626             obj = NULL;
1627             id = JS_E_INVALID_PROPERTY;
1628         }else {
1629             return hres;
1630         }
1631     }
1632
1633     return stack_push_objid(ctx, obj, id);
1634 }
1635
1636 /* ECMA-262 3rd Edition    11.2.1 */
1637 static HRESULT interp_refval(exec_ctx_t *ctx)
1638 {
1639     IDispatch *disp;
1640     VARIANT v;
1641     DISPID id;
1642     HRESULT hres;
1643
1644     TRACE("\n");
1645
1646     disp = stack_topn_objid(ctx, 0, &id);
1647     if(!disp)
1648         return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
1649
1650     hres = disp_propget(ctx->parser->script, disp, id, &v, &ctx->ei, NULL/*FIXME*/);
1651     if(FAILED(hres))
1652         return hres;
1653
1654     return stack_push(ctx, &v);
1655 }
1656
1657 static void jsstack_to_dp(exec_ctx_t *ctx, unsigned arg_cnt, DISPPARAMS *dp)
1658 {
1659     VARIANT tmp;
1660     unsigned i;
1661
1662     dp->cArgs = arg_cnt;
1663     dp->rgdispidNamedArgs = NULL;
1664     dp->cNamedArgs = 0;
1665
1666     assert(ctx->top >= arg_cnt);
1667
1668     for(i=1; i*2 <= arg_cnt; i++) {
1669         tmp = ctx->stack[ctx->top-i];
1670         ctx->stack[ctx->top-i] = ctx->stack[ctx->top-arg_cnt+i-1];
1671         ctx->stack[ctx->top-arg_cnt+i-1] = tmp;
1672     }
1673
1674     dp->rgvarg = ctx->stack + ctx->top-arg_cnt;
1675 }
1676
1677 /* ECMA-262 3rd Edition    11.2.2 */
1678 static HRESULT interp_new(exec_ctx_t *ctx)
1679 {
1680     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1681     VARIANT *constr, v;
1682     DISPPARAMS dp;
1683     HRESULT hres;
1684
1685     TRACE("%d\n", arg);
1686
1687     constr = stack_topn(ctx, arg);
1688
1689     /* NOTE: Should use to_object here */
1690
1691     if(V_VT(constr) == VT_NULL)
1692         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
1693     else if(V_VT(constr) != VT_DISPATCH)
1694         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_ACTION, NULL);
1695     else if(!V_DISPATCH(constr))
1696         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1697
1698     jsstack_to_dp(ctx, arg, &dp);
1699     hres = disp_call(ctx->parser->script, V_DISPATCH(constr), DISPID_VALUE,
1700             DISPATCH_CONSTRUCT, &dp, &v, &ctx->ei, NULL/*FIXME*/);
1701     if(FAILED(hres))
1702         return hres;
1703
1704     stack_popn(ctx, arg+1);
1705     return stack_push(ctx, &v);
1706 }
1707
1708 /* ECMA-262 3rd Edition    11.2.3 */
1709 static HRESULT interp_call(exec_ctx_t *ctx)
1710 {
1711     const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1712     const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1713     VARIANT v, *objv;
1714     DISPPARAMS dp;
1715     HRESULT hres;
1716
1717     TRACE("%d %d\n", argn, do_ret);
1718
1719     objv = stack_topn(ctx, argn);
1720     if(V_VT(objv) != VT_DISPATCH)
1721         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_INVALID_PROPERTY, NULL);
1722
1723     jsstack_to_dp(ctx, argn, &dp);
1724     hres = disp_call(ctx->parser->script, V_DISPATCH(objv), DISPID_VALUE, DISPATCH_METHOD, &dp,
1725             do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1726     if(FAILED(hres))
1727         return hres;
1728
1729     stack_popn(ctx, argn+1);
1730     return do_ret ? stack_push(ctx, &v) : S_OK;
1731
1732 }
1733
1734 /* ECMA-262 3rd Edition    11.2.3 */
1735 static HRESULT interp_call_member(exec_ctx_t *ctx)
1736 {
1737     const unsigned argn = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1738     const int do_ret = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1739     IDispatch *obj;
1740     DISPPARAMS dp;
1741     VARIANT v;
1742     DISPID id;
1743     HRESULT hres;
1744
1745     TRACE("%d %d\n", argn, do_ret);
1746
1747     obj = stack_topn_objid(ctx, argn, &id);
1748     if(!obj)
1749         return throw_type_error(ctx->parser->script, &ctx->ei, id, NULL);
1750
1751     jsstack_to_dp(ctx, argn, &dp);
1752     hres = disp_call(ctx->parser->script, obj, id, DISPATCH_METHOD, &dp, do_ret ? &v : NULL, &ctx->ei, NULL/*FIXME*/);
1753     if(FAILED(hres))
1754         return hres;
1755
1756     stack_popn(ctx, argn+2);
1757     return do_ret ? stack_push(ctx, &v) : S_OK;
1758
1759 }
1760
1761 /* ECMA-262 3rd Edition    11.1.1 */
1762 static HRESULT interp_this(exec_ctx_t *ctx)
1763 {
1764     VARIANT v;
1765
1766     TRACE("\n");
1767
1768     V_VT(&v) = VT_DISPATCH;
1769     V_DISPATCH(&v) = ctx->this_obj;
1770     IDispatch_AddRef(ctx->this_obj);
1771     return stack_push(ctx, &v);
1772 }
1773
1774 /* ECMA-262 3rd Edition    10.1.4 */
1775 HRESULT identifier_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1776 {
1777     identifier_expression_t *expr = (identifier_expression_t*)_expr;
1778     BSTR identifier;
1779     HRESULT hres;
1780
1781     TRACE("\n");
1782
1783     identifier = SysAllocString(expr->identifier);
1784     if(!identifier)
1785         return E_OUTOFMEMORY;
1786
1787     hres = identifier_eval(ctx, identifier, flags, ei, ret);
1788
1789     SysFreeString(identifier);
1790     return hres;
1791 }
1792
1793 /* ECMA-262 3rd Edition    10.1.4 */
1794 static HRESULT interp_ident(exec_ctx_t *ctx)
1795 {
1796     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1797     exprval_t exprval;
1798     VARIANT v;
1799     HRESULT hres;
1800
1801     TRACE("%s\n", debugstr_w(arg));
1802
1803     hres = identifier_eval(ctx->parser->script, arg, 0, &ctx->ei, &exprval);
1804     if(FAILED(hres))
1805         return hres;
1806
1807     hres = exprval_to_value(ctx->parser->script, &exprval, &ctx->ei, &v);
1808     exprval_release(&exprval);
1809     if(FAILED(hres))
1810         return hres;
1811
1812     return stack_push(ctx, &v);
1813 }
1814
1815 /* ECMA-262 3rd Edition    10.1.4 */
1816 static HRESULT interp_identid(exec_ctx_t *ctx)
1817 {
1818     const BSTR arg = ctx->parser->code->instrs[ctx->ip].arg1.bstr;
1819     const unsigned flags = ctx->parser->code->instrs[ctx->ip].arg2.uint;
1820     exprval_t exprval;
1821     HRESULT hres;
1822
1823     TRACE("%s %x\n", debugstr_w(arg), flags);
1824
1825     hres = identifier_eval(ctx->parser->script, arg, (flags&fdexNameEnsure) ? EXPR_NEWREF : 0, &ctx->ei, &exprval);
1826     if(FAILED(hres))
1827         return hres;
1828
1829     if(exprval.type != EXPRVAL_IDREF) {
1830         WARN("invalid ref\n");
1831         exprval_release(&exprval);
1832         return stack_push_objid(ctx, NULL, JS_E_OBJECT_EXPECTED);
1833     }
1834
1835     return stack_push_objid(ctx, exprval.u.idref.disp, exprval.u.idref.id);
1836 }
1837
1838 /* ECMA-262 3rd Edition    7.8.1 */
1839 static HRESULT interp_null(exec_ctx_t *ctx)
1840 {
1841     VARIANT v;
1842
1843     TRACE("\n");
1844
1845     V_VT(&v) = VT_NULL;
1846     return stack_push(ctx, &v);
1847 }
1848
1849 /* ECMA-262 3rd Edition    7.8.2 */
1850 static HRESULT interp_bool(exec_ctx_t *ctx)
1851 {
1852     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1853
1854     TRACE("%s\n", arg ? "true" : "false");
1855
1856     return stack_push_bool(ctx, arg);
1857 }
1858
1859 /* ECMA-262 3rd Edition    7.8.3 */
1860 static HRESULT interp_int(exec_ctx_t *ctx)
1861 {
1862     const LONG arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
1863     VARIANT v;
1864
1865     TRACE("%d\n", arg);
1866
1867     V_VT(&v) = VT_I4;
1868     V_I4(&v) = arg;
1869     return stack_push(ctx, &v);
1870 }
1871
1872 /* ECMA-262 3rd Edition    7.8.3 */
1873 static HRESULT interp_double(exec_ctx_t *ctx)
1874 {
1875     const double arg = *ctx->parser->code->instrs[ctx->ip].arg1.dbl;
1876     VARIANT v;
1877
1878     TRACE("%lf\n", arg);
1879
1880     V_VT(&v) = VT_R8;
1881     V_R8(&v) = arg;
1882     return stack_push(ctx, &v);
1883 }
1884
1885 /* ECMA-262 3rd Edition    7.8.4 */
1886 static HRESULT interp_str(exec_ctx_t *ctx)
1887 {
1888     const WCHAR *str = ctx->parser->code->instrs[ctx->ip].arg1.str;
1889     VARIANT v;
1890
1891     TRACE("%s\n", debugstr_w(str));
1892
1893     V_VT(&v) = VT_BSTR;
1894     V_BSTR(&v) = SysAllocString(str);
1895     if(!V_BSTR(&v))
1896         return E_OUTOFMEMORY;
1897
1898     return stack_push(ctx, &v);
1899 }
1900
1901 /* ECMA-262 3rd Edition    7.8 */
1902 static HRESULT interp_regexp(exec_ctx_t *ctx)
1903 {
1904     const WCHAR *source = ctx->parser->code->instrs[ctx->ip].arg1.str;
1905     const LONG flags = ctx->parser->code->instrs[ctx->ip].arg2.lng;
1906     jsdisp_t *regexp;
1907     VARIANT v;
1908     HRESULT hres;
1909
1910     TRACE("%s %x\n", debugstr_w(source), flags);
1911
1912     hres = create_regexp(ctx->parser->script, source, strlenW(source), flags, &regexp);
1913     if(FAILED(hres))
1914         return hres;
1915
1916     var_set_jsdisp(&v, regexp);
1917     return stack_push(ctx, &v);
1918 }
1919
1920 /* ECMA-262 3rd Edition    11.1.4 */
1921 static HRESULT interp_carray(exec_ctx_t *ctx)
1922 {
1923     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
1924     jsdisp_t *array;
1925     VARIANT *v, r;
1926     unsigned i;
1927     HRESULT hres;
1928
1929     TRACE("%u\n", arg);
1930
1931     hres = create_array(ctx->parser->script, arg, &array);
1932     if(FAILED(hres))
1933         return hres;
1934
1935     i = arg;
1936     while(i--) {
1937         v = stack_pop(ctx);
1938         hres = jsdisp_propput_idx(array, i, v, &ctx->ei, NULL/*FIXME*/);
1939         VariantClear(v);
1940         if(FAILED(hres)) {
1941             jsdisp_release(array);
1942             return hres;
1943         }
1944     }
1945
1946     var_set_jsdisp(&r, array);
1947     return stack_push(ctx, &r);
1948 }
1949
1950 /* ECMA-262 3rd Edition    11.1.5 */
1951 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
1952 {
1953     property_value_expression_t *expr = (property_value_expression_t*)_expr;
1954     VARIANT val, tmp;
1955     jsdisp_t *obj;
1956     prop_val_t *iter;
1957     exprval_t exprval;
1958     BSTR name;
1959     HRESULT hres;
1960
1961     TRACE("\n");
1962
1963     hres = create_object(ctx, NULL, &obj);
1964     if(FAILED(hres))
1965         return hres;
1966
1967     for(iter = expr->property_list; iter; iter = iter->next) {
1968         hres = literal_to_var(ctx, iter->name, &tmp);
1969         if(FAILED(hres))
1970             break;
1971
1972         hres = to_string(ctx, &tmp, ei, &name);
1973         VariantClear(&tmp);
1974         if(FAILED(hres))
1975             break;
1976
1977         hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
1978         if(SUCCEEDED(hres)) {
1979             hres = exprval_to_value(ctx, &exprval, ei, &val);
1980             exprval_release(&exprval);
1981             if(SUCCEEDED(hres)) {
1982                 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
1983                 VariantClear(&val);
1984             }
1985         }
1986
1987         SysFreeString(name);
1988         if(FAILED(hres))
1989             break;
1990     }
1991
1992     if(FAILED(hres)) {
1993         jsdisp_release(obj);
1994         return hres;
1995     }
1996
1997     ret->type = EXPRVAL_VARIANT;
1998     var_set_jsdisp(&ret->u.var, obj);
1999     return S_OK;
2000 }
2001
2002 /* ECMA-262 3rd Edition    11.11 */
2003 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2004 {
2005     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2006     VARIANT_BOOL b;
2007     HRESULT hres;
2008
2009     TRACE("\n");
2010
2011     hres = to_boolean(stack_top(ctx), &b);
2012     if(FAILED(hres))
2013         return hres;
2014
2015     if(b) {
2016         ctx->ip = arg;
2017     }else {
2018         stack_popn(ctx, 1);
2019         ctx->ip++;
2020     }
2021     return S_OK;
2022 }
2023
2024 /* ECMA-262 3rd Edition    11.11 */
2025 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2026 {
2027     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2028     VARIANT_BOOL b;
2029     HRESULT hres;
2030
2031     TRACE("\n");
2032
2033     hres = to_boolean(stack_top(ctx), &b);
2034     if(FAILED(hres))
2035         return hres;
2036
2037     if(b) {
2038         stack_popn(ctx, 1);
2039         ctx->ip++;
2040     }else {
2041         ctx->ip = arg;
2042     }
2043     return S_OK;
2044 }
2045
2046 /* ECMA-262 3rd Edition    11.10 */
2047 static HRESULT interp_or(exec_ctx_t *ctx)
2048 {
2049     INT l, r;
2050     HRESULT hres;
2051
2052     TRACE("\n");
2053
2054     hres = stack_pop_int(ctx, &r);
2055     if(FAILED(hres))
2056         return hres;
2057
2058     hres = stack_pop_int(ctx, &l);
2059     if(FAILED(hres))
2060         return hres;
2061
2062     return stack_push_int(ctx, l|r);
2063 }
2064
2065 /* ECMA-262 3rd Edition    11.10 */
2066 static HRESULT interp_xor(exec_ctx_t *ctx)
2067 {
2068     INT l, r;
2069     HRESULT hres;
2070
2071     TRACE("\n");
2072
2073     hres = stack_pop_int(ctx, &r);
2074     if(FAILED(hres))
2075         return hres;
2076
2077     hres = stack_pop_int(ctx, &l);
2078     if(FAILED(hres))
2079         return hres;
2080
2081     return stack_push_int(ctx, l^r);
2082 }
2083
2084 /* ECMA-262 3rd Edition    11.10 */
2085 static HRESULT interp_and(exec_ctx_t *ctx)
2086 {
2087     INT l, r;
2088     HRESULT hres;
2089
2090     TRACE("\n");
2091
2092     hres = stack_pop_int(ctx, &r);
2093     if(FAILED(hres))
2094         return hres;
2095
2096     hres = stack_pop_int(ctx, &l);
2097     if(FAILED(hres))
2098         return hres;
2099
2100     return stack_push_int(ctx, l&r);
2101 }
2102
2103 /* ECMA-262 3rd Edition    11.8.6 */
2104 static HRESULT interp_instanceof(exec_ctx_t *ctx)
2105 {
2106     jsdisp_t *obj, *iter, *tmp = NULL;
2107     VARIANT prot, *v;
2108     BOOL ret = FALSE;
2109     HRESULT hres;
2110
2111     static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2112
2113     v = stack_pop(ctx);
2114     if(V_VT(v) != VT_DISPATCH || !V_DISPATCH(v)) {
2115         VariantClear(v);
2116         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
2117     }
2118
2119     obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
2120     IDispatch_Release(V_DISPATCH(v));
2121     if(!obj) {
2122         FIXME("non-jsdisp objects not supported\n");
2123         return E_FAIL;
2124     }
2125
2126     if(is_class(obj, JSCLASS_FUNCTION)) {
2127         hres = jsdisp_propget_name(obj, prototypeW, &prot, &ctx->ei, NULL/*FIXME*/);
2128     }else {
2129         hres = throw_type_error(ctx->parser->script, &ctx->ei, JS_E_FUNCTION_EXPECTED, NULL);
2130     }
2131     jsdisp_release(obj);
2132     if(FAILED(hres))
2133         return hres;
2134
2135     v = stack_pop(ctx);
2136
2137     if(V_VT(&prot) == VT_DISPATCH) {
2138         if(V_VT(v) == VT_DISPATCH)
2139             tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
2140         for(iter = tmp; !ret && iter; iter = iter->prototype) {
2141             hres = disp_cmp(V_DISPATCH(&prot), to_disp(iter), &ret);
2142             if(FAILED(hres))
2143                 break;
2144         }
2145
2146         if(tmp)
2147             jsdisp_release(tmp);
2148     }else {
2149         FIXME("prototype is not an object\n");
2150         hres = E_FAIL;
2151     }
2152
2153     VariantClear(&prot);
2154     VariantClear(v);
2155     if(FAILED(hres))
2156         return hres;
2157
2158     return stack_push_bool(ctx, ret);
2159 }
2160
2161 /* ECMA-262 3rd Edition    11.8.7 */
2162 static HRESULT interp_in(exec_ctx_t *ctx)
2163 {
2164     VARIANT *obj, *v;
2165     DISPID id = 0;
2166     BOOL ret;
2167     BSTR str;
2168     HRESULT hres;
2169
2170     TRACE("\n");
2171
2172     obj = stack_pop(ctx);
2173     v = stack_pop(ctx);
2174
2175     if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2176         VariantClear(obj);
2177         VariantClear(v);
2178         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2179     }
2180
2181     hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2182     VariantClear(v);
2183     if(FAILED(hres)) {
2184         IDispatch_Release(V_DISPATCH(obj));
2185         return hres;
2186     }
2187
2188     hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2189     IDispatch_Release(V_DISPATCH(obj));
2190     SysFreeString(str);
2191     if(SUCCEEDED(hres))
2192         ret = TRUE;
2193     else if(hres == DISP_E_UNKNOWNNAME)
2194         ret = FALSE;
2195     else
2196         return hres;
2197
2198     return stack_push_bool(ctx, ret);
2199 }
2200
2201 /* ECMA-262 3rd Edition    11.6.1 */
2202 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2203 {
2204     VARIANT r, l;
2205     HRESULT hres;
2206
2207     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2208     if(FAILED(hres))
2209         return hres;
2210
2211     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2212     if(FAILED(hres)) {
2213         VariantClear(&l);
2214         return hres;
2215     }
2216
2217     if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2218         BSTR lstr = NULL, rstr = NULL;
2219
2220         if(V_VT(&l) == VT_BSTR)
2221             lstr = V_BSTR(&l);
2222         else
2223             hres = to_string(ctx, &l, ei, &lstr);
2224
2225         if(SUCCEEDED(hres)) {
2226             if(V_VT(&r) == VT_BSTR)
2227                 rstr = V_BSTR(&r);
2228             else
2229                 hres = to_string(ctx, &r, ei, &rstr);
2230         }
2231
2232         if(SUCCEEDED(hres)) {
2233             int len1, len2;
2234
2235             len1 = SysStringLen(lstr);
2236             len2 = SysStringLen(rstr);
2237
2238             V_VT(retv) = VT_BSTR;
2239             V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2240             memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2241             memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2242         }
2243
2244         if(V_VT(&l) != VT_BSTR)
2245             SysFreeString(lstr);
2246         if(V_VT(&r) != VT_BSTR)
2247             SysFreeString(rstr);
2248     }else {
2249         VARIANT nl, nr;
2250
2251         hres = to_number(ctx, &l, ei, &nl);
2252         if(SUCCEEDED(hres)) {
2253             hres = to_number(ctx, &r, ei, &nr);
2254             if(SUCCEEDED(hres))
2255                 num_set_val(retv, num_val(&nl) + num_val(&nr));
2256         }
2257     }
2258
2259     VariantClear(&r);
2260     VariantClear(&l);
2261     return hres;
2262 }
2263
2264 /* ECMA-262 3rd Edition    11.6.1 */
2265 static HRESULT interp_add(exec_ctx_t *ctx)
2266 {
2267     VARIANT *l, *r, ret;
2268     HRESULT hres;
2269
2270     r = stack_pop(ctx);
2271     l = stack_pop(ctx);
2272
2273     TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2274
2275     hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2276     VariantClear(l);
2277     VariantClear(r);
2278     if(FAILED(hres))
2279         return hres;
2280
2281     return stack_push(ctx, &ret);
2282 }
2283
2284 /* ECMA-262 3rd Edition    11.6.2 */
2285 static HRESULT interp_sub(exec_ctx_t *ctx)
2286 {
2287     VARIANT l, r;
2288     HRESULT hres;
2289
2290     TRACE("\n");
2291
2292     hres = stack_pop_number(ctx, &r);
2293     if(FAILED(hres))
2294         return hres;
2295
2296     hres = stack_pop_number(ctx, &l);
2297     if(FAILED(hres))
2298         return hres;
2299
2300     return stack_push_number(ctx, num_val(&l)-num_val(&r));
2301 }
2302
2303 /* ECMA-262 3rd Edition    11.5.1 */
2304 static HRESULT interp_mul(exec_ctx_t *ctx)
2305 {
2306     VARIANT l, r;
2307     HRESULT hres;
2308
2309     TRACE("\n");
2310
2311     hres = stack_pop_number(ctx, &r);
2312     if(FAILED(hres))
2313         return hres;
2314
2315     hres = stack_pop_number(ctx, &l);
2316     if(FAILED(hres))
2317         return hres;
2318
2319     return stack_push_number(ctx, num_val(&l)*num_val(&r));
2320 }
2321
2322 /* ECMA-262 3rd Edition    11.5.2 */
2323 static HRESULT interp_div(exec_ctx_t *ctx)
2324 {
2325     VARIANT l, r;
2326     HRESULT hres;
2327
2328     TRACE("\n");
2329
2330     hres = stack_pop_number(ctx, &r);
2331     if(FAILED(hres))
2332         return hres;
2333
2334     hres = stack_pop_number(ctx, &l);
2335     if(FAILED(hres))
2336         return hres;
2337
2338     return stack_push_number(ctx, num_val(&l)/num_val(&r));
2339 }
2340
2341 /* ECMA-262 3rd Edition    11.5.3 */
2342 static HRESULT interp_mod(exec_ctx_t *ctx)
2343 {
2344     VARIANT l, r;
2345     HRESULT hres;
2346
2347     TRACE("\n");
2348
2349     hres = stack_pop_number(ctx, &r);
2350     if(FAILED(hres))
2351         return hres;
2352
2353     hres = stack_pop_number(ctx, &l);
2354     if(FAILED(hres))
2355         return hres;
2356
2357     return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2358 }
2359
2360 /* ECMA-262 3rd Edition    11.4.2 */
2361 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2362 {
2363     unary_expression_t *expr = (unary_expression_t*)_expr;
2364     VARIANT_BOOL b = VARIANT_FALSE;
2365     exprval_t exprval;
2366     HRESULT hres;
2367
2368     TRACE("\n");
2369
2370     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2371     if(FAILED(hres))
2372         return hres;
2373
2374     switch(exprval.type) {
2375     case EXPRVAL_IDREF: {
2376         IDispatchEx *dispex;
2377
2378         hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2379         if(SUCCEEDED(hres)) {
2380             hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2381             b = VARIANT_TRUE;
2382             IDispatchEx_Release(dispex);
2383         }
2384         break;
2385     }
2386     default:
2387         FIXME("unsupported type %d\n", exprval.type);
2388         hres = E_NOTIMPL;
2389     }
2390
2391     exprval_release(&exprval);
2392     if(FAILED(hres))
2393         return hres;
2394
2395     return return_bool(ret, b);
2396 }
2397
2398 /* ECMA-262 3rd Edition    11.4.2 */
2399 static HRESULT interp_delete(exec_ctx_t *ctx)
2400 {
2401     VARIANT *obj_var, *name_var;
2402     IDispatchEx *dispex;
2403     IDispatch *obj;
2404     BSTR name;
2405     BOOL ret;
2406     HRESULT hres;
2407
2408     TRACE("\n");
2409
2410     name_var = stack_pop(ctx);
2411     obj_var = stack_pop(ctx);
2412
2413     hres = to_object(ctx->parser->script, obj_var, &obj);
2414     VariantClear(obj_var);
2415     if(FAILED(hres)) {
2416         VariantClear(name_var);
2417         return hres;
2418     }
2419
2420     hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2421     VariantClear(name_var);
2422     if(FAILED(hres)) {
2423         IDispatch_Release(obj);
2424         return hres;
2425     }
2426
2427     hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2428     if(SUCCEEDED(hres)) {
2429         hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2430         ret = TRUE;
2431         IDispatchEx_Release(dispex);
2432     }else {
2433         hres = S_OK;
2434         ret = FALSE;
2435     }
2436
2437     IDispatch_Release(obj);
2438     SysFreeString(name);
2439     if(FAILED(hres))
2440         return hres;
2441
2442     return stack_push_bool(ctx, ret);
2443 }
2444
2445 /* ECMA-262 3rd Edition    11.4.2 */
2446 static HRESULT interp_void(exec_ctx_t *ctx)
2447 {
2448     VARIANT v;
2449
2450     TRACE("\n");
2451
2452     stack_popn(ctx, 1);
2453
2454     V_VT(&v) = VT_EMPTY;
2455     return stack_push(ctx, &v);
2456 }
2457
2458 /* ECMA-262 3rd Edition    11.4.3 */
2459 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2460 {
2461     VARIANT val;
2462     HRESULT hres;
2463
2464     static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2465     static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2466     static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2467     static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2468     static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2469     static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2470     static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2471
2472     if(exprval->type == EXPRVAL_INVALID) {
2473         *ret = undefinedW;
2474         return S_OK;
2475     }
2476
2477     hres = exprval_to_value(ctx, exprval, ei, &val);
2478     if(FAILED(hres)) {
2479         if(exprval->type == EXPRVAL_IDREF) {
2480             *ret = unknownW;
2481             return S_OK;
2482         }
2483         return hres;
2484     }
2485
2486     switch(V_VT(&val)) {
2487     case VT_EMPTY:
2488         *ret = undefinedW;
2489         break;
2490     case VT_NULL:
2491         *ret = objectW;
2492         break;
2493     case VT_BOOL:
2494         *ret = booleanW;
2495         break;
2496     case VT_I4:
2497     case VT_R8:
2498         *ret = numberW;
2499         break;
2500     case VT_BSTR:
2501         *ret = stringW;
2502         break;
2503     case VT_DISPATCH: {
2504         jsdisp_t *dispex;
2505
2506         if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2507             *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2508             jsdisp_release(dispex);
2509         }else {
2510             *ret = objectW;
2511         }
2512         break;
2513     }
2514     default:
2515         FIXME("unhandled vt %d\n", V_VT(&val));
2516         hres = E_NOTIMPL;
2517     }
2518
2519     VariantClear(&val);
2520     return hres;
2521 }
2522
2523 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2524 {
2525     unary_expression_t *expr = (unary_expression_t*)_expr;
2526     const WCHAR *str = NULL;
2527     exprval_t exprval;
2528     HRESULT hres;
2529
2530     TRACE("\n");
2531
2532     hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2533     if(FAILED(hres))
2534         return hres;
2535
2536     hres = typeof_exprval(ctx, &exprval, ei, &str);
2537     exprval_release(&exprval);
2538     if(FAILED(hres))
2539         return hres;
2540
2541     ret->type = EXPRVAL_VARIANT;
2542     V_VT(&ret->u.var) = VT_BSTR;
2543     V_BSTR(&ret->u.var) = SysAllocString(str);
2544     if(!V_BSTR(&ret->u.var))
2545         return E_OUTOFMEMORY;
2546
2547     return S_OK;
2548 }
2549
2550 /* ECMA-262 3rd Edition    11.4.7 */
2551 static HRESULT interp_minus(exec_ctx_t *ctx)
2552 {
2553     VARIANT n;
2554     HRESULT hres;
2555
2556     TRACE("\n");
2557
2558     hres = stack_pop_number(ctx, &n);
2559     if(FAILED(hres))
2560         return hres;
2561
2562     return stack_push_number(ctx, -num_val(&n));
2563 }
2564
2565 /* ECMA-262 3rd Edition    11.4.6 */
2566 static HRESULT interp_tonum(exec_ctx_t *ctx)
2567 {
2568     VARIANT *v, num;
2569     HRESULT hres;
2570
2571     TRACE("\n");
2572
2573     v = stack_pop(ctx);
2574     hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2575     VariantClear(v);
2576     if(FAILED(hres))
2577         return hres;
2578
2579     return stack_push(ctx, &num);
2580 }
2581
2582 /* ECMA-262 3rd Edition    11.3.1 */
2583 static HRESULT interp_postinc(exec_ctx_t *ctx)
2584 {
2585     const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2586     IDispatch *obj;
2587     DISPID id;
2588     VARIANT v;
2589     HRESULT hres;
2590
2591     TRACE("%d\n", arg);
2592
2593     obj = stack_pop_objid(ctx, &id);
2594     if(!obj)
2595         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2596
2597     hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2598     if(SUCCEEDED(hres)) {
2599         VARIANT n, inc;
2600
2601         hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2602         if(SUCCEEDED(hres)) {
2603             num_set_val(&inc, num_val(&n)+(double)arg);
2604             hres = disp_propput(ctx->parser->script, obj, id, &inc, &ctx->ei, NULL/*FIXME*/);
2605         }
2606         if(FAILED(hres))
2607             VariantClear(&v);
2608     }
2609     IDispatch_Release(obj);
2610     if(FAILED(hres))
2611         return hres;
2612
2613     return stack_push(ctx, &v);
2614 }
2615
2616 /* ECMA-262 3rd Edition    11.4.4, 11.4.5 */
2617 static HRESULT interp_preinc(exec_ctx_t *ctx)
2618 {
2619     const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2620     IDispatch *obj;
2621     DISPID id;
2622     VARIANT v;
2623     HRESULT hres;
2624
2625     TRACE("%d\n", arg);
2626
2627     obj = stack_pop_objid(ctx, &id);
2628     if(!obj)
2629         return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2630
2631     hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2632     if(SUCCEEDED(hres)) {
2633         VARIANT n;
2634
2635         hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2636         VariantClear(&v);
2637         if(SUCCEEDED(hres)) {
2638             num_set_val(&v, num_val(&n)+(double)arg);
2639             hres = disp_propput(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2640         }
2641     }
2642     IDispatch_Release(obj);
2643     if(FAILED(hres))
2644         return hres;
2645
2646     return stack_push(ctx, &v);
2647 }
2648
2649 /* ECMA-262 3rd Edition    11.9.3 */
2650 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2651 {
2652     if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2653        return equal2_values(lval, rval, ret);
2654
2655     /* FIXME: NULL disps should be handled in more general way */
2656     if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2657         VARIANT v;
2658         V_VT(&v) = VT_NULL;
2659         return equal_values(ctx, &v, rval, ei, ret);
2660     }
2661
2662     if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2663         VARIANT v;
2664         V_VT(&v) = VT_NULL;
2665         return equal_values(ctx, lval, &v, ei, ret);
2666     }
2667
2668     if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2669        (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2670         *ret = TRUE;
2671         return S_OK;
2672     }
2673
2674     if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2675         VARIANT v;
2676         HRESULT hres;
2677
2678         hres = to_number(ctx, lval, ei, &v);
2679         if(FAILED(hres))
2680             return hres;
2681
2682         return equal_values(ctx, &v, rval, ei, ret);
2683     }
2684
2685     if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2686         VARIANT v;
2687         HRESULT hres;
2688
2689         hres = to_number(ctx, rval, ei, &v);
2690         if(FAILED(hres))
2691             return hres;
2692
2693         return equal_values(ctx, lval, &v, ei, ret);
2694     }
2695
2696     if(V_VT(rval) == VT_BOOL) {
2697         VARIANT v;
2698
2699         V_VT(&v) = VT_I4;
2700         V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2701         return equal_values(ctx, lval, &v, ei, ret);
2702     }
2703
2704     if(V_VT(lval) == VT_BOOL) {
2705         VARIANT v;
2706
2707         V_VT(&v) = VT_I4;
2708         V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2709         return equal_values(ctx, &v, rval, ei, ret);
2710     }
2711
2712
2713     if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2714         VARIANT v;
2715         HRESULT hres;
2716
2717         hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2718         if(FAILED(hres))
2719             return hres;
2720
2721         hres = equal_values(ctx, lval, &v, ei, ret);
2722
2723         VariantClear(&v);
2724         return hres;
2725     }
2726
2727
2728     if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2729         VARIANT v;
2730         HRESULT hres;
2731
2732         hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2733         if(FAILED(hres))
2734             return hres;
2735
2736         hres = equal_values(ctx, &v, rval, ei, ret);
2737
2738         VariantClear(&v);
2739         return hres;
2740     }
2741
2742
2743     *ret = FALSE;
2744     return S_OK;
2745 }
2746
2747 /* ECMA-262 3rd Edition    11.9.1 */
2748 static HRESULT interp_eq(exec_ctx_t *ctx)
2749 {
2750     VARIANT *l, *r;
2751     BOOL b;
2752     HRESULT hres;
2753
2754     r = stack_pop(ctx);
2755     l = stack_pop(ctx);
2756
2757     TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2758
2759     hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2760     VariantClear(l);
2761     VariantClear(r);
2762     if(FAILED(hres))
2763         return hres;
2764
2765     return stack_push_bool(ctx, b);
2766 }
2767
2768 /* ECMA-262 3rd Edition    11.9.2 */
2769 static HRESULT interp_neq(exec_ctx_t *ctx)
2770 {
2771     VARIANT *l, *r;
2772     BOOL b;
2773     HRESULT hres;
2774
2775     r = stack_pop(ctx);
2776     l = stack_pop(ctx);
2777
2778     TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2779
2780     hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2781     VariantClear(l);
2782     VariantClear(r);
2783     if(FAILED(hres))
2784         return hres;
2785
2786     return stack_push_bool(ctx, !b);
2787 }
2788
2789 /* ECMA-262 3rd Edition    11.9.4 */
2790 static HRESULT interp_eq2(exec_ctx_t *ctx)
2791 {
2792     VARIANT *l, *r;
2793     BOOL b;
2794     HRESULT hres;
2795
2796     TRACE("\n");
2797
2798     r = stack_pop(ctx);
2799     l = stack_pop(ctx);
2800
2801     hres = equal2_values(r, l, &b);
2802     VariantClear(l);
2803     VariantClear(r);
2804     if(FAILED(hres))
2805         return hres;
2806
2807     return stack_push_bool(ctx, b);
2808 }
2809
2810 /* ECMA-262 3rd Edition    11.9.5 */
2811 static HRESULT interp_neq2(exec_ctx_t *ctx)
2812 {
2813     VARIANT *l, *r;
2814     BOOL b;
2815     HRESULT hres;
2816
2817     TRACE("\n");
2818
2819     r = stack_pop(ctx);
2820     l = stack_pop(ctx);
2821
2822     hres = equal2_values(r, l, &b);
2823     VariantClear(l);
2824     VariantClear(r);
2825     if(FAILED(hres))
2826         return hres;
2827
2828     return stack_push_bool(ctx, !b);
2829 }
2830
2831 /* ECMA-262 3rd Edition    11.8.5 */
2832 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2833 {
2834     VARIANT l, r, ln, rn;
2835     HRESULT hres;
2836
2837     hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2838     if(FAILED(hres))
2839         return hres;
2840
2841     hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2842     if(FAILED(hres)) {
2843         VariantClear(&l);
2844         return hres;
2845     }
2846
2847     if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2848         *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2849         SysFreeString(V_BSTR(&l));
2850         SysFreeString(V_BSTR(&r));
2851         return S_OK;
2852     }
2853
2854     hres = to_number(ctx, &l, ei, &ln);
2855     VariantClear(&l);
2856     if(SUCCEEDED(hres))
2857         hres = to_number(ctx, &r, ei, &rn);
2858     VariantClear(&r);
2859     if(FAILED(hres))
2860         return hres;
2861
2862     if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
2863         *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
2864     }else  {
2865         DOUBLE ld = num_val(&ln);
2866         DOUBLE rd = num_val(&rn);
2867
2868         *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
2869     }
2870
2871     return S_OK;
2872 }
2873
2874 /* ECMA-262 3rd Edition    11.8.1 */
2875 static HRESULT interp_lt(exec_ctx_t *ctx)
2876 {
2877     VARIANT *l, *r;
2878     BOOL b;
2879     HRESULT hres;
2880
2881     r = stack_pop(ctx);
2882     l = stack_pop(ctx);
2883
2884     TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2885
2886     hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
2887     VariantClear(l);
2888     VariantClear(r);
2889     if(FAILED(hres))
2890         return hres;
2891
2892     return stack_push_bool(ctx, b);
2893 }
2894
2895 /* ECMA-262 3rd Edition    11.8.1 */
2896 static HRESULT interp_lteq(exec_ctx_t *ctx)
2897 {
2898     VARIANT *l, *r;
2899     BOOL b;
2900     HRESULT hres;
2901
2902     r = stack_pop(ctx);
2903     l = stack_pop(ctx);
2904
2905     TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
2906
2907     hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
2908     VariantClear(l);
2909     VariantClear(r);
2910     if(FAILED(hres))
2911         return hres;
2912
2913     return stack_push_bool(ctx, b);
2914 }
2915
2916 /* ECMA-262 3rd Edition    11.8.2 */
2917 static HRESULT interp_gt(exec_ctx_t *ctx)
2918 {
2919     VARIANT *l, *r;
2920     BOOL b;
2921     HRESULT hres;
2922
2923     r = stack_pop(ctx);
2924     l = stack_pop(ctx);
2925
2926     TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
2927
2928     hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
2929     VariantClear(l);
2930     VariantClear(r);
2931     if(FAILED(hres))
2932         return hres;
2933
2934     return stack_push_bool(ctx, b);
2935 }
2936
2937 /* ECMA-262 3rd Edition    11.8.4 */
2938 static HRESULT interp_gteq(exec_ctx_t *ctx)
2939 {
2940     VARIANT *l, *r;
2941     BOOL b;
2942     HRESULT hres;
2943
2944     r = stack_pop(ctx);
2945     l = stack_pop(ctx);
2946
2947     TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
2948
2949     hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
2950     VariantClear(l);
2951     VariantClear(r);
2952     if(FAILED(hres))
2953         return hres;
2954
2955     return stack_push_bool(ctx, b);
2956 }
2957
2958 /* ECMA-262 3rd Edition    11.4.8 */
2959 static HRESULT interp_bneg(exec_ctx_t *ctx)
2960 {
2961     VARIANT *v, r;
2962     INT i;
2963     HRESULT hres;
2964
2965     TRACE("\n");
2966
2967     v = stack_pop(ctx);
2968     hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
2969     VariantClear(v);
2970     if(FAILED(hres))
2971         return hres;
2972
2973     V_VT(&r) = VT_I4;
2974     V_I4(&r) = ~i;
2975     return stack_push(ctx, &r);
2976 }
2977
2978 /* ECMA-262 3rd Edition    11.4.9 */
2979 static HRESULT interp_neg(exec_ctx_t *ctx)
2980 {
2981     VARIANT *v;
2982     VARIANT_BOOL b;
2983     HRESULT hres;
2984
2985     TRACE("\n");
2986
2987     v = stack_pop(ctx);
2988     hres = to_boolean(v, &b);
2989     VariantClear(v);
2990     if(FAILED(hres))
2991         return hres;
2992
2993     return stack_push_bool(ctx, !b);
2994 }
2995
2996 /* ECMA-262 3rd Edition    11.7.1 */
2997 static HRESULT interp_lshift(exec_ctx_t *ctx)
2998 {
2999     DWORD r;
3000     INT l;
3001     HRESULT hres;
3002
3003     hres = stack_pop_uint(ctx, &r);
3004     if(FAILED(hres))
3005         return hres;
3006
3007     hres = stack_pop_int(ctx, &l);
3008     if(FAILED(hres))
3009         return hres;
3010
3011     return stack_push_int(ctx, l << (r&0x1f));
3012 }
3013
3014 /* ECMA-262 3rd Edition    11.7.2 */
3015 static HRESULT interp_rshift(exec_ctx_t *ctx)
3016 {
3017     DWORD r;
3018     INT l;
3019     HRESULT hres;
3020
3021     hres = stack_pop_uint(ctx, &r);
3022     if(FAILED(hres))
3023         return hres;
3024
3025     hres = stack_pop_int(ctx, &l);
3026     if(FAILED(hres))
3027         return hres;
3028
3029     return stack_push_int(ctx, l >> (r&0x1f));
3030 }
3031
3032 /* ECMA-262 3rd Edition    11.7.3 */
3033 static HRESULT interp_rshift2(exec_ctx_t *ctx)
3034 {
3035     DWORD r, l;
3036     HRESULT hres;
3037
3038     hres = stack_pop_uint(ctx, &r);
3039     if(FAILED(hres))
3040         return hres;
3041
3042     hres = stack_pop_uint(ctx, &l);
3043     if(FAILED(hres))
3044         return hres;
3045
3046     return stack_push_int(ctx, l >> (r&0x1f));
3047 }
3048
3049 /* ECMA-262 3rd Edition    11.13.1 */
3050 static HRESULT interp_assign(exec_ctx_t *ctx)
3051 {
3052     IDispatch *disp;
3053     DISPID id;
3054     VARIANT *v;
3055     HRESULT hres;
3056
3057     TRACE("\n");
3058
3059     v = stack_pop(ctx);
3060     disp = stack_pop_objid(ctx, &id);
3061
3062     if(!disp)
3063         return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3064
3065     hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3066     IDispatch_Release(disp);
3067     if(FAILED(hres)) {
3068         VariantClear(v);
3069         return hres;
3070     }
3071
3072     return stack_push(ctx, v);
3073 }
3074
3075 static HRESULT interp_undefined(exec_ctx_t *ctx)
3076 {
3077     VARIANT v;
3078
3079     TRACE("\n");
3080
3081     V_VT(&v) = VT_EMPTY;
3082     return stack_push(ctx, &v);
3083 }
3084
3085 static HRESULT interp_jmp(exec_ctx_t *ctx)
3086 {
3087     const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3088
3089     TRACE("\n");
3090
3091     ctx->ip = arg;
3092     return S_OK;
3093 }
3094
3095 static HRESULT interp_pop(exec_ctx_t *ctx)
3096 {
3097     TRACE("\n");
3098
3099     stack_popn(ctx, 1);
3100     return S_OK;
3101 }
3102
3103 static HRESULT interp_ret(exec_ctx_t *ctx)
3104 {
3105     TRACE("\n");
3106
3107     ctx->ip = -1;
3108     return S_OK;
3109 }
3110
3111 static HRESULT interp_tree(exec_ctx_t *ctx)
3112 {
3113     instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3114     exprval_t val;
3115     VARIANT v;
3116     HRESULT hres;
3117
3118     TRACE("\n");
3119
3120     hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3121     if(FAILED(hres))
3122         return hres;
3123
3124     hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3125     exprval_release(&val);
3126     if(FAILED(hres))
3127         return hres;
3128
3129     return stack_push(ctx, &v);
3130 }
3131
3132 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3133
3134 static const op_func_t op_funcs[] = {
3135 #define X(x,a,b,c) interp_##x,
3136 OP_LIST
3137 #undef X
3138 };
3139
3140 static const unsigned op_move[] = {
3141 #define X(a,x,b,c) x,
3142 OP_LIST
3143 #undef X
3144 };
3145
3146 static HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3147 {
3148     exec_ctx_t *exec_ctx = ctx->exec_ctx;
3149     unsigned prev_ip, prev_top;
3150     jsop_t op;
3151     HRESULT hres = S_OK;
3152
3153     TRACE("\n");
3154
3155     prev_top = exec_ctx->top;
3156     prev_ip = exec_ctx->ip;
3157     exec_ctx->ip = expr->instr_off;
3158
3159     while(exec_ctx->ip != -1) {
3160         op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3161         hres = op_funcs[op](exec_ctx);
3162         if(FAILED(hres))
3163             break;
3164         exec_ctx->ip += op_move[op];
3165     }
3166
3167     exec_ctx->ip = prev_ip;
3168
3169     if(FAILED(hres)) {
3170         stack_popn(exec_ctx, exec_ctx->top-prev_top);
3171         *ei = exec_ctx->ei;
3172         memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3173         return hres;
3174     }
3175
3176     assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3177
3178     ret->type = EXPRVAL_VARIANT;
3179     if(exec_ctx->top == prev_top)
3180         V_VT(&ret->u.var) = VT_EMPTY;
3181     else
3182         ret->u.var = *stack_pop(exec_ctx);
3183     return S_OK;
3184 }
3185
3186 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3187 {
3188     HRESULT hres;
3189
3190     TRACE("\n");
3191
3192     hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
3193     if(FAILED(hres))
3194         return hres;
3195
3196     if(expr->eval == compiled_expression_eval)
3197         expr->eval = interp_expression_eval;
3198
3199     return expr->eval(ctx, expr, flags, ei, ret);
3200 }