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