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