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