?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
jscript: Use bytecode for binary and implementation.
[wine/multimedia.git] / dlls / jscript / engine.c
blob50aab416b66fe015e8f13e418d41e5f967ec7860
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 static HRESULT interp_carray(exec_ctx_t *ctx)
2005 {
2006 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2007 jsdisp_t *array;
2008 VARIANT *v, r;
2009 unsigned i;
2010 HRESULT hres;
2011
2012 TRACE("%u\n", arg);
2013
2014 hres = create_array(ctx->parser->script, arg, &array);
2015 if(FAILED(hres))
2016 return hres;
2017
2018 i = arg;
2019 while(i--) {
2020 v = stack_pop(ctx);
2021 hres = jsdisp_propput_idx(array, i, v, &ctx->ei, NULL/*FIXME*/);
2022 VariantClear(v);
2023 if(FAILED(hres)) {
2024 jsdisp_release(array);
2025 return hres;
2026 }
2027 }
2028
2029 var_set_jsdisp(&r, array);
2030 return stack_push(ctx, &r);
2031 }
2032
2033 /* ECMA-262 3rd Edition 11.1.5 */
2034 HRESULT property_value_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2035 {
2036 property_value_expression_t *expr = (property_value_expression_t*)_expr;
2037 VARIANT val, tmp;
2038 jsdisp_t *obj;
2039 prop_val_t *iter;
2040 exprval_t exprval;
2041 BSTR name;
2042 HRESULT hres;
2043
2044 TRACE("\n");
2045
2046 hres = create_object(ctx, NULL, &obj);
2047 if(FAILED(hres))
2048 return hres;
2049
2050 for(iter = expr->property_list; iter; iter = iter->next) {
2051 hres = literal_to_var(ctx, iter->name, &tmp);
2052 if(FAILED(hres))
2053 break;
2054
2055 hres = to_string(ctx, &tmp, ei, &name);
2056 VariantClear(&tmp);
2057 if(FAILED(hres))
2058 break;
2059
2060 hres = expr_eval(ctx, iter->value, 0, ei, &exprval);
2061 if(SUCCEEDED(hres)) {
2062 hres = exprval_to_value(ctx, &exprval, ei, &val);
2063 exprval_release(&exprval);
2064 if(SUCCEEDED(hres)) {
2065 hres = jsdisp_propput_name(obj, name, &val, ei, NULL/*FIXME*/);
2066 VariantClear(&val);
2067 }
2068 }
2069
2070 SysFreeString(name);
2071 if(FAILED(hres))
2072 break;
2073 }
2074
2075 if(FAILED(hres)) {
2076 jsdisp_release(obj);
2077 return hres;
2078 }
2079
2080 ret->type = EXPRVAL_VARIANT;
2081 var_set_jsdisp(&ret->u.var, obj);
2082 return S_OK;
2083 }
2084
2085 /* ECMA-262 3rd Edition 11.11 */
2086 static HRESULT interp_jmp_nz(exec_ctx_t *ctx)
2087 {
2088 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2089 VARIANT_BOOL b;
2090 HRESULT hres;
2091
2092 TRACE("\n");
2093
2094 hres = to_boolean(stack_top(ctx), &b);
2095 if(FAILED(hres))
2096 return hres;
2097
2098 if(b) {
2099 ctx->ip = arg;
2100 }else {
2101 stack_popn(ctx, 1);
2102 ctx->ip++;
2103 }
2104 return S_OK;
2105 }
2106
2107 /* ECMA-262 3rd Edition 11.11 */
2108 static HRESULT interp_jmp_z(exec_ctx_t *ctx)
2109 {
2110 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
2111 VARIANT_BOOL b;
2112 HRESULT hres;
2113
2114 TRACE("\n");
2115
2116 hres = to_boolean(stack_top(ctx), &b);
2117 if(FAILED(hres))
2118 return hres;
2119
2120 if(b) {
2121 stack_popn(ctx, 1);
2122 ctx->ip++;
2123 }else {
2124 ctx->ip = arg;
2125 }
2126 return S_OK;
2127 }
2128
2129 /* ECMA-262 3rd Edition 11.10 */
2130 static HRESULT interp_or(exec_ctx_t *ctx)
2131 {
2132 INT l, r;
2133 HRESULT hres;
2134
2135 TRACE("\n");
2136
2137 hres = stack_pop_int(ctx, &r);
2138 if(FAILED(hres))
2139 return hres;
2140
2141 hres = stack_pop_int(ctx, &l);
2142 if(FAILED(hres))
2143 return hres;
2144
2145 return stack_push_int(ctx, l|r);
2146 }
2147
2148 /* ECMA-262 3rd Edition 11.10 */
2149 static HRESULT interp_xor(exec_ctx_t *ctx)
2150 {
2151 INT l, r;
2152 HRESULT hres;
2153
2154 TRACE("\n");
2155
2156 hres = stack_pop_int(ctx, &r);
2157 if(FAILED(hres))
2158 return hres;
2159
2160 hres = stack_pop_int(ctx, &l);
2161 if(FAILED(hres))
2162 return hres;
2163
2164 return stack_push_int(ctx, l^r);
2165 }
2166
2167 /* ECMA-262 3rd Edition 11.10 */
2168 static HRESULT bitand_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2169 {
2170 INT li, ri;
2171 HRESULT hres;
2172
2173 hres = to_int32(ctx, lval, ei, &li);
2174 if(FAILED(hres))
2175 return hres;
2176
2177 hres = to_int32(ctx, rval, ei, &ri);
2178 if(FAILED(hres))
2179 return hres;
2180
2181 V_VT(retv) = VT_I4;
2182 V_I4(retv) = li&ri;
2183 return S_OK;
2184 }
2185
2186 /* ECMA-262 3rd Edition 11.10 */
2187 static HRESULT interp_and(exec_ctx_t *ctx)
2188 {
2189 INT l, r;
2190 HRESULT hres;
2191
2192 TRACE("\n");
2193
2194 hres = stack_pop_int(ctx, &r);
2195 if(FAILED(hres))
2196 return hres;
2197
2198 hres = stack_pop_int(ctx, &l);
2199 if(FAILED(hres))
2200 return hres;
2201
2202 return stack_push_int(ctx, l&r);
2203 }
2204
2205 /* ECMA-262 3rd Edition 11.8.6 */
2206 static HRESULT instanceof_eval(script_ctx_t *ctx, VARIANT *inst, VARIANT *objv, jsexcept_t *ei, VARIANT *retv)
2207 {
2208 jsdisp_t *obj, *iter, *tmp = NULL;
2209 VARIANT_BOOL ret = VARIANT_FALSE;
2210 BOOL b;
2211 VARIANT var;
2212 HRESULT hres;
2213
2214 static const WCHAR prototypeW[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2215
2216 if(V_VT(objv) != VT_DISPATCH || !V_DISPATCH(objv))
2217 return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2218
2219 obj = iface_to_jsdisp((IUnknown*)V_DISPATCH(objv));
2220 if(!obj) {
2221 FIXME("non-jsdisp objects not supported\n");
2222 return E_FAIL;
2223 }
2224
2225 if(is_class(obj, JSCLASS_FUNCTION)) {
2226 hres = jsdisp_propget_name(obj, prototypeW, &var, ei, NULL/*FIXME*/);
2227 }else {
2228 hres = throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
2229 }
2230 jsdisp_release(obj);
2231 if(FAILED(hres))
2232 return hres;
2233
2234 if(V_VT(&var) == VT_DISPATCH) {
2235 if(V_VT(inst) == VT_DISPATCH)
2236 tmp = iface_to_jsdisp((IUnknown*)V_DISPATCH(inst));
2237 for(iter = tmp; iter; iter = iter->prototype) {
2238 hres = disp_cmp(V_DISPATCH(&var), to_disp(iter), &b);
2239 if(FAILED(hres))
2240 break;
2241 if(b) {
2242 ret = VARIANT_TRUE;
2243 break;
2244 }
2245 }
2246
2247 if(tmp)
2248 jsdisp_release(tmp);
2249 }else {
2250 FIXME("prototype is not an object\n");
2251 hres = E_FAIL;
2252 }
2253
2254 VariantClear(&var);
2255 if(FAILED(hres))
2256 return hres;
2257
2258 V_VT(retv) = VT_BOOL;
2259 V_BOOL(retv) = ret;
2260 return S_OK;
2261 }
2262
2263 /* ECMA-262 3rd Edition 11.8.6 */
2264 HRESULT instanceof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2265 {
2266 binary_expression_t *expr = (binary_expression_t*)_expr;
2267
2268 TRACE("\n");
2269
2270 return binary_expr_eval(ctx, expr, instanceof_eval, ei, ret);
2271 }
2272
2273 /* ECMA-262 3rd Edition 11.8.7 */
2274 static HRESULT interp_in(exec_ctx_t *ctx)
2275 {
2276 VARIANT *obj, *v;
2277 DISPID id = 0;
2278 BOOL ret;
2279 BSTR str;
2280 HRESULT hres;
2281
2282 TRACE("\n");
2283
2284 obj = stack_pop(ctx);
2285 v = stack_pop(ctx);
2286
2287 if(V_VT(obj) != VT_DISPATCH || !V_DISPATCH(obj)) {
2288 VariantClear(obj);
2289 VariantClear(v);
2290 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2291 }
2292
2293 hres = to_string(ctx->parser->script, v, &ctx->ei, &str);
2294 VariantClear(v);
2295 if(FAILED(hres)) {
2296 IDispatch_Release(V_DISPATCH(obj));
2297 return hres;
2298 }
2299
2300 hres = disp_get_id(ctx->parser->script, V_DISPATCH(obj), str, 0, &id);
2301 IDispatch_Release(V_DISPATCH(obj));
2302 SysFreeString(str);
2303 if(SUCCEEDED(hres))
2304 ret = TRUE;
2305 else if(hres == DISP_E_UNKNOWNNAME)
2306 ret = FALSE;
2307 else
2308 return hres;
2309
2310 return stack_push_bool(ctx, ret);
2311 }
2312
2313 /* ECMA-262 3rd Edition 11.6.1 */
2314 static HRESULT add_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
2315 {
2316 VARIANT r, l;
2317 HRESULT hres;
2318
2319 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2320 if(FAILED(hres))
2321 return hres;
2322
2323 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2324 if(FAILED(hres)) {
2325 VariantClear(&l);
2326 return hres;
2327 }
2328
2329 if(V_VT(&l) == VT_BSTR || V_VT(&r) == VT_BSTR) {
2330 BSTR lstr = NULL, rstr = NULL;
2331
2332 if(V_VT(&l) == VT_BSTR)
2333 lstr = V_BSTR(&l);
2334 else
2335 hres = to_string(ctx, &l, ei, &lstr);
2336
2337 if(SUCCEEDED(hres)) {
2338 if(V_VT(&r) == VT_BSTR)
2339 rstr = V_BSTR(&r);
2340 else
2341 hres = to_string(ctx, &r, ei, &rstr);
2342 }
2343
2344 if(SUCCEEDED(hres)) {
2345 int len1, len2;
2346
2347 len1 = SysStringLen(lstr);
2348 len2 = SysStringLen(rstr);
2349
2350 V_VT(retv) = VT_BSTR;
2351 V_BSTR(retv) = SysAllocStringLen(NULL, len1+len2);
2352 memcpy(V_BSTR(retv), lstr, len1*sizeof(WCHAR));
2353 memcpy(V_BSTR(retv)+len1, rstr, (len2+1)*sizeof(WCHAR));
2354 }
2355
2356 if(V_VT(&l) != VT_BSTR)
2357 SysFreeString(lstr);
2358 if(V_VT(&r) != VT_BSTR)
2359 SysFreeString(rstr);
2360 }else {
2361 VARIANT nl, nr;
2362
2363 hres = to_number(ctx, &l, ei, &nl);
2364 if(SUCCEEDED(hres)) {
2365 hres = to_number(ctx, &r, ei, &nr);
2366 if(SUCCEEDED(hres))
2367 num_set_val(retv, num_val(&nl) + num_val(&nr));
2368 }
2369 }
2370
2371 VariantClear(&r);
2372 VariantClear(&l);
2373 return hres;
2374 }
2375
2376 /* ECMA-262 3rd Edition 11.6.1 */
2377 static HRESULT interp_add(exec_ctx_t *ctx)
2378 {
2379 VARIANT *l, *r, ret;
2380 HRESULT hres;
2381
2382 r = stack_pop(ctx);
2383 l = stack_pop(ctx);
2384
2385 TRACE("%s + %s\n", debugstr_variant(l), debugstr_variant(r));
2386
2387 hres = add_eval(ctx->parser->script, l, r, &ctx->ei, &ret);
2388 VariantClear(l);
2389 VariantClear(r);
2390 if(FAILED(hres))
2391 return hres;
2392
2393 return stack_push(ctx, &ret);
2394 }
2395
2396 /* ECMA-262 3rd Edition 11.6.2 */
2397 static HRESULT interp_sub(exec_ctx_t *ctx)
2398 {
2399 VARIANT l, r;
2400 HRESULT hres;
2401
2402 TRACE("\n");
2403
2404 hres = stack_pop_number(ctx, &r);
2405 if(FAILED(hres))
2406 return hres;
2407
2408 hres = stack_pop_number(ctx, &l);
2409 if(FAILED(hres))
2410 return hres;
2411
2412 return stack_push_number(ctx, num_val(&l)-num_val(&r));
2413 }
2414
2415 /* ECMA-262 3rd Edition 11.5.1 */
2416 static HRESULT interp_mul(exec_ctx_t *ctx)
2417 {
2418 VARIANT l, r;
2419 HRESULT hres;
2420
2421 TRACE("\n");
2422
2423 hres = stack_pop_number(ctx, &r);
2424 if(FAILED(hres))
2425 return hres;
2426
2427 hres = stack_pop_number(ctx, &l);
2428 if(FAILED(hres))
2429 return hres;
2430
2431 return stack_push_number(ctx, num_val(&l)*num_val(&r));
2432 }
2433
2434 /* ECMA-262 3rd Edition 11.5.2 */
2435 static HRESULT interp_div(exec_ctx_t *ctx)
2436 {
2437 VARIANT l, r;
2438 HRESULT hres;
2439
2440 TRACE("\n");
2441
2442 hres = stack_pop_number(ctx, &r);
2443 if(FAILED(hres))
2444 return hres;
2445
2446 hres = stack_pop_number(ctx, &l);
2447 if(FAILED(hres))
2448 return hres;
2449
2450 return stack_push_number(ctx, num_val(&l)/num_val(&r));
2451 }
2452
2453 /* ECMA-262 3rd Edition 11.5.3 */
2454 static HRESULT interp_mod(exec_ctx_t *ctx)
2455 {
2456 VARIANT l, r;
2457 HRESULT hres;
2458
2459 TRACE("\n");
2460
2461 hres = stack_pop_number(ctx, &r);
2462 if(FAILED(hres))
2463 return hres;
2464
2465 hres = stack_pop_number(ctx, &l);
2466 if(FAILED(hres))
2467 return hres;
2468
2469 return stack_push_number(ctx, fmod(num_val(&l), num_val(&r)));
2470 }
2471
2472 /* ECMA-262 3rd Edition 11.4.2 */
2473 HRESULT delete_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2474 {
2475 unary_expression_t *expr = (unary_expression_t*)_expr;
2476 VARIANT_BOOL b = VARIANT_FALSE;
2477 exprval_t exprval;
2478 HRESULT hres;
2479
2480 TRACE("\n");
2481
2482 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2483 if(FAILED(hres))
2484 return hres;
2485
2486 switch(exprval.type) {
2487 case EXPRVAL_IDREF: {
2488 IDispatchEx *dispex;
2489
2490 hres = IDispatch_QueryInterface(exprval.u.idref.disp, &IID_IDispatchEx, (void**)&dispex);
2491 if(SUCCEEDED(hres)) {
2492 hres = IDispatchEx_DeleteMemberByDispID(dispex, exprval.u.idref.id);
2493 b = VARIANT_TRUE;
2494 IDispatchEx_Release(dispex);
2495 }
2496 break;
2497 }
2498 default:
2499 FIXME("unsupported type %d\n", exprval.type);
2500 hres = E_NOTIMPL;
2501 }
2502
2503 exprval_release(&exprval);
2504 if(FAILED(hres))
2505 return hres;
2506
2507 return return_bool(ret, b);
2508 }
2509
2510 /* ECMA-262 3rd Edition 11.4.2 */
2511 static HRESULT interp_delete(exec_ctx_t *ctx)
2512 {
2513 VARIANT *obj_var, *name_var;
2514 IDispatchEx *dispex;
2515 IDispatch *obj;
2516 BSTR name;
2517 BOOL ret;
2518 HRESULT hres;
2519
2520 TRACE("\n");
2521
2522 name_var = stack_pop(ctx);
2523 obj_var = stack_pop(ctx);
2524
2525 hres = to_object(ctx->parser->script, obj_var, &obj);
2526 VariantClear(obj_var);
2527 if(FAILED(hres)) {
2528 VariantClear(name_var);
2529 return hres;
2530 }
2531
2532 hres = to_string(ctx->parser->script, name_var, &ctx->ei, &name);
2533 VariantClear(name_var);
2534 if(FAILED(hres)) {
2535 IDispatch_Release(obj);
2536 return hres;
2537 }
2538
2539 hres = IDispatch_QueryInterface(obj, &IID_IDispatchEx, (void**)&dispex);
2540 if(SUCCEEDED(hres)) {
2541 hres = IDispatchEx_DeleteMemberByName(dispex, name, make_grfdex(ctx->parser->script, fdexNameCaseSensitive));
2542 ret = TRUE;
2543 IDispatchEx_Release(dispex);
2544 }else {
2545 hres = S_OK;
2546 ret = FALSE;
2547 }
2548
2549 IDispatch_Release(obj);
2550 SysFreeString(name);
2551 if(FAILED(hres))
2552 return hres;
2553
2554 return stack_push_bool(ctx, ret);
2555 }
2556
2557 /* ECMA-262 3rd Edition 11.4.2 */
2558 static HRESULT interp_void(exec_ctx_t *ctx)
2559 {
2560 VARIANT v;
2561
2562 TRACE("\n");
2563
2564 stack_popn(ctx, 1);
2565
2566 V_VT(&v) = VT_EMPTY;
2567 return stack_push(ctx, &v);
2568 }
2569
2570 /* ECMA-262 3rd Edition 11.4.3 */
2571 static HRESULT typeof_exprval(script_ctx_t *ctx, exprval_t *exprval, jsexcept_t *ei, const WCHAR **ret)
2572 {
2573 VARIANT val;
2574 HRESULT hres;
2575
2576 static const WCHAR booleanW[] = {'b','o','o','l','e','a','n',0};
2577 static const WCHAR functionW[] = {'f','u','n','c','t','i','o','n',0};
2578 static const WCHAR numberW[] = {'n','u','m','b','e','r',0};
2579 static const WCHAR objectW[] = {'o','b','j','e','c','t',0};
2580 static const WCHAR stringW[] = {'s','t','r','i','n','g',0};
2581 static const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
2582 static const WCHAR unknownW[] = {'u','n','k','n','o','w','n',0};
2583
2584 if(exprval->type == EXPRVAL_INVALID) {
2585 *ret = undefinedW;
2586 return S_OK;
2587 }
2588
2589 hres = exprval_to_value(ctx, exprval, ei, &val);
2590 if(FAILED(hres)) {
2591 if(exprval->type == EXPRVAL_IDREF) {
2592 *ret = unknownW;
2593 return S_OK;
2594 }
2595 return hres;
2596 }
2597
2598 switch(V_VT(&val)) {
2599 case VT_EMPTY:
2600 *ret = undefinedW;
2601 break;
2602 case VT_NULL:
2603 *ret = objectW;
2604 break;
2605 case VT_BOOL:
2606 *ret = booleanW;
2607 break;
2608 case VT_I4:
2609 case VT_R8:
2610 *ret = numberW;
2611 break;
2612 case VT_BSTR:
2613 *ret = stringW;
2614 break;
2615 case VT_DISPATCH: {
2616 jsdisp_t *dispex;
2617
2618 if(V_DISPATCH(&val) && (dispex = iface_to_jsdisp((IUnknown*)V_DISPATCH(&val)))) {
2619 *ret = is_class(dispex, JSCLASS_FUNCTION) ? functionW : objectW;
2620 jsdisp_release(dispex);
2621 }else {
2622 *ret = objectW;
2623 }
2624 break;
2625 }
2626 default:
2627 FIXME("unhandled vt %d\n", V_VT(&val));
2628 hres = E_NOTIMPL;
2629 }
2630
2631 VariantClear(&val);
2632 return hres;
2633 }
2634
2635 HRESULT typeof_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
2636 {
2637 unary_expression_t *expr = (unary_expression_t*)_expr;
2638 const WCHAR *str = NULL;
2639 exprval_t exprval;
2640 HRESULT hres;
2641
2642 TRACE("\n");
2643
2644 hres = expr_eval(ctx, expr->expression, 0, ei, &exprval);
2645 if(FAILED(hres))
2646 return hres;
2647
2648 hres = typeof_exprval(ctx, &exprval, ei, &str);
2649 exprval_release(&exprval);
2650 if(FAILED(hres))
2651 return hres;
2652
2653 ret->type = EXPRVAL_VARIANT;
2654 V_VT(&ret->u.var) = VT_BSTR;
2655 V_BSTR(&ret->u.var) = SysAllocString(str);
2656 if(!V_BSTR(&ret->u.var))
2657 return E_OUTOFMEMORY;
2658
2659 return S_OK;
2660 }
2661
2662 /* ECMA-262 3rd Edition 11.4.7 */
2663 static HRESULT interp_minus(exec_ctx_t *ctx)
2664 {
2665 VARIANT n;
2666 HRESULT hres;
2667
2668 TRACE("\n");
2669
2670 hres = stack_pop_number(ctx, &n);
2671 if(FAILED(hres))
2672 return hres;
2673
2674 return stack_push_number(ctx, -num_val(&n));
2675 }
2676
2677 /* ECMA-262 3rd Edition 11.4.6 */
2678 static HRESULT interp_tonum(exec_ctx_t *ctx)
2679 {
2680 VARIANT *v, num;
2681 HRESULT hres;
2682
2683 TRACE("\n");
2684
2685 v = stack_pop(ctx);
2686 hres = to_number(ctx->parser->script, v, &ctx->ei, &num);
2687 VariantClear(v);
2688 if(FAILED(hres))
2689 return hres;
2690
2691 return stack_push(ctx, &num);
2692 }
2693
2694 /* ECMA-262 3rd Edition 11.3.1 */
2695 static HRESULT interp_postinc(exec_ctx_t *ctx)
2696 {
2697 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2698 IDispatch *obj;
2699 DISPID id;
2700 VARIANT v;
2701 HRESULT hres;
2702
2703 TRACE("%d\n", arg);
2704
2705 obj = stack_pop_objid(ctx, &id);
2706 if(!obj)
2707 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2708
2709 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2710 if(SUCCEEDED(hres)) {
2711 VARIANT n, inc;
2712
2713 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2714 if(SUCCEEDED(hres)) {
2715 num_set_val(&inc, num_val(&n)+(double)arg);
2716 hres = disp_propput(ctx->parser->script, obj, id, &inc, &ctx->ei, NULL/*FIXME*/);
2717 }
2718 }
2719 IDispatch_Release(obj);
2720 if(FAILED(hres))
2721 return hres;
2722
2723 return stack_push(ctx, &v);
2724 }
2725
2726 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
2727 static HRESULT interp_preinc(exec_ctx_t *ctx)
2728 {
2729 const int arg = ctx->parser->code->instrs[ctx->ip].arg1.lng;
2730 IDispatch *obj;
2731 DISPID id;
2732 VARIANT v;
2733 HRESULT hres;
2734
2735 TRACE("%d\n", arg);
2736
2737 obj = stack_pop_objid(ctx, &id);
2738 if(!obj)
2739 return throw_type_error(ctx->parser->script, &ctx->ei, JS_E_OBJECT_EXPECTED, NULL);
2740
2741 hres = disp_propget(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2742 if(SUCCEEDED(hres)) {
2743 VARIANT n;
2744
2745 hres = to_number(ctx->parser->script, &v, &ctx->ei, &n);
2746 VariantClear(&v);
2747 if(SUCCEEDED(hres)) {
2748 num_set_val(&v, num_val(&n)+(double)arg);
2749 hres = disp_propput(ctx->parser->script, obj, id, &v, &ctx->ei, NULL/*FIXME*/);
2750 }
2751 }
2752 IDispatch_Release(obj);
2753 if(FAILED(hres))
2754 return hres;
2755
2756 return stack_push(ctx, &v);
2757 }
2758
2759 /* ECMA-262 3rd Edition 11.9.3 */
2760 static HRESULT equal_values(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, BOOL *ret)
2761 {
2762 if(V_VT(lval) == V_VT(rval) || (is_num_vt(V_VT(lval)) && is_num_vt(V_VT(rval))))
2763 return equal2_values(lval, rval, ret);
2764
2765 /* FIXME: NULL disps should be handled in more general way */
2766 if(V_VT(lval) == VT_DISPATCH && !V_DISPATCH(lval)) {
2767 VARIANT v;
2768 V_VT(&v) = VT_NULL;
2769 return equal_values(ctx, &v, rval, ei, ret);
2770 }
2771
2772 if(V_VT(rval) == VT_DISPATCH && !V_DISPATCH(rval)) {
2773 VARIANT v;
2774 V_VT(&v) = VT_NULL;
2775 return equal_values(ctx, lval, &v, ei, ret);
2776 }
2777
2778 if((V_VT(lval) == VT_NULL && V_VT(rval) == VT_EMPTY) ||
2779 (V_VT(lval) == VT_EMPTY && V_VT(rval) == VT_NULL)) {
2780 *ret = TRUE;
2781 return S_OK;
2782 }
2783
2784 if(V_VT(lval) == VT_BSTR && is_num_vt(V_VT(rval))) {
2785 VARIANT v;
2786 HRESULT hres;
2787
2788 hres = to_number(ctx, lval, ei, &v);
2789 if(FAILED(hres))
2790 return hres;
2791
2792 return equal_values(ctx, &v, rval, ei, ret);
2793 }
2794
2795 if(V_VT(rval) == VT_BSTR && is_num_vt(V_VT(lval))) {
2796 VARIANT v;
2797 HRESULT hres;
2798
2799 hres = to_number(ctx, rval, ei, &v);
2800 if(FAILED(hres))
2801 return hres;
2802
2803 return equal_values(ctx, lval, &v, ei, ret);
2804 }
2805
2806 if(V_VT(rval) == VT_BOOL) {
2807 VARIANT v;
2808
2809 V_VT(&v) = VT_I4;
2810 V_I4(&v) = V_BOOL(rval) ? 1 : 0;
2811 return equal_values(ctx, lval, &v, ei, ret);
2812 }
2813
2814 if(V_VT(lval) == VT_BOOL) {
2815 VARIANT v;
2816
2817 V_VT(&v) = VT_I4;
2818 V_I4(&v) = V_BOOL(lval) ? 1 : 0;
2819 return equal_values(ctx, &v, rval, ei, ret);
2820 }
2821
2822
2823 if(V_VT(rval) == VT_DISPATCH && (V_VT(lval) == VT_BSTR || is_num_vt(V_VT(lval)))) {
2824 VARIANT v;
2825 HRESULT hres;
2826
2827 hres = to_primitive(ctx, rval, ei, &v, NO_HINT);
2828 if(FAILED(hres))
2829 return hres;
2830
2831 hres = equal_values(ctx, lval, &v, ei, ret);
2832
2833 VariantClear(&v);
2834 return hres;
2835 }
2836
2837
2838 if(V_VT(lval) == VT_DISPATCH && (V_VT(rval) == VT_BSTR || is_num_vt(V_VT(rval)))) {
2839 VARIANT v;
2840 HRESULT hres;
2841
2842 hres = to_primitive(ctx, lval, ei, &v, NO_HINT);
2843 if(FAILED(hres))
2844 return hres;
2845
2846 hres = equal_values(ctx, &v, rval, ei, ret);
2847
2848 VariantClear(&v);
2849 return hres;
2850 }
2851
2852
2853 *ret = FALSE;
2854 return S_OK;
2855 }
2856
2857 /* ECMA-262 3rd Edition 11.9.1 */
2858 static HRESULT interp_eq(exec_ctx_t *ctx)
2859 {
2860 VARIANT *l, *r;
2861 BOOL b;
2862 HRESULT hres;
2863
2864 r = stack_pop(ctx);
2865 l = stack_pop(ctx);
2866
2867 TRACE("%s == %s\n", debugstr_variant(l), debugstr_variant(r));
2868
2869 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2870 VariantClear(l);
2871 VariantClear(r);
2872 if(FAILED(hres))
2873 return hres;
2874
2875 return stack_push_bool(ctx, b);
2876 }
2877
2878 /* ECMA-262 3rd Edition 11.9.2 */
2879 static HRESULT interp_neq(exec_ctx_t *ctx)
2880 {
2881 VARIANT *l, *r;
2882 BOOL b;
2883 HRESULT hres;
2884
2885 r = stack_pop(ctx);
2886 l = stack_pop(ctx);
2887
2888 TRACE("%s != %s\n", debugstr_variant(l), debugstr_variant(r));
2889
2890 hres = equal_values(ctx->parser->script, l, r, &ctx->ei, &b);
2891 VariantClear(l);
2892 VariantClear(r);
2893 if(FAILED(hres))
2894 return hres;
2895
2896 return stack_push_bool(ctx, !b);
2897 }
2898
2899 /* ECMA-262 3rd Edition 11.9.4 */
2900 static HRESULT interp_eq2(exec_ctx_t *ctx)
2901 {
2902 VARIANT *l, *r;
2903 BOOL b;
2904 HRESULT hres;
2905
2906 TRACE("\n");
2907
2908 r = stack_pop(ctx);
2909 l = stack_pop(ctx);
2910
2911 hres = equal2_values(r, l, &b);
2912 VariantClear(l);
2913 VariantClear(r);
2914 if(FAILED(hres))
2915 return hres;
2916
2917 return stack_push_bool(ctx, b);
2918 }
2919
2920 /* ECMA-262 3rd Edition 11.9.5 */
2921 static HRESULT interp_neq2(exec_ctx_t *ctx)
2922 {
2923 VARIANT *l, *r;
2924 BOOL b;
2925 HRESULT hres;
2926
2927 TRACE("\n");
2928
2929 r = stack_pop(ctx);
2930 l = stack_pop(ctx);
2931
2932 hres = equal2_values(r, l, &b);
2933 VariantClear(l);
2934 VariantClear(r);
2935 if(FAILED(hres))
2936 return hres;
2937
2938 return stack_push_bool(ctx, !b);
2939 }
2940
2941 /* ECMA-262 3rd Edition 11.8.5 */
2942 static HRESULT less_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, BOOL greater, jsexcept_t *ei, BOOL *ret)
2943 {
2944 VARIANT l, r, ln, rn;
2945 HRESULT hres;
2946
2947 hres = to_primitive(ctx, lval, ei, &l, NO_HINT);
2948 if(FAILED(hres))
2949 return hres;
2950
2951 hres = to_primitive(ctx, rval, ei, &r, NO_HINT);
2952 if(FAILED(hres)) {
2953 VariantClear(&l);
2954 return hres;
2955 }
2956
2957 if(V_VT(&l) == VT_BSTR && V_VT(&r) == VT_BSTR) {
2958 *ret = (strcmpW(V_BSTR(&l), V_BSTR(&r)) < 0) ^ greater;
2959 SysFreeString(V_BSTR(&l));
2960 SysFreeString(V_BSTR(&r));
2961 return S_OK;
2962 }
2963
2964 hres = to_number(ctx, &l, ei, &ln);
2965 VariantClear(&l);
2966 if(SUCCEEDED(hres))
2967 hres = to_number(ctx, &r, ei, &rn);
2968 VariantClear(&r);
2969 if(FAILED(hres))
2970 return hres;
2971
2972 if(V_VT(&ln) == VT_I4 && V_VT(&rn) == VT_I4) {
2973 *ret = (V_I4(&ln) < V_I4(&rn)) ^ greater;
2974 }else {
2975 DOUBLE ld = num_val(&ln);
2976 DOUBLE rd = num_val(&rn);
2977
2978 *ret = !isnan(ld) && !isnan(rd) && ((ld < rd) ^ greater);
2979 }
2980
2981 return S_OK;
2982 }
2983
2984 /* ECMA-262 3rd Edition 11.8.1 */
2985 static HRESULT interp_lt(exec_ctx_t *ctx)
2986 {
2987 VARIANT *l, *r;
2988 BOOL b;
2989 HRESULT hres;
2990
2991 r = stack_pop(ctx);
2992 l = stack_pop(ctx);
2993
2994 TRACE("%s < %s\n", debugstr_variant(l), debugstr_variant(r));
2995
2996 hres = less_eval(ctx->parser->script, l, r, FALSE, &ctx->ei, &b);
2997 VariantClear(l);
2998 VariantClear(r);
2999 if(FAILED(hres))
3000 return hres;
3001
3002 return stack_push_bool(ctx, b);
3003 }
3004
3005 /* ECMA-262 3rd Edition 11.8.1 */
3006 static HRESULT interp_lteq(exec_ctx_t *ctx)
3007 {
3008 VARIANT *l, *r;
3009 BOOL b;
3010 HRESULT hres;
3011
3012 r = stack_pop(ctx);
3013 l = stack_pop(ctx);
3014
3015 TRACE("%s <= %s\n", debugstr_variant(l), debugstr_variant(r));
3016
3017 hres = less_eval(ctx->parser->script, r, l, TRUE, &ctx->ei, &b);
3018 VariantClear(l);
3019 VariantClear(r);
3020 if(FAILED(hres))
3021 return hres;
3022
3023 return stack_push_bool(ctx, b);
3024 }
3025
3026 /* ECMA-262 3rd Edition 11.8.2 */
3027 static HRESULT interp_gt(exec_ctx_t *ctx)
3028 {
3029 VARIANT *l, *r;
3030 BOOL b;
3031 HRESULT hres;
3032
3033 r = stack_pop(ctx);
3034 l = stack_pop(ctx);
3035
3036 TRACE("%s > %s\n", debugstr_variant(l), debugstr_variant(r));
3037
3038 hres = less_eval(ctx->parser->script, r, l, FALSE, &ctx->ei, &b);
3039 VariantClear(l);
3040 VariantClear(r);
3041 if(FAILED(hres))
3042 return hres;
3043
3044 return stack_push_bool(ctx, b);
3045 }
3046
3047 /* ECMA-262 3rd Edition 11.8.4 */
3048 static HRESULT interp_gteq(exec_ctx_t *ctx)
3049 {
3050 VARIANT *l, *r;
3051 BOOL b;
3052 HRESULT hres;
3053
3054 r = stack_pop(ctx);
3055 l = stack_pop(ctx);
3056
3057 TRACE("%s >= %s\n", debugstr_variant(l), debugstr_variant(r));
3058
3059 hres = less_eval(ctx->parser->script, l, r, TRUE, &ctx->ei, &b);
3060 VariantClear(l);
3061 VariantClear(r);
3062 if(FAILED(hres))
3063 return hres;
3064
3065 return stack_push_bool(ctx, b);
3066 }
3067
3068 /* ECMA-262 3rd Edition 11.4.8 */
3069 static HRESULT interp_bneg(exec_ctx_t *ctx)
3070 {
3071 VARIANT *v, r;
3072 INT i;
3073 HRESULT hres;
3074
3075 TRACE("\n");
3076
3077 v = stack_pop(ctx);
3078 hres = to_int32(ctx->parser->script, v, &ctx->ei, &i);
3079 VariantClear(v);
3080 if(FAILED(hres))
3081 return hres;
3082
3083 V_VT(&r) = VT_I4;
3084 V_I4(&r) = ~i;
3085 return stack_push(ctx, &r);
3086 }
3087
3088 /* ECMA-262 3rd Edition 11.4.9 */
3089 static HRESULT interp_neg(exec_ctx_t *ctx)
3090 {
3091 VARIANT *v;
3092 VARIANT_BOOL b;
3093 HRESULT hres;
3094
3095 TRACE("\n");
3096
3097 v = stack_pop(ctx);
3098 hres = to_boolean(v, &b);
3099 VariantClear(v);
3100 if(FAILED(hres))
3101 return hres;
3102
3103 return stack_push_bool(ctx, !b);
3104 }
3105
3106 /* ECMA-262 3rd Edition 11.7.1 */
3107 static HRESULT lshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3108 {
3109 DWORD ri;
3110 INT li;
3111 HRESULT hres;
3112
3113 hres = to_int32(ctx, lval, ei, &li);
3114 if(FAILED(hres))
3115 return hres;
3116
3117 hres = to_uint32(ctx, rval, ei, &ri);
3118 if(FAILED(hres))
3119 return hres;
3120
3121 V_VT(retv) = VT_I4;
3122 V_I4(retv) = li << (ri&0x1f);
3123 return S_OK;
3124 }
3125
3126 /* ECMA-262 3rd Edition 11.7.1 */
3127 HRESULT left_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3128 {
3129 binary_expression_t *expr = (binary_expression_t*)_expr;
3130
3131 TRACE("\n");
3132
3133 return binary_expr_eval(ctx, expr, lshift_eval, ei, ret);
3134 }
3135
3136 /* ECMA-262 3rd Edition 11.7.2 */
3137 static HRESULT rshift_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3138 {
3139 DWORD ri;
3140 INT li;
3141 HRESULT hres;
3142
3143 hres = to_int32(ctx, lval, ei, &li);
3144 if(FAILED(hres))
3145 return hres;
3146
3147 hres = to_uint32(ctx, rval, ei, &ri);
3148 if(FAILED(hres))
3149 return hres;
3150
3151 V_VT(retv) = VT_I4;
3152 V_I4(retv) = li >> (ri&0x1f);
3153 return S_OK;
3154 }
3155
3156 /* ECMA-262 3rd Edition 11.7.2 */
3157 HRESULT right_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3158 {
3159 binary_expression_t *expr = (binary_expression_t*)_expr;
3160
3161 TRACE("\n");
3162
3163 return binary_expr_eval(ctx, expr, rshift_eval, ei, ret);
3164 }
3165
3166 /* ECMA-262 3rd Edition 11.7.3 */
3167 static HRESULT rshift2_eval(script_ctx_t *ctx, VARIANT *lval, VARIANT *rval, jsexcept_t *ei, VARIANT *retv)
3168 {
3169 DWORD li, ri;
3170 HRESULT hres;
3171
3172 hres = to_uint32(ctx, lval, ei, &li);
3173 if(FAILED(hres))
3174 return hres;
3175
3176 hres = to_uint32(ctx, rval, ei, &ri);
3177 if(FAILED(hres))
3178 return hres;
3179
3180 V_VT(retv) = VT_I4;
3181 V_I4(retv) = li >> (ri&0x1f);
3182 return S_OK;
3183 }
3184
3185 /* ECMA-262 3rd Edition 11.7.3 */
3186 HRESULT right2_shift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3187 {
3188 binary_expression_t *expr = (binary_expression_t*)_expr;
3189
3190 TRACE("\n");
3191
3192 return binary_expr_eval(ctx, expr, rshift2_eval, ei, ret);
3193 }
3194
3195 /* ECMA-262 3rd Edition 11.13.1 */
3196 static HRESULT interp_assign(exec_ctx_t *ctx)
3197 {
3198 IDispatch *disp;
3199 DISPID id;
3200 VARIANT *v;
3201 HRESULT hres;
3202
3203 TRACE("\n");
3204
3205 v = stack_pop(ctx);
3206 disp = stack_pop_objid(ctx, &id);
3207
3208 if(!disp)
3209 return throw_reference_error(ctx->parser->script, &ctx->ei, JS_E_ILLEGAL_ASSIGN, NULL);
3210
3211 hres = disp_propput(ctx->parser->script, disp, id, v, &ctx->ei, NULL/*FIXME*/);
3212 IDispatch_Release(disp);
3213 if(FAILED(hres)) {
3214 VariantClear(v);
3215 return hres;
3216 }
3217
3218 return stack_push(ctx, v);
3219 }
3220
3221 /* ECMA-262 3rd Edition 11.13.2 */
3222 HRESULT assign_lshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3223 {
3224 binary_expression_t *expr = (binary_expression_t*)_expr;
3225
3226 TRACE("\n");
3227
3228 return assign_oper_eval(ctx, expr->expression1, expr->expression2, lshift_eval, ei, ret);
3229 }
3230
3231 /* ECMA-262 3rd Edition 11.13.2 */
3232 HRESULT assign_rshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3233 {
3234 binary_expression_t *expr = (binary_expression_t*)_expr;
3235
3236 TRACE("\n");
3237
3238 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift_eval, ei, ret);
3239 }
3240
3241 /* ECMA-262 3rd Edition 11.13.2 */
3242 HRESULT assign_rrshift_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3243 {
3244 binary_expression_t *expr = (binary_expression_t*)_expr;
3245
3246 TRACE("\n");
3247
3248 return assign_oper_eval(ctx, expr->expression1, expr->expression2, rshift2_eval, ei, ret);
3249 }
3250
3251 /* ECMA-262 3rd Edition 11.13.2 */
3252 HRESULT assign_and_expression_eval(script_ctx_t *ctx, expression_t *_expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3253 {
3254 binary_expression_t *expr = (binary_expression_t*)_expr;
3255
3256 TRACE("\n");
3257
3258 return assign_oper_eval(ctx, expr->expression1, expr->expression2, bitand_eval, ei, ret);
3259 }
3260
3261 static HRESULT interp_undefined(exec_ctx_t *ctx)
3262 {
3263 VARIANT v;
3264
3265 TRACE("\n");
3266
3267 V_VT(&v) = VT_EMPTY;
3268 return stack_push(ctx, &v);
3269 }
3270
3271 static HRESULT interp_jmp(exec_ctx_t *ctx)
3272 {
3273 const unsigned arg = ctx->parser->code->instrs[ctx->ip].arg1.uint;
3274
3275 TRACE("\n");
3276
3277 ctx->ip = arg;
3278 return S_OK;
3279 }
3280
3281 static HRESULT interp_pop(exec_ctx_t *ctx)
3282 {
3283 TRACE("\n");
3284
3285 stack_popn(ctx, 1);
3286 return S_OK;
3287 }
3288
3289 static HRESULT interp_ret(exec_ctx_t *ctx)
3290 {
3291 TRACE("\n");
3292
3293 ctx->ip = -1;
3294 return S_OK;
3295 }
3296
3297 static HRESULT interp_tree(exec_ctx_t *ctx)
3298 {
3299 instr_t *instr = ctx->parser->code->instrs+ctx->ip;
3300 exprval_t val;
3301 VARIANT v;
3302 HRESULT hres;
3303
3304 TRACE("\n");
3305
3306 hres = expr_eval(ctx->parser->script, instr->arg1.expr, 0, &ctx->ei, &val);
3307 if(FAILED(hres))
3308 return hres;
3309
3310 hres = exprval_to_value(ctx->parser->script, &val, &ctx->ei, &v);
3311 exprval_release(&val);
3312 if(FAILED(hres))
3313 return hres;
3314
3315 return stack_push(ctx, &v);
3316 }
3317
3318 typedef HRESULT (*op_func_t)(exec_ctx_t*);
3319
3320 static const op_func_t op_funcs[] = {
3321 #define X(x,a,b,c) interp_##x,
3322 OP_LIST
3323 #undef X
3324 };
3325
3326 static const unsigned op_move[] = {
3327 #define X(a,x,b,c) x,
3328 OP_LIST
3329 #undef X
3330 };
3331
3332 static HRESULT interp_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3333 {
3334 exec_ctx_t *exec_ctx = ctx->exec_ctx;
3335 unsigned prev_ip, prev_top;
3336 jsop_t op;
3337 HRESULT hres = S_OK;
3338
3339 TRACE("\n");
3340
3341 prev_top = exec_ctx->top;
3342 prev_ip = exec_ctx->ip;
3343 exec_ctx->ip = expr->instr_off;
3344
3345 while(exec_ctx->ip != -1) {
3346 op = exec_ctx->parser->code->instrs[exec_ctx->ip].op;
3347 hres = op_funcs[op](exec_ctx);
3348 if(FAILED(hres))
3349 break;
3350 exec_ctx->ip += op_move[op];
3351 }
3352
3353 exec_ctx->ip = prev_ip;
3354
3355 if(FAILED(hres)) {
3356 stack_popn(exec_ctx, exec_ctx->top-prev_top);
3357 *ei = exec_ctx->ei;
3358 memset(&exec_ctx->ei, 0, sizeof(exec_ctx->ei));
3359 return hres;
3360 }
3361
3362 assert(exec_ctx->top == prev_top+1 || ((flags&EXPR_NOVAL) && exec_ctx->top == prev_top));
3363
3364 ret->type = EXPRVAL_VARIANT;
3365 if(exec_ctx->top == prev_top)
3366 V_VT(&ret->u.var) = VT_EMPTY;
3367 else
3368 ret->u.var = *stack_pop(exec_ctx);
3369 return S_OK;
3370 }
3371
3372 HRESULT compiled_expression_eval(script_ctx_t *ctx, expression_t *expr, DWORD flags, jsexcept_t *ei, exprval_t *ret)
3373 {
3374 HRESULT hres;
3375
3376 TRACE("\n");
3377
3378 hres = compile_subscript(ctx->exec_ctx->parser, expr, !(flags & EXPR_NOVAL), &expr->instr_off);
3379 if(FAILED(hres))
3380 return hres;
3381
3382 if(expr->eval == compiled_expression_eval)
3383 expr->eval = interp_expression_eval;
3384
3385 return expr->eval(ctx, expr, flags, ei, ret);
3386 }
Maarten's multimedia branch