?  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
blobc9ad5195cd046f9cf2686f8cd70387c8e1e73957
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 div_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2444 {
2445 VARIANT lnum, rnum;
2446 HRESULT hres;
2447
2448 hres = to_number(ctx, lval, ei, &lnum);
2449 if(FAILED(hres))
2450 return hres;
2451
2452 hres = to_number(ctx, rval, ei, &rnum);
2453 if(FAILED(hres))
2454 return hres;
2455
2456 num_set_val(retv, num_val(&lnum) / num_val(&rnum));
2457 return S_OK;
2458 }
2459
2460 /* ECMA-262 3rd Edition 11.5.2 */
2461 static HRESULT interp_div(exec_ctx_t *ctx)
2462 {
2463 VARIANT l, r;
2464 HRESULT hres;
2465
2466 TRACE("\n");
2467
2468 hres = stack_pop_number(ctx, &r);
2469 if(FAILED(hres))
2470 return hres;
2471
2472 hres = stack_pop_number(ctx, &l);
2473 if(FAILED(hres))
2474 return hres;
2475
2476 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2477 }
2478
2479 /* ECMA-262 3rd Edition 11.5.3 */
2480 static HRESULT mod_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2481 {
2482 VARIANT lnum, rnum;
2483 HRESULT hres;
2484
2485 hres = to_number(ctx, lval, ei, &lnum);
2486 if(FAILED(hres))
2487 return hres;
2488
2489 hres = to_number(ctx, rval, ei, &rnum);
2490 if(FAILED(hres))
2491 return hres;
2492
2493 num_set_val(retv, fmod(num_val(&lnum), num_val(&rnum)));
2494 return S_OK;
2495 }
2496
2497 /* ECMA-262 3rd Edition 11.5.3 */
2498 static HRESULT interp_mod(exec_ctx_t *ctx)
2499 {
2500 VARIANT l, r;
2501 HRESULT hres;
2502
2503 TRACE("\n");
2504
2505 hres = stack_pop_number(ctx, &r);
2506 if(FAILED(hres))
2507 return hres;
2508
2509 hres = stack_pop_number(ctx, &l);
2510 if(FAILED(hres))
2511 return hres;
2512
2513 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2514 }
2515
2516 /* ECMA-262 3rd Edition 11.4.2 */
2517 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2518 {
2519 unary_expression_t *expr = (unary_expression_t*)_expr;
2520 VARIANT_BOOL b = VARIANT_FALSE;
2521 exprval_t exprval;
2522 HRESULT hres;
2523
2524 TRACE("\n");
2525
2526 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2527 if(FAILED(hres))
2528 return hres;
2529
2530 switch(exprval.type) {
2531 case EXPRVAL_IDREF: {
2532 IDispatchEx *dispex;
2533
2534 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2535 if(SUCCEEDED(hres)) {
2536 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2537 b = VARIANT_TRUE;
2538 IDispatchEx_Release(dispex);
2539 }
2540 break;
2541 }
2542 default:
2543 FIXME("unsupported type %d\n", exprval.type);
2544 hres = E_NOTIMPL;
2545 }
2546
2547 exprval_release(&exprval);
2548 if(FAILED(hres))
2549 return hres;
2550
2551 return return_bool(ret, b);
2552 }
2553
2554 /* ECMA-262 3rd Edition 11.4.2 */
2555 static HRESULT interp_delete(exec_ctx_t *ctx)
2556 {
2557 VARIANT *obj_var, *name_var;
2558 IDispatchEx *dispex;
2559 IDispatch *obj;
2560 BSTR name;
2561 BOOL ret;
2562 HRESULT hres;
2563
2564 TRACE("\n");
2565
2566 name_var = stack_pop(ctx);
2567 obj_var = stack_pop(ctx);
2568
2569 hres = to_object(ctx->parser->script, obj_var, &obj);
2570 VariantClear(obj_var);
2571 if(FAILED(hres)) {
2572 VariantClear(name_var);
2573 return hres;
2574 }
2575
2576 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2577 VariantClear(name_var);
2578 if(FAILED(hres)) {
2579 IDispatch_Release(obj);
2580 return hres;
2581 }
2582
2583 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2584 if(SUCCEEDED(hres)) {
2585 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2586 ret = TRUE;
2587 IDispatchEx_Release(dispex);
2588 }else {
2589 hres = S_OK;
2590 ret = FALSE;
2591 }
2592
2593 IDispatch_Release(obj);
2594 SysFreeString(name);
2595 if(FAILED(hres))
2596 return hres;
2597
2598 return stack_push_bool(ctx, ret);
2599 }
2600
2601 /* ECMA-262 3rd Edition 11.4.2 */
2602 static HRESULT interp_void(exec_ctx_t *ctx)
2603 {
2604 VARIANT v;
2605
2606 TRACE("\n");
2607
2608 stack_popn(ctx, 1);
2609
2610 V_VT(&v) = VT_EMPTY;
2611 return stack_push(ctx, &v);
2612 }
2613
2614 /* ECMA-262 3rd Edition 11.4.3 */
2615 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2616 {
2617 VARIANT val;
2618 HRESULT hres;
2619
2620 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2621 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2622 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2623 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2624 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2625 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2626 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2627
2628 if(exprval->type == EXPRVAL_INVALID) {
2629 *ret = undefinedW;
2630 return S_OK;
2631 }
2632
2633 hres = exprval_to_value(ctx, exprval, ei, &val);
2634 if(FAILED(hres)) {
2635 if(exprval->type == EXPRVAL_IDREF) {
2636 *ret = unknownW;
2637 return S_OK;
2638 }
2639 return hres;
2640 }
2641
2642 switch(V_VT(&val)) {
2643 case VT_EMPTY:
2644 *ret = undefinedW;
2645 break;
2646 case VT_NULL:
2647 *ret = objectW;
2648 break;
2649 case VT_BOOL:
2650 *ret = booleanW;
2651 break;
2652 case VT_I4:
2653 case VT_R8:
2654 *ret = numberW;
2655 break;
2656 case VT_BSTR:
2657 *ret = stringW;
2658 break;
2659 case VT_DISPATCH: {
2660 jsdisp_t *dispex;
2661
2662 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2663 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2664 jsdisp_release(dispex);
2665 }else {
2666 *ret = objectW;
2667 }
2668 break;
2669 }
2670 default:
2671 FIXME("unhandled vt %d\n", V_VT(&val));
2672 hres = E_NOTIMPL;
2673 }
2674
2675 VariantClear(&val);
2676 return hres;
2677 }
2678
2679 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2680 {
2681 unary_expression_t *expr = (unary_expression_t*)_expr;
2682 const WCHAR *str = NULL;
2683 exprval_t exprval;
2684 HRESULT hres;
2685
2686 TRACE("\n");
2687
2688 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2689 if(FAILED(hres))
2690 return hres;
2691
2692 hres = typeof_exprval(ctx, &exprval, ei, &str);
2693 exprval_release(&exprval);
2694 if(FAILED(hres))
2695 return hres;
2696
2697 ret->type = EXPRVAL_VARIANT;
2698 V_VT(&ret->u.var) = VT_BSTR;
2699 V_BSTR(&ret->u.var) = SysAllocString(str);
2700 if(!V_BSTR(&ret->u.var))
2701 return E_OUTOFMEMORY;
2702
2703 return S_OK;
2704 }
2705
2706 /* ECMA-262 3rd Edition 11.4.7 */
2707 static HRESULT interp_minus(exec_ctx_t *ctx)
2708 {
2709 VARIANT n;
2710 HRESULT hres;
2711
2712 TRACE("\n");
2713
2714 hres = stack_pop_number(ctx, &n);
2715 if(FAILED(hres))
2716 return hres;
2717
2718 return stack_push_number(ctx, -num_val(&n));
2719 }
2720
2721 /* ECMA-262 3rd Edition 11.4.6 */
2722 static HRESULT interp_tonum(exec_ctx_t *ctx)
2723 {
2724 VARIANT *v, num;
2725 HRESULT hres;
2726
2727 TRACE("\n");
2728
2729 v = stack_pop(ctx);
2730 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2731 VariantClear(v);
2732 if(FAILED(hres))
2733 return hres;
2734
2735 return stack_push(ctx, &num);
2736 }
2737
2738 /* ECMA-262 3rd Edition 11.3.1 */
2739 HRESULT post_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2740 {
2741 unary_expression_t *expr = (unary_expression_t*)_expr;
2742 VARIANT val, num;
2743 exprval_t exprval;
2744 HRESULT hres;
2745
2746 TRACE("\n");
2747
2748 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2749 if(FAILED(hres))
2750 return hres;
2751
2752 hres = exprval_value(ctx, &exprval, ei, &val);
2753 if(SUCCEEDED(hres)) {
2754 hres = to_number(ctx, &val, ei, &num);
2755 VariantClear(&val);
2756 }
2757
2758 if(SUCCEEDED(hres)) {
2759 VARIANT inc;
2760 num_set_val(&inc, num_val(&num)+1.0);
2761 hres = put_value(ctx, &exprval, &inc, ei);
2762 }
2763
2764 exprval_release(&exprval);
2765 if(FAILED(hres))
2766 return hres;
2767
2768 ret->type = EXPRVAL_VARIANT;
2769 ret->u.var = num;
2770 return S_OK;
2771 }
2772
2773 /* ECMA-262 3rd Edition 11.3.2 */
2774 HRESULT post_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2775 {
2776 unary_expression_t *expr = (unary_expression_t*)_expr;
2777 VARIANT val, num;
2778 exprval_t exprval;
2779 HRESULT hres;
2780
2781 TRACE("\n");
2782
2783 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2784 if(FAILED(hres))
2785 return hres;
2786
2787 hres = exprval_value(ctx, &exprval, ei, &val);
2788 if(SUCCEEDED(hres)) {
2789 hres = to_number(ctx, &val, ei, &num);
2790 VariantClear(&val);
2791 }
2792
2793 if(SUCCEEDED(hres)) {
2794 VARIANT dec;
2795 num_set_val(&dec, num_val(&num)-1.0);
2796 hres = put_value(ctx, &exprval, &dec, ei);
2797 }
2798
2799 exprval_release(&exprval);
2800 if(FAILED(hres))
2801 return hres;
2802
2803 ret->type = EXPRVAL_VARIANT;
2804 ret->u.var = num;
2805 return S_OK;
2806 }
2807
2808 /* ECMA-262 3rd Edition 11.4.4 */
2809 HRESULT pre_increment_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2810 {
2811 unary_expression_t *expr = (unary_expression_t*)_expr;
2812 VARIANT val, num;
2813 exprval_t exprval;
2814 HRESULT hres;
2815
2816 TRACE("\n");
2817
2818 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2819 if(FAILED(hres))
2820 return hres;
2821
2822 hres = exprval_value(ctx, &exprval, ei, &val);
2823 if(SUCCEEDED(hres)) {
2824 hres = to_number(ctx, &val, ei, &num);
2825 VariantClear(&val);
2826 }
2827
2828 if(SUCCEEDED(hres)) {
2829 num_set_val(&val, num_val(&num)+1.0);
2830 hres = put_value(ctx, &exprval, &val, ei);
2831 }
2832
2833 exprval_release(&exprval);
2834 if(FAILED(hres))
2835 return hres;
2836
2837 ret->type = EXPRVAL_VARIANT;
2838 ret->u.var = val;
2839 return S_OK;
2840 }
2841
2842 /* ECMA-262 3rd Edition 11.4.5 */
2843 HRESULT pre_decrement_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2844 {
2845 unary_expression_t *expr = (unary_expression_t*)_expr;
2846 VARIANT val, num;
2847 exprval_t exprval;
2848 HRESULT hres;
2849
2850 TRACE("\n");
2851
2852 hres = expr_eval(ctx, expr->expression, EXPR_NEWREF, ei, &exprval);
2853 if(FAILED(hres))
2854 return hres;
2855
2856 hres = exprval_value(ctx, &exprval, ei, &val);
2857 if(SUCCEEDED(hres)) {
2858 hres = to_number(ctx, &val, ei, &num);
2859 VariantClear(&val);
2860 }
2861
2862 if(SUCCEEDED(hres)) {
2863 num_set_val(&val, num_val(&num)-1.0);
2864 hres = put_value(ctx, &exprval, &val, ei);
2865 }
2866
2867 exprval_release(&exprval);
2868 if(FAILED(hres))
2869 return hres;
2870
2871 ret->type = EXPRVAL_VARIANT;
2872 ret->u.var = val;
2873 return S_OK;
2874 }
2875
2876 /* ECMA-262 3rd Edition 11.9.3 */
2877 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2878 {
2879 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2880 return equal2_values(lval, rval, ret);
2881
2882 /* FIXME: NULL disps should be handled in more general way */
2883 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2884 VARIANT v;
2885 V_VT(&v) = VT_NULL;
2886 return equal_values(ctx, &v, rval, ei, ret);
2887 }
2888
2889 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2890 VARIANT v;
2891 V_VT(&v) = VT_NULL;
2892 return equal_values(ctx, lval, &v, ei, ret);
2893 }
2894
2895 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2896 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2897 *ret = TRUE;
2898 return S_OK;
2899 }
2900
2901 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2902 VARIANT v;
2903 HRESULT hres;
2904
2905 hres = to_number(ctx, lval, ei, &v);
2906 if(FAILED(hres))
2907 return hres;
2908
2909 return equal_values(ctx, &v, rval, ei, ret);
2910 }
2911
2912 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2913 VARIANT v;
2914 HRESULT hres;
2915
2916 hres = to_number(ctx, rval, ei, &v);
2917 if(FAILED(hres))
2918 return hres;
2919
2920 return equal_values(ctx, lval, &v, ei, ret);
2921 }
2922
2923 if(V_VT(rval) == VT_BOOL) {
2924 VARIANT v;
2925
2926 V_VT(&v) = VT_I4;
2927 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2928 return equal_values(ctx, lval, &v, ei, ret);
2929 }
2930
2931 if(V_VT(lval) == VT_BOOL) {
2932 VARIANT v;
2933
2934 V_VT(&v) = VT_I4;
2935 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2936 return equal_values(ctx, &v, rval, ei, ret);
2937 }
2938
2939
2940 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2941 VARIANT v;
2942 HRESULT hres;
2943
2944 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2945 if(FAILED(hres))
2946 return hres;
2947
2948 hres = equal_values(ctx, lval, &v, ei, ret);
2949
2950 VariantClear(&v);
2951 return hres;
2952 }
2953
2954
2955 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2956 VARIANT v;
2957 HRESULT hres;
2958
2959 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2960 if(FAILED(hres))
2961 return hres;
2962
2963 hres = equal_values(ctx, &v, rval, ei, ret);
2964
2965 VariantClear(&v);
2966 return hres;
2967 }
2968
2969
2970 *ret = FALSE;
2971 return S_OK;
2972 }
2973
2974 /* ECMA-262 3rd Edition 11.9.1 */
2975 static HRESULT interp_eq(exec_ctx_t *ctx)
2976 {
2977 VARIANT *l, *r;
2978 BOOL b;
2979 HRESULT hres;
2980
2981 r = stack_pop(ctx);
2982 l = stack_pop(ctx);
2983
2984 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2985
2986 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2987 VariantClear(l);
2988 VariantClear(r);
2989 if(FAILED(hres))
2990 return hres;
2991
2992 return stack_push_bool(ctx, b);
2993 }
2994
2995 /* ECMA-262 3rd Edition 11.9.2 */
2996 static HRESULT interp_neq(exec_ctx_t *ctx)
2997 {
2998 VARIANT *l, *r;
2999 BOOL b;
3000 HRESULT hres;
3001
3002 r = stack_pop(ctx);
3003 l = stack_pop(ctx);
3004
3005 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
3006
3007 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
3008 VariantClear(l);
3009 VariantClear(r);
3010 if(FAILED(hres))
3011 return hres;
3012
3013 return stack_push_bool(ctx, !b);
3014 }
3015
3016 /* ECMA-262 3rd Edition 11.9.4 */
3017 static HRESULT interp_eq2(exec_ctx_t *ctx)
3018 {
3019 VARIANT *l, *r;
3020 BOOL b;
3021 HRESULT hres;
3022
3023 TRACE("\n");
3024
3025 r = stack_pop(ctx);
3026 l = stack_pop(ctx);
3027
3028 hres = equal2_values(r, l, &b);
3029 VariantClear(l);
3030 VariantClear(r);
3031 if(FAILED(hres))
3032 return hres;
3033
3034 return stack_push_bool(ctx, b);
3035 }
3036
3037 /* ECMA-262 3rd Edition 11.9.5 */
3038 static HRESULT interp_neq2(exec_ctx_t *ctx)
3039 {
3040 VARIANT *l, *r;
3041 BOOL b;
3042 HRESULT hres;
3043
3044 TRACE("\n");
3045
3046 r = stack_pop(ctx);
3047 l = stack_pop(ctx);
3048
3049 hres = equal2_values(r, l, &b);
3050 VariantClear(l);
3051 VariantClear(r);
3052 if(FAILED(hres))
3053 return hres;
3054
3055 return stack_push_bool(ctx, !b);
3056 }
3057
3058 /* ECMA-262 3rd Edition 11.8.5 */
3059 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
3060 {
3061 VARIANT l, r, ln, rn;
3062 HRESULT hres;
3063
3064 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
3065 if(FAILED(hres))
3066 return hres;
3067
3068 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
3069 if(FAILED(hres)) {
3070 VariantClear(&l);
3071 return hres;
3072 }
3073
3074 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
3075 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
3076 SysFreeString(V_BSTR(&l));
3077 SysFreeString(V_BSTR(&r));
3078 return S_OK;
3079 }
3080
3081 hres = to_number(ctx, &l, ei, &ln);
3082 VariantClear(&l);
3083 if(SUCCEEDED(hres))
3084 hres = to_number(ctx, &r, ei, &rn);
3085 VariantClear(&r);
3086 if(FAILED(hres))
3087 return hres;
3088
3089 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
3090 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
3091 }else {
3092 DOUBLE ld = num_val(&ln);
3093 DOUBLE rd = num_val(&rn);
3094
3095 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
3096 }
3097
3098 return S_OK;
3099 }
3100
3101 /* ECMA-262 3rd Edition 11.8.1 */
3102 static HRESULT interp_lt(exec_ctx_t *ctx)
3103 {
3104 VARIANT *l, *r;
3105 BOOL b;
3106 HRESULT hres;
3107
3108 r = stack_pop(ctx);
3109 l = stack_pop(ctx);
3110
3111 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
3112
3113 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
3114 VariantClear(l);
3115 VariantClear(r);
3116 if(FAILED(hres))
3117 return hres;
3118
3119 return stack_push_bool(ctx, b);
3120 }
3121
3122 /* ECMA-262 3rd Edition 11.8.1 */
3123 static HRESULT interp_lteq(exec_ctx_t *ctx)
3124 {
3125 VARIANT *l, *r;
3126 BOOL b;
3127 HRESULT hres;
3128
3129 r = stack_pop(ctx);
3130 l = stack_pop(ctx);
3131
3132 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
3133
3134 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
3135 VariantClear(l);
3136 VariantClear(r);
3137 if(FAILED(hres))
3138 return hres;
3139
3140 return stack_push_bool(ctx, b);
3141 }
3142
3143 /* ECMA-262 3rd Edition 11.8.2 */
3144 static HRESULT interp_gt(exec_ctx_t *ctx)
3145 {
3146 VARIANT *l, *r;
3147 BOOL b;
3148 HRESULT hres;
3149
3150 r = stack_pop(ctx);
3151 l = stack_pop(ctx);
3152
3153 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
3154
3155 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
3156 VariantClear(l);
3157 VariantClear(r);
3158 if(FAILED(hres))
3159 return hres;
3160
3161 return stack_push_bool(ctx, b);
3162 }
3163
3164 /* ECMA-262 3rd Edition 11.8.4 */
3165 static HRESULT interp_gteq(exec_ctx_t *ctx)
3166 {
3167 VARIANT *l, *r;
3168 BOOL b;
3169 HRESULT hres;
3170
3171 r = stack_pop(ctx);
3172 l = stack_pop(ctx);
3173
3174 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
3175
3176 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
3177 VariantClear(l);
3178 VariantClear(r);
3179 if(FAILED(hres))
3180 return hres;
3181
3182 return stack_push_bool(ctx, b);
3183 }
3184
3185 /* ECMA-262 3rd Edition 11.4.8 */
3186 static HRESULT interp_bneg(exec_ctx_t *ctx)
3187 {
3188 VARIANT *v, r;
3189 INT i;
3190 HRESULT hres;
3191
3192 TRACE("\n");
3193
3194 v = stack_pop(ctx);
3195 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3196 VariantClear(v);
3197 if(FAILED(hres))
3198 return hres;
3199
3200 V_VT(&r) = VT_I4;
3201 V_I4(&r) = ~i;
3202 return stack_push(ctx, &r);
3203 }
3204
3205 /* ECMA-262 3rd Edition 11.4.9 */
3206 static HRESULT interp_neg(exec_ctx_t *ctx)
3207 {
3208 VARIANT *v;
3209 VARIANT_BOOL b;
3210 HRESULT hres;
3211
3212 TRACE("\n");
3213
3214 v = stack_pop(ctx);
3215 hres = to_boolean(v, &b);
3216 VariantClear(v);
3217 if(FAILED(hres))
3218 return hres;
3219
3220 return stack_push_bool(ctx, !b);
3221 }
3222
3223 /* ECMA-262 3rd Edition 11.7.1 */
3224 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3225 {
3226 DWORD ri;
3227 INT li;
3228 HRESULT hres;
3229
3230 hres = to_int32(ctx, lval, ei, &li);
3231 if(FAILED(hres))
3232 return hres;
3233
3234 hres = to_uint32(ctx, rval, ei, &ri);
3235 if(FAILED(hres))
3236 return hres;
3237
3238 V_VT(retv) = VT_I4;
3239 V_I4(retv) = li << (ri&0x1f);
3240 return S_OK;
3241 }
3242
3243 /* ECMA-262 3rd Edition 11.7.1 */
3244 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3245 {
3246 binary_expression_t *expr = (binary_expression_t*)_expr;
3247
3248 TRACE("\n");
3249
3250 return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3251 }
3252
3253 /* ECMA-262 3rd Edition 11.7.2 */
3254 static HRESULT rshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3255 {
3256 DWORD ri;
3257 INT li;
3258 HRESULT hres;
3259
3260 hres = to_int32(ctx, lval, ei, &li);
3261 if(FAILED(hres))
3262 return hres;
3263
3264 hres = to_uint32(ctx, rval, ei, &ri);
3265 if(FAILED(hres))
3266 return hres;
3267
3268 V_VT(retv) = VT_I4;
3269 V_I4(retv) = li >> (ri&0x1f);
3270 return S_OK;
3271 }
3272
3273 /* ECMA-262 3rd Edition 11.7.2 */
3274 HRESULT right_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3275 {
3276 binary_expression_t *expr = (binary_expression_t*)_expr;
3277
3278 TRACE("\n");
3279
3280 return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
3281 }
3282
3283 /* ECMA-262 3rd Edition 11.7.3 */
3284 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3285 {
3286 DWORD li, ri;
3287 HRESULT hres;
3288
3289 hres = to_uint32(ctx, lval, ei, &li);
3290 if(FAILED(hres))
3291 return hres;
3292
3293 hres = to_uint32(ctx, rval, ei, &ri);
3294 if(FAILED(hres))
3295 return hres;
3296
3297 V_VT(retv) = VT_I4;
3298 V_I4(retv) = li >> (ri&0x1f);
3299 return S_OK;
3300 }
3301
3302 /* ECMA-262 3rd Edition 11.7.3 */
3303 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3304 {
3305 binary_expression_t *expr = (binary_expression_t*)_expr;
3306
3307 TRACE("\n");
3308
3309 return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3310 }
3311
3312 /* ECMA-262 3rd Edition 11.13.1 */
3313 static HRESULT interp_assign(exec_ctx_t *ctx)
3314 {
3315 IDispatch *disp;
3316 DISPID id;
3317 VARIANT *v;
3318 HRESULT hres;
3319
3320 TRACE("\n");
3321
3322 v = stack_pop(ctx);
3323 disp = stack_pop_objid(ctx, &id);
3324
3325 if(!disp)
3326 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3327
3328 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3329 IDispatch_Release(disp);
3330 if(FAILED(hres)) {
3331 VariantClear(v);
3332 return hres;
3333 }
3334
3335 return stack_push(ctx, v);
3336 }
3337
3338 /* ECMA-262 3rd Edition 11.13.2 */
3339 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3340 {
3341 binary_expression_t *expr = (binary_expression_t*)_expr;
3342
3343 TRACE("\n");
3344
3345 return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3346 }
3347
3348 /* ECMA-262 3rd Edition 11.13.2 */
3349 HRESULT assign_rshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3350 {
3351 binary_expression_t *expr = (binary_expression_t*)_expr;
3352
3353 TRACE("\n");
3354
3355 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
3356 }
3357
3358 /* ECMA-262 3rd Edition 11.13.2 */
3359 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3360 {
3361 binary_expression_t *expr = (binary_expression_t*)_expr;
3362
3363 TRACE("\n");
3364
3365 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3366 }
3367
3368 /* ECMA-262 3rd Edition 11.13.2 */
3369 HRESULT assign_div_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3370 {
3371 binary_expression_t *expr = (binary_expression_t*)_expr;
3372
3373 TRACE("\n");
3374
3375 return assign_oper_eval(ctx, expr->expression1, expr->expression2, div_eval, ei, ret);
3376 }
3377
3378 /* ECMA-262 3rd Edition 11.13.2 */
3379 HRESULT assign_mod_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3380 {
3381 binary_expression_t *expr = (binary_expression_t*)_expr;
3382
3383 TRACE("\n");
3384
3385 return assign_oper_eval(ctx, expr->expression1, expr->expression2, mod_eval, ei, ret);
3386 }
3387
3388 /* ECMA-262 3rd Edition 11.13.2 */
3389 HRESULT assign_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3390 {
3391 binary_expression_t *expr = (binary_expression_t*)_expr;
3392
3393 TRACE("\n");
3394
3395 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
3396 }
3397
3398 /* ECMA-262 3rd Edition 11.13.2 */
3399 HRESULT assign_or_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3400 {
3401 binary_expression_t *expr = (binary_expression_t*)_expr;
3402
3403 TRACE("\n");
3404
3405 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitor_eval, ei, ret);
3406 }
3407
3408 /* ECMA-262 3rd Edition 11.13.2 */
3409 HRESULT assign_xor_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3410 {
3411 binary_expression_t *expr = (binary_expression_t*)_expr;
3412
3413 TRACE("\n");
3414
3415 return assign_oper_eval(ctx, expr->expression1, expr->expression2, xor_eval, ei, ret);
3416 }
3417
3418 static HRESULT interp_jmp(exec_ctx_t *ctx)
3419 {
3420 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3421
3422 TRACE("\n");
3423
3424 ctx->ip = arg;
3425 return S_OK;
3426 }
3427
3428 static HRESULT interp_pop(exec_ctx_t *ctx)
3429 {
3430 TRACE("\n");
3431
3432 stack_popn(ctx, 1);
3433 return S_OK;
3434 }
3435
3436 static HRESULT interp_ret(exec_ctx_t *ctx)
3437 {
3438 TRACE("\n");
3439
3440 ctx->ip = -1;
3441 return S_OK;
3442 }
3443
3444 static HRESULT interp_tree(exec_ctx_t *ctx)
3445 {
3446 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3447 exprval_t val;
3448 VARIANT v;
3449 HRESULT hres;
3450
3451 TRACE("\n");
3452
3453 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3454 if(FAILED(hres))
3455 return hres;
3456
3457 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3458 exprval_release(&val);
3459 if(FAILED(hres))
3460 return hres;
3461
3462 return stack_push(ctx, &v);
3463 }
3464
3465 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3466
3467 static const op_func_t op_funcs[] = {
3468 #define X(x,a,b,c) interp_##x,
3469 OP_LIST
3470 #undef X
3471 };
3472
3473 static const unsigned op_move[] = {
3474 #define X(a,x,b,c) x,
3475 OP_LIST
3476 #undef X
3477 };
3478
3479 HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3480 {
3481 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3482 unsigned prev_ip, prev_top;
3483 jsop_t op;
3484 HRESULT hres = S_OK;
3485
3486 TRACE("\n");
3487
3488 prev_top = exec_ctx->top;
3489 prev_ip = exec_ctx->ip;
3490 exec_ctx->ip = expr->instr_off;
3491
3492 while(exec_ctx->ip != -1) {
3493 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3494 hres = op_funcs[op](exec_ctx);
3495 if(FAILED(hres))
3496 break;
3497 exec_ctx->ip += op_move[op];
3498 }
3499
3500 exec_ctx->ip = prev_ip;
3501
3502 if(FAILED(hres)) {
3503 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3504 *ei = exec_ctx->ei;
3505 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3506 return hres;
3507 }
3508
3509 assert(exec_ctx->top == prev_top+1);
3510
3511 ret->type = EXPRVAL_VARIANT;
3512 ret->u.var = *stack_pop(exec_ctx);
3513 return S_OK;
3514 }
3515
3516 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3517 {
3518 HRESULT hres;
3519
3520 TRACE("\n");
3521
3522 hres = compile_subscript(ctx->exec_ctx->parser, expr, &expr->instr_off);
3523 if(FAILED(hres))
3524 return hres;
3525
3526 if(expr->eval == compiled_expression_eval)
3527 expr->eval = interp_expression_eval;
3528
3529 return expr->eval(ctx, expr, flags, ei, ret);
3530 }
Maarten's multimedia branch