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