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