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