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