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