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