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