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