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