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