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