2 * Copyright 2008 Jacek Caban for CodeWeavers
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.
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.
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
20 #include "wine/port.h"
28 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(jscript
);
32 #define EXPR_NOVAL 0x0001
33 #define EXPR_NEWREF 0x0002
35 struct _return_type_t
{
45 static inline HRESULT
stat_eval(script_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
47 return stat
->eval(ctx
, stat
, rt
, ret
);
50 static inline HRESULT
expr_eval(script_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
52 return expr
->eval(ctx
, expr
, flags
, ei
, ret
);
55 static HRESULT
stack_push(exec_ctx_t
*ctx
, VARIANT
*v
)
57 if(!ctx
->stack_size
) {
58 ctx
->stack
= heap_alloc(16*sizeof(VARIANT
));
62 }else if(ctx
->stack_size
== ctx
->top
) {
65 new_stack
= heap_realloc(ctx
->stack
, ctx
->stack_size
*2*sizeof(VARIANT
));
71 ctx
->stack
= new_stack
;
75 ctx
->stack
[ctx
->top
++] = *v
;
79 static HRESULT
stack_push_bool(exec_ctx_t
*ctx
, BOOL b
)
84 V_BOOL(&v
) = b
? VARIANT_TRUE
: VARIANT_FALSE
;
85 return stack_push(ctx
, &v
);
88 static inline HRESULT
stack_push_number(exec_ctx_t
*ctx
, double number
)
92 num_set_val(&v
, number
);
93 return stack_push(ctx
, &v
);
96 static inline HRESULT
stack_push_int(exec_ctx_t
*ctx
, INT n
)
102 return stack_push(ctx
, &v
);
105 static HRESULT
stack_push_objid(exec_ctx_t
*ctx
, IDispatch
*disp
, DISPID id
)
110 V_VT(&v
) = VT_DISPATCH
;
111 V_DISPATCH(&v
) = disp
;
112 hres
= stack_push(ctx
, &v
);
118 return stack_push(ctx
, &v
);
121 static inline VARIANT
*stack_top(exec_ctx_t
*ctx
)
124 return ctx
->stack
+ ctx
->top
-1;
127 static inline VARIANT
*stack_topn(exec_ctx_t
*ctx
, unsigned n
)
129 assert(ctx
->top
> n
);
130 return ctx
->stack
+ ctx
->top
-1-n
;
133 static inline VARIANT
*stack_pop(exec_ctx_t
*ctx
)
136 return ctx
->stack
+ --ctx
->top
;
139 static void stack_popn(exec_ctx_t
*ctx
, unsigned n
)
142 VariantClear(stack_pop(ctx
));
145 static HRESULT
stack_pop_number(exec_ctx_t
*ctx
, VARIANT
*r
)
151 hres
= to_number(ctx
->parser
->script
, v
, &ctx
->ei
, r
);
156 static HRESULT
stack_pop_object(exec_ctx_t
*ctx
, IDispatch
**r
)
162 if(V_VT(v
) == VT_DISPATCH
) {
167 hres
= to_object(ctx
->parser
->script
, v
, r
);
172 static inline HRESULT
stack_pop_int(exec_ctx_t
*ctx
, INT
*r
)
174 return to_int32(ctx
->parser
->script
, stack_pop(ctx
), &ctx
->ei
, r
);
177 static inline HRESULT
stack_pop_uint(exec_ctx_t
*ctx
, DWORD
*r
)
179 return to_uint32(ctx
->parser
->script
, stack_pop(ctx
), &ctx
->ei
, r
);
182 static inline IDispatch
*stack_pop_objid(exec_ctx_t
*ctx
, DISPID
*id
)
184 assert(V_VT(stack_top(ctx
)) == VT_INT
&& V_VT(stack_topn(ctx
, 1)) == VT_DISPATCH
);
186 *id
= V_INT(stack_pop(ctx
));
187 return V_DISPATCH(stack_pop(ctx
));
190 static inline IDispatch
*stack_topn_objid(exec_ctx_t
*ctx
, unsigned n
, DISPID
*id
)
192 assert(V_VT(stack_topn(ctx
, n
)) == VT_INT
&& V_VT(stack_topn(ctx
, n
+1)) == VT_DISPATCH
);
194 *id
= V_INT(stack_topn(ctx
, n
));
195 return V_DISPATCH(stack_topn(ctx
, n
+1));
198 static void exprval_release(exprval_t
*val
)
201 case EXPRVAL_VARIANT
:
202 if(V_VT(&val
->u
.var
) != VT_EMPTY
)
203 VariantClear(&val
->u
.var
);
206 if(val
->u
.idref
.disp
)
207 IDispatch_Release(val
->u
.idref
.disp
);
209 case EXPRVAL_INVALID
:
210 SysFreeString(val
->u
.identifier
);
214 /* ECMA-262 3rd Edition 8.7.1 */
215 static HRESULT
exprval_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
217 V_VT(ret
) = VT_EMPTY
;
220 case EXPRVAL_VARIANT
:
221 return VariantCopy(ret
, &val
->u
.var
);
223 if(!val
->u
.idref
.disp
) {
224 FIXME("throw ReferenceError\n");
228 return disp_propget(ctx
, val
->u
.idref
.disp
, val
->u
.idref
.id
, ret
, ei
, NULL
/*FIXME*/);
229 case EXPRVAL_INVALID
:
230 return throw_type_error(ctx
, ei
, JS_E_UNDEFINED_VARIABLE
, val
->u
.identifier
);
233 ERR("type %d\n", val
->type
);
237 static HRESULT
exprval_to_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
239 if(val
->type
== EXPRVAL_VARIANT
) {
241 V_VT(&val
->u
.var
) = VT_EMPTY
;
245 return exprval_value(ctx
, val
, ei
, ret
);
248 static HRESULT
exprval_to_boolean(script_ctx_t
*ctx
, exprval_t
*exprval
, jsexcept_t
*ei
, VARIANT_BOOL
*b
)
250 if(exprval
->type
!= EXPRVAL_VARIANT
) {
254 hres
= exprval_to_value(ctx
, exprval
, ei
, &val
);
258 hres
= to_boolean(&val
, b
);
263 return to_boolean(&exprval
->u
.var
, b
);
266 static void exprval_init(exprval_t
*val
)
268 val
->type
= EXPRVAL_VARIANT
;
269 V_VT(&val
->u
.var
) = VT_EMPTY
;
272 static void exprval_set_idref(exprval_t
*val
, IDispatch
*disp
, DISPID id
)
274 val
->type
= EXPRVAL_IDREF
;
275 val
->u
.idref
.disp
= disp
;
276 val
->u
.idref
.id
= id
;
279 IDispatch_AddRef(disp
);
282 HRESULT
scope_push(scope_chain_t
*scope
, jsdisp_t
*obj
, scope_chain_t
**ret
)
284 scope_chain_t
*new_scope
;
286 new_scope
= heap_alloc(sizeof(scope_chain_t
));
288 return E_OUTOFMEMORY
;
293 new_scope
->obj
= obj
;
297 new_scope
->next
= scope
;
299 new_scope
->next
= NULL
;
306 static void scope_pop(scope_chain_t
**scope
)
315 void scope_release(scope_chain_t
*scope
)
321 scope_release(scope
->next
);
323 jsdisp_release(scope
->obj
);
327 HRESULT
create_exec_ctx(script_ctx_t
*script_ctx
, IDispatch
*this_obj
, jsdisp_t
*var_disp
,
328 scope_chain_t
*scope
, BOOL is_global
, exec_ctx_t
**ret
)
332 ctx
= heap_alloc_zero(sizeof(exec_ctx_t
));
334 return E_OUTOFMEMORY
;
337 ctx
->is_global
= is_global
;
340 ctx
->this_obj
= this_obj
;
341 else if(script_ctx
->host_global
)
342 ctx
->this_obj
= script_ctx
->host_global
;
344 ctx
->this_obj
= to_disp(script_ctx
->global
);
345 IDispatch_AddRef(ctx
->this_obj
);
347 jsdisp_addref(var_disp
);
348 ctx
->var_disp
= var_disp
;
352 ctx
->scope_chain
= scope
;
359 void exec_release(exec_ctx_t
*ctx
)
365 scope_release(ctx
->scope_chain
);
367 jsdisp_release(ctx
->var_disp
);
369 IDispatch_Release(ctx
->this_obj
);
370 heap_free(ctx
->stack
);
374 static HRESULT
disp_get_id(script_ctx_t
*ctx
, IDispatch
*disp
, BSTR name
, DWORD flags
, DISPID
*id
)
379 hres
= IDispatch_QueryInterface(disp
, &IID_IDispatchEx
, (void**)&dispex
);
381 TRACE("unsing IDispatch\n");
384 return IDispatch_GetIDsOfNames(disp
, &IID_NULL
, &name
, 1, 0, id
);
388 hres
= IDispatchEx_GetDispID(dispex
, name
, make_grfdex(ctx
, flags
|fdexNameCaseSensitive
), id
);
389 IDispatchEx_Release(dispex
);
393 /* ECMA-262 3rd Edition 8.7.2 */
394 static HRESULT
put_value(script_ctx_t
*ctx
, exprval_t
*ref
, VARIANT
*v
, jsexcept_t
*ei
)
396 if(ref
->type
!= EXPRVAL_IDREF
)
397 return throw_reference_error(ctx
, ei
, JS_E_ILLEGAL_ASSIGN
, NULL
);
399 return disp_propput(ctx
, ref
->u
.idref
.disp
, ref
->u
.idref
.id
, v
, ei
, NULL
/*FIXME*/);
402 static inline BOOL
is_null(const VARIANT
*v
)
404 return V_VT(v
) == VT_NULL
|| (V_VT(v
) == VT_DISPATCH
&& !V_DISPATCH(v
));
407 static HRESULT
disp_cmp(IDispatch
*disp1
, IDispatch
*disp2
, BOOL
*ret
)
409 IObjectIdentity
*identity
;
410 IUnknown
*unk1
, *unk2
;
418 if(!disp1
|| !disp2
) {
423 hres
= IDispatch_QueryInterface(disp1
, &IID_IUnknown
, (void**)&unk1
);
427 hres
= IDispatch_QueryInterface(disp2
, &IID_IUnknown
, (void**)&unk2
);
429 IUnknown_Release(unk1
);
436 hres
= IUnknown_QueryInterface(unk1
, &IID_IObjectIdentity
, (void**)&identity
);
437 if(SUCCEEDED(hres
)) {
438 hres
= IObjectIdentity_IsEqualObject(identity
, unk2
);
439 IObjectIdentity_Release(identity
);
446 IUnknown_Release(unk1
);
447 IUnknown_Release(unk2
);
451 /* ECMA-262 3rd Edition 11.9.6 */
452 static HRESULT
equal2_values(VARIANT
*lval
, VARIANT
*rval
, BOOL
*ret
)
456 if(V_VT(lval
) != V_VT(rval
)) {
457 if(is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
)))
458 *ret
= num_val(lval
) == num_val(rval
);
459 else if(is_null(lval
))
460 *ret
= is_null(rval
);
472 *ret
= V_I4(lval
) == V_I4(rval
);
475 *ret
= V_R8(lval
) == V_R8(rval
);
479 *ret
= SysStringLen(V_BSTR(rval
))?FALSE
:TRUE
;
480 else if(!V_BSTR(rval
))
481 *ret
= SysStringLen(V_BSTR(lval
))?FALSE
:TRUE
;
483 *ret
= !strcmpW(V_BSTR(lval
), V_BSTR(rval
));
486 return disp_cmp(V_DISPATCH(lval
), V_DISPATCH(rval
), ret
);
488 *ret
= !V_BOOL(lval
) == !V_BOOL(rval
);
491 FIXME("unimplemented vt %d\n", V_VT(lval
));
498 static HRESULT
literal_to_var(script_ctx_t
*ctx
, literal_t
*literal
, VARIANT
*v
)
500 switch(literal
->type
) {
506 V_I4(v
) = literal
->u
.lval
;
510 V_R8(v
) = literal
->u
.dval
;
513 BSTR str
= SysAllocString(literal
->u
.wstr
);
515 return E_OUTOFMEMORY
;
523 V_BOOL(v
) = literal
->u
.bval
;
529 hres
= create_regexp(ctx
, literal
->u
.regexp
.str
, literal
->u
.regexp
.str_len
,
530 literal
->u
.regexp
.flags
, ®exp
);
534 var_set_jsdisp(v
, regexp
);
541 static BOOL
lookup_global_members(script_ctx_t
*ctx
, BSTR identifier
, exprval_t
*ret
)
547 for(item
= ctx
->named_items
; item
; item
= item
->next
) {
548 if(item
->flags
& SCRIPTITEM_GLOBALMEMBERS
) {
549 hres
= disp_get_id(ctx
, item
->disp
, identifier
, 0, &id
);
550 if(SUCCEEDED(hres
)) {
552 exprval_set_idref(ret
, item
->disp
, id
);
561 HRESULT
exec_source(exec_ctx_t
*ctx
, parser_ctx_t
*parser
, source_elements_t
*source
, BOOL from_eval
,
562 jsexcept_t
*ei
, VARIANT
*retv
)
564 script_ctx_t
*script
= parser
->script
;
565 function_declaration_t
*func
;
566 parser_ctx_t
*prev_parser
;
570 exec_ctx_t
*prev_ctx
;
574 for(func
= source
->functions
; func
; func
= func
->next
) {
578 hres
= create_source_function(parser
, func
->expr
->parameter_list
, func
->expr
->source_elements
,
579 ctx
->scope_chain
, func
->expr
->src_str
, func
->expr
->src_len
, &func_obj
);
583 var_set_jsdisp(&var
, func_obj
);
584 hres
= jsdisp_propput_name(ctx
->var_disp
, func
->expr
->identifier
, &var
, ei
, NULL
);
585 jsdisp_release(func_obj
);
590 for(var
= source
->variables
; var
; var
= var
->next
) {
594 name
= SysAllocString(var
->identifier
);
596 return E_OUTOFMEMORY
;
598 if(!ctx
->is_global
|| !lookup_global_members(parser
->script
, name
, NULL
))
599 hres
= jsdisp_get_id(ctx
->var_disp
, var
->identifier
, fdexNameEnsure
, &id
);
605 prev_ctx
= script
->exec_ctx
;
606 script
->exec_ctx
= ctx
;
608 prev_parser
= ctx
->parser
;
609 ctx
->parser
= parser
;
611 V_VT(&val
) = VT_EMPTY
;
612 memset(&rt
, 0, sizeof(rt
));
615 for(stat
= source
->statement
; stat
; stat
= stat
->next
) {
616 hres
= stat_eval(script
, stat
, &rt
, &tmp
);
622 if(rt
.type
!= RT_NORMAL
)
626 script
->exec_ctx
= prev_ctx
;
627 ctx
->parser
= prev_parser
;
629 if(rt
.type
!= RT_NORMAL
&& rt
.type
!= RT_RETURN
) {
630 FIXME("wrong rt %d\n", rt
.type
);
640 if(!retv
|| (!from_eval
&& rt
.type
!= RT_RETURN
))
647 /* ECMA-262 3rd Edition 10.1.4 */
648 static HRESULT
identifier_eval(script_ctx_t
*ctx
, BSTR identifier
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
650 scope_chain_t
*scope
;
655 TRACE("%s\n", debugstr_w(identifier
));
657 for(scope
= ctx
->exec_ctx
->scope_chain
; scope
; scope
= scope
->next
) {
658 hres
= jsdisp_get_id(scope
->obj
, identifier
, 0, &id
);
659 if(SUCCEEDED(hres
)) {
660 exprval_set_idref(ret
, to_disp(scope
->obj
), id
);
665 hres
= jsdisp_get_id(ctx
->global
, identifier
, 0, &id
);
666 if(SUCCEEDED(hres
)) {
667 exprval_set_idref(ret
, to_disp(ctx
->global
), id
);
671 for(item
= ctx
->named_items
; item
; item
= item
->next
) {
672 if((item
->flags
& SCRIPTITEM_ISVISIBLE
) && !strcmpW(item
->name
, identifier
)) {
679 hres
= IActiveScriptSite_GetItemInfo(ctx
->site
, identifier
,
680 SCRIPTINFO_IUNKNOWN
, &unk
, NULL
);
682 WARN("GetItemInfo failed: %08x\n", hres
);
686 hres
= IUnknown_QueryInterface(unk
, &IID_IDispatch
, (void**)&item
->disp
);
687 IUnknown_Release(unk
);
689 WARN("object does not implement IDispatch\n");
694 ret
->type
= EXPRVAL_VARIANT
;
695 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
696 V_DISPATCH(&ret
->u
.var
) = item
->disp
;
697 IDispatch_AddRef(item
->disp
);
702 if(lookup_global_members(ctx
, identifier
, ret
))
705 if(flags
& EXPR_NEWREF
) {
706 hres
= jsdisp_get_id(ctx
->global
, identifier
, fdexNameEnsure
, &id
);
710 exprval_set_idref(ret
, to_disp(ctx
->global
), id
);
714 ret
->type
= EXPRVAL_INVALID
;
715 ret
->u
.identifier
= SysAllocString(identifier
);
716 if(!ret
->u
.identifier
)
717 return E_OUTOFMEMORY
;
722 /* ECMA-262 3rd Edition 12.1 */
723 HRESULT
block_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
725 block_statement_t
*stat
= (block_statement_t
*)_stat
;
732 V_VT(&val
) = VT_EMPTY
;
733 for(iter
= stat
->stat_list
; iter
; iter
= iter
->next
) {
734 hres
= stat_eval(ctx
, iter
, rt
, &tmp
);
740 if(rt
->type
!= RT_NORMAL
)
753 /* ECMA-262 3rd Edition 12.2 */
754 static HRESULT
variable_list_eval(script_ctx_t
*ctx
, variable_declaration_t
*var_list
, jsexcept_t
*ei
)
756 variable_declaration_t
*iter
;
759 for(iter
= var_list
; iter
; iter
= iter
->next
) {
766 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
770 hres
= exprval_to_value(ctx
, &exprval
, ei
, &val
);
771 exprval_release(&exprval
);
775 hres
= jsdisp_propput_name(ctx
->exec_ctx
->var_disp
, iter
->identifier
, &val
, ei
, NULL
/*FIXME*/);
784 /* ECMA-262 3rd Edition 12.2 */
785 HRESULT
var_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
787 var_statement_t
*stat
= (var_statement_t
*)_stat
;
792 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
796 V_VT(ret
) = VT_EMPTY
;
800 /* ECMA-262 3rd Edition 12.3 */
801 HRESULT
empty_statement_eval(script_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
805 V_VT(ret
) = VT_EMPTY
;
809 /* ECMA-262 3rd Edition 12.4 */
810 HRESULT
expression_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
812 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
819 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NOVAL
, &rt
->ei
, &exprval
);
823 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
824 exprval_release(&exprval
);
829 TRACE("= %s\n", debugstr_variant(ret
));
833 /* ECMA-262 3rd Edition 12.5 */
834 HRESULT
if_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
836 if_statement_t
*stat
= (if_statement_t
*)_stat
;
843 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
847 hres
= exprval_to_boolean(ctx
, &exprval
, &rt
->ei
, &b
);
848 exprval_release(&exprval
);
853 hres
= stat_eval(ctx
, stat
->if_stat
, rt
, ret
);
854 else if(stat
->else_stat
)
855 hres
= stat_eval(ctx
, stat
->else_stat
, rt
, ret
);
857 V_VT(ret
) = VT_EMPTY
;
862 /* ECMA-262 3rd Edition 12.6.2 */
863 HRESULT
while_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
865 while_statement_t
*stat
= (while_statement_t
*)_stat
;
874 V_VT(&val
) = VT_EMPTY
;
875 test_expr
= !stat
->do_while
;
879 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
883 hres
= exprval_to_boolean(ctx
, &exprval
, &rt
->ei
, &b
);
884 exprval_release(&exprval
);
885 if(FAILED(hres
) || !b
)
891 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
898 if(rt
->type
== RT_CONTINUE
)
899 rt
->type
= RT_NORMAL
;
900 if(rt
->type
!= RT_NORMAL
)
909 if(rt
->type
== RT_BREAK
)
910 rt
->type
= RT_NORMAL
;
916 /* ECMA-262 3rd Edition 12.6.3 */
917 HRESULT
for_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
919 for_statement_t
*stat
= (for_statement_t
*)_stat
;
920 VARIANT val
, tmp
, retv
;
927 if(stat
->variable_list
) {
928 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
931 }else if(stat
->begin_expr
) {
932 hres
= expr_eval(ctx
, stat
->begin_expr
, 0, &rt
->ei
, &exprval
);
936 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
937 exprval_release(&exprval
);
944 V_VT(&retv
) = VT_EMPTY
;
948 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
952 hres
= exprval_to_boolean(ctx
, &exprval
, &rt
->ei
, &b
);
953 exprval_release(&exprval
);
954 if(FAILED(hres
) || !b
)
958 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
965 if(rt
->type
== RT_CONTINUE
)
966 rt
->type
= RT_NORMAL
;
967 else if(rt
->type
!= RT_NORMAL
)
971 hres
= expr_eval(ctx
, stat
->end_expr
, 0, &rt
->ei
, &exprval
);
975 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
976 exprval_release(&exprval
);
989 if(rt
->type
== RT_BREAK
)
990 rt
->type
= RT_NORMAL
;
996 /* ECMA-262 3rd Edition 12.6.4 */
997 HRESULT
forin_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
999 forin_statement_t
*stat
= (forin_statement_t
*)_stat
;
1000 VARIANT val
, name
, retv
, tmp
;
1001 DISPID id
= DISPID_STARTENUM
;
1002 BSTR str
, identifier
= NULL
;
1003 IDispatchEx
*in_obj
;
1009 if(stat
->variable
) {
1010 hres
= variable_list_eval(ctx
, stat
->variable
, &rt
->ei
);
1015 hres
= expr_eval(ctx
, stat
->in_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
1019 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
1020 exprval_release(&exprval
);
1024 if(V_VT(&val
) != VT_DISPATCH
) {
1025 TRACE("in vt %d\n", V_VT(&val
));
1027 V_VT(ret
) = VT_EMPTY
;
1031 hres
= IDispatch_QueryInterface(V_DISPATCH(&val
), &IID_IDispatchEx
, (void**)&in_obj
);
1032 IDispatch_Release(V_DISPATCH(&val
));
1034 TRACE("Object doesn't support IDispatchEx\n");
1035 V_VT(ret
) = VT_EMPTY
;
1039 V_VT(&retv
) = VT_EMPTY
;
1042 identifier
= SysAllocString(stat
->variable
->identifier
);
1045 hres
= IDispatchEx_GetNextDispID(in_obj
, fdexEnumDefault
, id
, &id
);
1046 if(FAILED(hres
) || hres
== S_FALSE
)
1049 hres
= IDispatchEx_GetMemberName(in_obj
, id
, &str
);
1053 TRACE("iter %s\n", debugstr_w(str
));
1056 hres
= identifier_eval(ctx
, identifier
, 0, NULL
, &exprval
);
1058 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
1059 if(SUCCEEDED(hres
)) {
1060 V_VT(&name
) = VT_BSTR
;
1061 V_BSTR(&name
) = str
;
1062 hres
= put_value(ctx
, &exprval
, &name
, &rt
->ei
);
1063 exprval_release(&exprval
);
1069 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
1073 VariantClear(&retv
);
1076 if(rt
->type
== RT_CONTINUE
)
1077 rt
->type
= RT_NORMAL
;
1078 else if(rt
->type
!= RT_NORMAL
)
1082 SysFreeString(identifier
);
1083 IDispatchEx_Release(in_obj
);
1085 VariantClear(&retv
);
1089 if(rt
->type
== RT_BREAK
)
1090 rt
->type
= RT_NORMAL
;
1096 /* ECMA-262 3rd Edition 12.7 */
1097 HRESULT
continue_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1099 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
1103 if(stat
->identifier
) {
1104 FIXME("indentifier not implemented\n");
1108 rt
->type
= RT_CONTINUE
;
1109 V_VT(ret
) = VT_EMPTY
;
1113 /* ECMA-262 3rd Edition 12.8 */
1114 HRESULT
break_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1116 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
1120 if(stat
->identifier
) {
1121 FIXME("indentifier not implemented\n");
1125 rt
->type
= RT_BREAK
;
1126 V_VT(ret
) = VT_EMPTY
;
1130 /* ECMA-262 3rd Edition 12.9 */
1131 HRESULT
return_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1133 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
1141 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1145 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, ret
);
1146 exprval_release(&exprval
);
1150 V_VT(ret
) = VT_EMPTY
;
1153 TRACE("= %s\n", debugstr_variant(ret
));
1154 rt
->type
= RT_RETURN
;
1158 /* ECMA-262 3rd Edition 12.10 */
1159 HRESULT
with_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1161 with_statement_t
*stat
= (with_statement_t
*)_stat
;
1170 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1174 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
1175 exprval_release(&exprval
);
1179 hres
= to_object(ctx
, &val
, &disp
);
1184 obj
= iface_to_jsdisp((IUnknown
*)disp
);
1185 IDispatch_Release(disp
);
1187 FIXME("disp id not jsdisp\n");
1191 hres
= scope_push(ctx
->exec_ctx
->scope_chain
, obj
, &ctx
->exec_ctx
->scope_chain
);
1192 jsdisp_release(obj
);
1196 hres
= stat_eval(ctx
, stat
->statement
, rt
, ret
);
1198 scope_pop(&ctx
->exec_ctx
->scope_chain
);
1202 /* ECMA-262 3rd Edition 12.12 */
1203 HRESULT
labelled_statement_eval(script_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
1209 /* ECMA-262 3rd Edition 12.13 */
1210 HRESULT
switch_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1212 switch_statement_t
*stat
= (switch_statement_t
*)_stat
;
1213 case_clausule_t
*iter
, *default_clausule
= NULL
;
1214 statement_t
*stat_iter
;
1222 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1226 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
1227 exprval_release(&exprval
);
1231 for(iter
= stat
->case_list
; iter
; iter
= iter
->next
) {
1233 default_clausule
= iter
;
1237 hres
= expr_eval(ctx
, iter
->expr
, 0, &rt
->ei
, &exprval
);
1241 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &cval
);
1242 exprval_release(&exprval
);
1246 hres
= equal2_values(&val
, &cval
, &b
);
1247 VariantClear(&cval
);
1248 if(FAILED(hres
) || b
)
1257 iter
= default_clausule
;
1259 V_VT(&val
) = VT_EMPTY
;
1263 for(stat_iter
= iter
->stat
; stat_iter
; stat_iter
= stat_iter
->next
) {
1264 hres
= stat_eval(ctx
, stat_iter
, rt
, &tmp
);
1271 if(rt
->type
!= RT_NORMAL
)
1281 if(rt
->type
== RT_BREAK
)
1282 rt
->type
= RT_NORMAL
;
1288 /* ECMA-262 3rd Edition 12.13 */
1289 HRESULT
throw_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1291 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
1298 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1302 hres
= exprval_to_value(ctx
, &exprval
, &rt
->ei
, &val
);
1303 exprval_release(&exprval
);
1308 return DISP_E_EXCEPTION
;
1311 static HRESULT
interp_throw(exec_ctx_t
*ctx
)
1313 const HRESULT arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
1315 TRACE("%08x\n", arg
);
1317 return throw_reference_error(ctx
->parser
->script
, &ctx
->ei
, arg
, NULL
);
1320 /* ECMA-262 3rd Edition 12.14 */
1321 static HRESULT
catch_eval(script_ctx_t
*ctx
, catch_block_t
*block
, return_type_t
*rt
, VARIANT
*ret
)
1328 memset(&rt
->ei
, 0, sizeof(jsexcept_t
));
1330 hres
= create_dispex(ctx
, NULL
, NULL
, &var_disp
);
1331 if(SUCCEEDED(hres
)) {
1332 hres
= jsdisp_propput_name(var_disp
, block
->identifier
, &ex
, &rt
->ei
, NULL
/*FIXME*/);
1333 if(SUCCEEDED(hres
)) {
1334 hres
= scope_push(ctx
->exec_ctx
->scope_chain
, var_disp
, &ctx
->exec_ctx
->scope_chain
);
1335 if(SUCCEEDED(hres
)) {
1336 hres
= stat_eval(ctx
, block
->statement
, rt
, &val
);
1337 scope_pop(&ctx
->exec_ctx
->scope_chain
);
1341 jsdisp_release(var_disp
);
1352 /* ECMA-262 3rd Edition 12.14 */
1353 HRESULT
try_statement_eval(script_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1355 try_statement_t
*stat
= (try_statement_t
*)_stat
;
1361 hres
= stat_eval(ctx
, stat
->try_statement
, rt
, &val
);
1363 TRACE("EXCEPTION\n");
1364 if(!stat
->catch_block
)
1367 hres
= catch_eval(ctx
, stat
->catch_block
, rt
, &val
);
1372 if(stat
->finally_statement
) {
1374 hres
= stat_eval(ctx
, stat
->finally_statement
, rt
, &val
);
1383 static HRESULT
return_bool(exprval_t
*ret
, DWORD b
)
1385 ret
->type
= EXPRVAL_VARIANT
;
1386 V_VT(&ret
->u
.var
) = VT_BOOL
;
1387 V_BOOL(&ret
->u
.var
) = b
? VARIANT_TRUE
: VARIANT_FALSE
;
1392 static HRESULT
get_binary_expr_values(script_ctx_t
*ctx
, binary_expression_t
*expr
, jsexcept_t
*ei
, VARIANT
*lval
, VARIANT
*rval
)
1397 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1401 hres
= exprval_to_value(ctx
, &exprval
, ei
, lval
);
1402 exprval_release(&exprval
);
1406 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1407 if(SUCCEEDED(hres
)) {
1408 hres
= exprval_to_value(ctx
, &exprval
, ei
, rval
);
1409 exprval_release(&exprval
);
1420 typedef HRESULT (*oper_t
)(script_ctx_t
*,VARIANT
*,VARIANT
*,jsexcept_t
*,VARIANT
*);
1422 static HRESULT
binary_expr_eval(script_ctx_t
*ctx
, binary_expression_t
*expr
, oper_t oper
, jsexcept_t
*ei
,
1425 VARIANT lval
, rval
, retv
;
1428 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1432 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1433 VariantClear(&lval
);
1434 VariantClear(&rval
);
1438 ret
->type
= EXPRVAL_VARIANT
;
1443 /* ECMA-262 3rd Edition 13 */
1444 HRESULT
function_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1446 function_expression_t
*expr
= (function_expression_t
*)_expr
;
1452 if(expr
->identifier
) {
1453 hres
= jsdisp_propget_name(ctx
->exec_ctx
->var_disp
, expr
->identifier
, &var
, ei
, NULL
/*FIXME*/);
1459 hres
= create_source_function(ctx
->exec_ctx
->parser
, expr
->parameter_list
, expr
->source_elements
, ctx
->exec_ctx
->scope_chain
,
1460 expr
->src_str
, expr
->src_len
, &dispex
);
1464 var_set_jsdisp(&var
, dispex
);
1467 ret
->type
= EXPRVAL_VARIANT
;
1472 /* ECMA-262 3rd Edition 11.2.1 */
1473 HRESULT
array_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1475 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1477 VARIANT member
, val
;
1480 IDispatch
*obj
= NULL
;
1485 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1489 hres
= exprval_to_value(ctx
, &exprval
, ei
, &member
);
1490 exprval_release(&exprval
);
1494 hres
= expr_eval(ctx
, expr
->expression2
, EXPR_NEWREF
, ei
, &exprval
);
1495 if(SUCCEEDED(hres
)) {
1496 hres
= exprval_to_value(ctx
, &exprval
, ei
, &val
);
1497 exprval_release(&exprval
);
1500 if(SUCCEEDED(hres
)) {
1501 hres
= to_object(ctx
, &member
, &obj
);
1505 VariantClear(&member
);
1506 if(SUCCEEDED(hres
)) {
1507 hres
= to_string(ctx
, &val
, ei
, &str
);
1509 if(SUCCEEDED(hres
)) {
1510 hres
= disp_get_id(ctx
, obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1514 if(SUCCEEDED(hres
)) {
1515 exprval_set_idref(ret
, obj
, id
);
1516 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1521 IDispatch_Release(obj
);
1527 /* ECMA-262 3rd Edition 11.2.1 */
1528 static HRESULT
interp_array(exec_ctx_t
*ctx
)
1538 namev
= stack_pop(ctx
);
1540 hres
= stack_pop_object(ctx
, &obj
);
1542 VariantClear(namev
);
1546 hres
= to_string(ctx
->parser
->script
, namev
, &ctx
->ei
, &name
);
1547 VariantClear(namev
);
1549 IDispatch_Release(obj
);
1553 hres
= disp_get_id(ctx
->parser
->script
, obj
, name
, 0, &id
);
1554 SysFreeString(name
);
1555 if(SUCCEEDED(hres
)) {
1556 hres
= disp_propget(ctx
->parser
->script
, obj
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
1557 }else if(hres
== DISP_E_UNKNOWNNAME
) {
1558 V_VT(&v
) = VT_EMPTY
;
1561 IDispatch_Release(obj
);
1565 return stack_push(ctx
, &v
);
1568 /* ECMA-262 3rd Edition 11.2.1 */
1569 HRESULT
member_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1571 member_expression_t
*expr
= (member_expression_t
*)_expr
;
1572 IDispatch
*obj
= NULL
;
1581 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1585 hres
= exprval_to_value(ctx
, &exprval
, ei
, &member
);
1586 exprval_release(&exprval
);
1590 hres
= to_object(ctx
, &member
, &obj
);
1591 VariantClear(&member
);
1595 str
= SysAllocString(expr
->identifier
);
1597 IDispatch_Release(obj
);
1598 return E_OUTOFMEMORY
;
1601 hres
= disp_get_id(ctx
, obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1603 if(SUCCEEDED(hres
)) {
1604 exprval_set_idref(ret
, obj
, id
);
1605 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1610 IDispatch_Release(obj
);
1614 /* ECMA-262 3rd Edition 11.2.1 */
1615 static HRESULT
interp_member(exec_ctx_t
*ctx
)
1617 const BSTR arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.bstr
;
1625 hres
= stack_pop_object(ctx
, &obj
);
1629 hres
= disp_get_id(ctx
->parser
->script
, obj
, arg
, 0, &id
);
1630 if(SUCCEEDED(hres
)) {
1631 hres
= disp_propget(ctx
->parser
->script
, obj
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
1632 }else if(hres
== DISP_E_UNKNOWNNAME
) {
1633 V_VT(&v
) = VT_EMPTY
;
1636 IDispatch_Release(obj
);
1640 return stack_push(ctx
, &v
);
1643 /* ECMA-262 3rd Edition 11.2.1 */
1644 static HRESULT
interp_memberid(exec_ctx_t
*ctx
)
1646 const unsigned arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
1647 VARIANT
*objv
, *namev
;
1655 namev
= stack_pop(ctx
);
1656 objv
= stack_pop(ctx
);
1658 hres
= to_object(ctx
->parser
->script
, objv
, &obj
);
1660 if(SUCCEEDED(hres
)) {
1661 hres
= to_string(ctx
->parser
->script
, namev
, &ctx
->ei
, &name
);
1663 IDispatch_Release(obj
);
1665 VariantClear(namev
);
1669 hres
= disp_get_id(ctx
->parser
->script
, obj
, name
, arg
, &id
);
1670 SysFreeString(name
);
1672 IDispatch_Release(obj
);
1673 if(hres
== DISP_E_UNKNOWNNAME
&& !(arg
& fdexNameEnsure
)) {
1675 id
= JS_E_INVALID_PROPERTY
;
1681 return stack_push_objid(ctx
, obj
, id
);
1684 /* ECMA-262 3rd Edition 11.2.1 */
1685 static HRESULT
interp_refval(exec_ctx_t
*ctx
)
1694 disp
= stack_topn_objid(ctx
, 0, &id
);
1696 return throw_reference_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_ILLEGAL_ASSIGN
, NULL
);
1698 hres
= disp_propget(ctx
->parser
->script
, disp
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
1702 return stack_push(ctx
, &v
);
1705 static void jsstack_to_dp(exec_ctx_t
*ctx
, unsigned arg_cnt
, DISPPARAMS
*dp
)
1710 dp
->cArgs
= arg_cnt
;
1711 dp
->rgdispidNamedArgs
= NULL
;
1714 assert(ctx
->top
>= arg_cnt
);
1716 for(i
=1; i
*2 <= arg_cnt
; i
++) {
1717 tmp
= ctx
->stack
[ctx
->top
-i
];
1718 ctx
->stack
[ctx
->top
-i
] = ctx
->stack
[ctx
->top
-arg_cnt
+i
-1];
1719 ctx
->stack
[ctx
->top
-arg_cnt
+i
-1] = tmp
;
1722 dp
->rgvarg
= ctx
->stack
+ ctx
->top
-arg_cnt
;
1725 /* ECMA-262 3rd Edition 11.2.2 */
1726 static HRESULT
interp_new(exec_ctx_t
*ctx
)
1728 const LONG arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
1735 constr
= stack_topn(ctx
, arg
);
1737 /* NOTE: Should use to_object here */
1739 if(V_VT(constr
) == VT_NULL
)
1740 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_OBJECT_EXPECTED
, NULL
);
1741 else if(V_VT(constr
) != VT_DISPATCH
)
1742 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_INVALID_ACTION
, NULL
);
1743 else if(!V_DISPATCH(constr
))
1744 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_INVALID_PROPERTY
, NULL
);
1746 jsstack_to_dp(ctx
, arg
, &dp
);
1747 hres
= disp_call(ctx
->parser
->script
, V_DISPATCH(constr
), DISPID_VALUE
,
1748 DISPATCH_CONSTRUCT
, &dp
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
1752 stack_popn(ctx
, arg
+1);
1753 return stack_push(ctx
, &v
);
1756 /* ECMA-262 3rd Edition 11.2.3 */
1757 static HRESULT
interp_call(exec_ctx_t
*ctx
)
1759 const unsigned argn
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
1760 const int do_ret
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg2
.lng
;
1765 TRACE("%d %d\n", argn
, do_ret
);
1767 objv
= stack_topn(ctx
, argn
);
1768 if(V_VT(objv
) != VT_DISPATCH
)
1769 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_INVALID_PROPERTY
, NULL
);
1771 jsstack_to_dp(ctx
, argn
, &dp
);
1772 hres
= disp_call(ctx
->parser
->script
, V_DISPATCH(objv
), DISPID_VALUE
, DISPATCH_METHOD
, &dp
,
1773 do_ret
? &v
: NULL
, &ctx
->ei
, NULL
/*FIXME*/);
1777 stack_popn(ctx
, argn
+1);
1778 return do_ret
? stack_push(ctx
, &v
) : S_OK
;
1782 /* ECMA-262 3rd Edition 11.2.3 */
1783 static HRESULT
interp_call_member(exec_ctx_t
*ctx
)
1785 const unsigned argn
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
1786 const int do_ret
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg2
.lng
;
1793 TRACE("%d %d\n", argn
, do_ret
);
1795 obj
= stack_topn_objid(ctx
, argn
, &id
);
1797 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, id
, NULL
);
1799 jsstack_to_dp(ctx
, argn
, &dp
);
1800 hres
= disp_call(ctx
->parser
->script
, obj
, id
, DISPATCH_METHOD
, &dp
, do_ret
? &v
: NULL
, &ctx
->ei
, NULL
/*FIXME*/);
1804 stack_popn(ctx
, argn
+2);
1805 return do_ret
? stack_push(ctx
, &v
) : S_OK
;
1809 /* ECMA-262 3rd Edition 11.1.1 */
1810 static HRESULT
interp_this(exec_ctx_t
*ctx
)
1816 V_VT(&v
) = VT_DISPATCH
;
1817 V_DISPATCH(&v
) = ctx
->this_obj
;
1818 IDispatch_AddRef(ctx
->this_obj
);
1819 return stack_push(ctx
, &v
);
1822 /* ECMA-262 3rd Edition 10.1.4 */
1823 HRESULT
identifier_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1825 identifier_expression_t
*expr
= (identifier_expression_t
*)_expr
;
1831 identifier
= SysAllocString(expr
->identifier
);
1833 return E_OUTOFMEMORY
;
1835 hres
= identifier_eval(ctx
, identifier
, flags
, ei
, ret
);
1837 SysFreeString(identifier
);
1841 /* ECMA-262 3rd Edition 10.1.4 */
1842 static HRESULT
interp_ident(exec_ctx_t
*ctx
)
1844 const BSTR arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.bstr
;
1849 TRACE("%s\n", debugstr_w(arg
));
1851 hres
= identifier_eval(ctx
->parser
->script
, arg
, 0, &ctx
->ei
, &exprval
);
1855 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &ctx
->ei
, &v
);
1856 exprval_release(&exprval
);
1860 return stack_push(ctx
, &v
);
1863 /* ECMA-262 3rd Edition 10.1.4 */
1864 static HRESULT
interp_identid(exec_ctx_t
*ctx
)
1866 const BSTR arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.bstr
;
1867 const unsigned flags
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg2
.uint
;
1871 TRACE("%s %x\n", debugstr_w(arg
), flags
);
1873 hres
= identifier_eval(ctx
->parser
->script
, arg
, (flags
&fdexNameEnsure
) ? EXPR_NEWREF
: 0, &ctx
->ei
, &exprval
);
1877 if(exprval
.type
!= EXPRVAL_IDREF
) {
1878 WARN("invalid ref\n");
1879 exprval_release(&exprval
);
1880 return stack_push_objid(ctx
, NULL
, JS_E_OBJECT_EXPECTED
);
1883 return stack_push_objid(ctx
, exprval
.u
.idref
.disp
, exprval
.u
.idref
.id
);
1886 /* ECMA-262 3rd Edition 7.8.1 */
1887 static HRESULT
interp_null(exec_ctx_t
*ctx
)
1894 return stack_push(ctx
, &v
);
1897 /* ECMA-262 3rd Edition 7.8.2 */
1898 static HRESULT
interp_bool(exec_ctx_t
*ctx
)
1900 const LONG arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
1902 TRACE("%s\n", arg
? "true" : "false");
1904 return stack_push_bool(ctx
, arg
);
1907 /* ECMA-262 3rd Edition 7.8.3 */
1908 static HRESULT
interp_int(exec_ctx_t
*ctx
)
1910 const LONG arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
1917 return stack_push(ctx
, &v
);
1920 /* ECMA-262 3rd Edition 7.8.3 */
1921 static HRESULT
interp_double(exec_ctx_t
*ctx
)
1923 const double arg
= *ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.dbl
;
1926 TRACE("%lf\n", arg
);
1930 return stack_push(ctx
, &v
);
1933 /* ECMA-262 3rd Edition 7.8.4 */
1934 static HRESULT
interp_str(exec_ctx_t
*ctx
)
1936 const WCHAR
*str
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.str
;
1939 TRACE("%s\n", debugstr_w(str
));
1942 V_BSTR(&v
) = SysAllocString(str
);
1944 return E_OUTOFMEMORY
;
1946 return stack_push(ctx
, &v
);
1949 /* ECMA-262 3rd Edition 7.8 */
1950 static HRESULT
interp_regexp(exec_ctx_t
*ctx
)
1952 const WCHAR
*source
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.str
;
1953 const LONG flags
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg2
.lng
;
1958 TRACE("%s %x\n", debugstr_w(source
), flags
);
1960 hres
= create_regexp(ctx
->parser
->script
, source
, strlenW(source
), flags
, ®exp
);
1964 var_set_jsdisp(&v
, regexp
);
1965 return stack_push(ctx
, &v
);
1968 /* ECMA-262 3rd Edition 11.1.4 */
1969 static HRESULT
interp_carray(exec_ctx_t
*ctx
)
1971 const unsigned arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
1979 hres
= create_array(ctx
->parser
->script
, arg
, &array
);
1986 hres
= jsdisp_propput_idx(array
, i
, v
, &ctx
->ei
, NULL
/*FIXME*/);
1989 jsdisp_release(array
);
1994 var_set_jsdisp(&r
, array
);
1995 return stack_push(ctx
, &r
);
1998 /* ECMA-262 3rd Edition 11.1.5 */
1999 HRESULT
property_value_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2001 property_value_expression_t
*expr
= (property_value_expression_t
*)_expr
;
2011 hres
= create_object(ctx
, NULL
, &obj
);
2015 for(iter
= expr
->property_list
; iter
; iter
= iter
->next
) {
2016 hres
= literal_to_var(ctx
, iter
->name
, &tmp
);
2020 hres
= to_string(ctx
, &tmp
, ei
, &name
);
2025 hres
= expr_eval(ctx
, iter
->value
, 0, ei
, &exprval
);
2026 if(SUCCEEDED(hres
)) {
2027 hres
= exprval_to_value(ctx
, &exprval
, ei
, &val
);
2028 exprval_release(&exprval
);
2029 if(SUCCEEDED(hres
)) {
2030 hres
= jsdisp_propput_name(obj
, name
, &val
, ei
, NULL
/*FIXME*/);
2035 SysFreeString(name
);
2041 jsdisp_release(obj
);
2045 ret
->type
= EXPRVAL_VARIANT
;
2046 var_set_jsdisp(&ret
->u
.var
, obj
);
2050 /* ECMA-262 3rd Edition 11.11 */
2051 static HRESULT
interp_jmp_nz(exec_ctx_t
*ctx
)
2053 const unsigned arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
2059 hres
= to_boolean(stack_top(ctx
), &b
);
2072 /* ECMA-262 3rd Edition 11.11 */
2073 static HRESULT
interp_jmp_z(exec_ctx_t
*ctx
)
2075 const unsigned arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
2081 hres
= to_boolean(stack_top(ctx
), &b
);
2094 /* ECMA-262 3rd Edition 11.10 */
2095 static HRESULT
interp_or(exec_ctx_t
*ctx
)
2102 hres
= stack_pop_int(ctx
, &r
);
2106 hres
= stack_pop_int(ctx
, &l
);
2110 return stack_push_int(ctx
, l
|r
);
2113 /* ECMA-262 3rd Edition 11.10 */
2114 static HRESULT
interp_xor(exec_ctx_t
*ctx
)
2121 hres
= stack_pop_int(ctx
, &r
);
2125 hres
= stack_pop_int(ctx
, &l
);
2129 return stack_push_int(ctx
, l
^r
);
2132 /* ECMA-262 3rd Edition 11.10 */
2133 static HRESULT
interp_and(exec_ctx_t
*ctx
)
2140 hres
= stack_pop_int(ctx
, &r
);
2144 hres
= stack_pop_int(ctx
, &l
);
2148 return stack_push_int(ctx
, l
&r
);
2151 /* ECMA-262 3rd Edition 11.8.6 */
2152 static HRESULT
instanceof_eval(script_ctx_t
*ctx
, VARIANT
*inst
, VARIANT
*objv
, jsexcept_t
*ei
, VARIANT
*retv
)
2154 jsdisp_t
*obj
, *iter
, *tmp
= NULL
;
2155 VARIANT_BOOL ret
= VARIANT_FALSE
;
2160 static const WCHAR prototypeW
[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
2162 if(V_VT(objv
) != VT_DISPATCH
|| !V_DISPATCH(objv
))
2163 return throw_type_error(ctx
, ei
, JS_E_FUNCTION_EXPECTED
, NULL
);
2165 obj
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(objv
));
2167 FIXME("non-jsdisp objects not supported\n");
2171 if(is_class(obj
, JSCLASS_FUNCTION
)) {
2172 hres
= jsdisp_propget_name(obj
, prototypeW
, &var
, ei
, NULL
/*FIXME*/);
2174 hres
= throw_type_error(ctx
, ei
, JS_E_FUNCTION_EXPECTED
, NULL
);
2176 jsdisp_release(obj
);
2180 if(V_VT(&var
) == VT_DISPATCH
) {
2181 if(V_VT(inst
) == VT_DISPATCH
)
2182 tmp
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(inst
));
2183 for(iter
= tmp
; iter
; iter
= iter
->prototype
) {
2184 hres
= disp_cmp(V_DISPATCH(&var
), to_disp(iter
), &b
);
2194 jsdisp_release(tmp
);
2196 FIXME("prototype is not an object\n");
2204 V_VT(retv
) = VT_BOOL
;
2209 /* ECMA-262 3rd Edition 11.8.6 */
2210 HRESULT
instanceof_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2212 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2216 return binary_expr_eval(ctx
, expr
, instanceof_eval
, ei
, ret
);
2219 /* ECMA-262 3rd Edition 11.8.7 */
2220 static HRESULT
interp_in(exec_ctx_t
*ctx
)
2230 obj
= stack_pop(ctx
);
2233 if(V_VT(obj
) != VT_DISPATCH
|| !V_DISPATCH(obj
)) {
2236 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_OBJECT_EXPECTED
, NULL
);
2239 hres
= to_string(ctx
->parser
->script
, v
, &ctx
->ei
, &str
);
2242 IDispatch_Release(V_DISPATCH(obj
));
2246 hres
= disp_get_id(ctx
->parser
->script
, V_DISPATCH(obj
), str
, 0, &id
);
2247 IDispatch_Release(V_DISPATCH(obj
));
2251 else if(hres
== DISP_E_UNKNOWNNAME
)
2256 return stack_push_bool(ctx
, ret
);
2259 /* ECMA-262 3rd Edition 11.6.1 */
2260 static HRESULT
add_eval(script_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2265 hres
= to_primitive(ctx
, lval
, ei
, &l
, NO_HINT
);
2269 hres
= to_primitive(ctx
, rval
, ei
, &r
, NO_HINT
);
2275 if(V_VT(&l
) == VT_BSTR
|| V_VT(&r
) == VT_BSTR
) {
2276 BSTR lstr
= NULL
, rstr
= NULL
;
2278 if(V_VT(&l
) == VT_BSTR
)
2281 hres
= to_string(ctx
, &l
, ei
, &lstr
);
2283 if(SUCCEEDED(hres
)) {
2284 if(V_VT(&r
) == VT_BSTR
)
2287 hres
= to_string(ctx
, &r
, ei
, &rstr
);
2290 if(SUCCEEDED(hres
)) {
2293 len1
= SysStringLen(lstr
);
2294 len2
= SysStringLen(rstr
);
2296 V_VT(retv
) = VT_BSTR
;
2297 V_BSTR(retv
) = SysAllocStringLen(NULL
, len1
+len2
);
2298 memcpy(V_BSTR(retv
), lstr
, len1
*sizeof(WCHAR
));
2299 memcpy(V_BSTR(retv
)+len1
, rstr
, (len2
+1)*sizeof(WCHAR
));
2302 if(V_VT(&l
) != VT_BSTR
)
2303 SysFreeString(lstr
);
2304 if(V_VT(&r
) != VT_BSTR
)
2305 SysFreeString(rstr
);
2309 hres
= to_number(ctx
, &l
, ei
, &nl
);
2310 if(SUCCEEDED(hres
)) {
2311 hres
= to_number(ctx
, &r
, ei
, &nr
);
2313 num_set_val(retv
, num_val(&nl
) + num_val(&nr
));
2322 /* ECMA-262 3rd Edition 11.6.1 */
2323 static HRESULT
interp_add(exec_ctx_t
*ctx
)
2325 VARIANT
*l
, *r
, ret
;
2331 TRACE("%s + %s\n", debugstr_variant(l
), debugstr_variant(r
));
2333 hres
= add_eval(ctx
->parser
->script
, l
, r
, &ctx
->ei
, &ret
);
2339 return stack_push(ctx
, &ret
);
2342 /* ECMA-262 3rd Edition 11.6.2 */
2343 static HRESULT
interp_sub(exec_ctx_t
*ctx
)
2350 hres
= stack_pop_number(ctx
, &r
);
2354 hres
= stack_pop_number(ctx
, &l
);
2358 return stack_push_number(ctx
, num_val(&l
)-num_val(&r
));
2361 /* ECMA-262 3rd Edition 11.5.1 */
2362 static HRESULT
interp_mul(exec_ctx_t
*ctx
)
2369 hres
= stack_pop_number(ctx
, &r
);
2373 hres
= stack_pop_number(ctx
, &l
);
2377 return stack_push_number(ctx
, num_val(&l
)*num_val(&r
));
2380 /* ECMA-262 3rd Edition 11.5.2 */
2381 static HRESULT
interp_div(exec_ctx_t
*ctx
)
2388 hres
= stack_pop_number(ctx
, &r
);
2392 hres
= stack_pop_number(ctx
, &l
);
2396 return stack_push_number(ctx
, num_val(&l
)/num_val(&r
));
2399 /* ECMA-262 3rd Edition 11.5.3 */
2400 static HRESULT
interp_mod(exec_ctx_t
*ctx
)
2407 hres
= stack_pop_number(ctx
, &r
);
2411 hres
= stack_pop_number(ctx
, &l
);
2415 return stack_push_number(ctx
, fmod(num_val(&l
), num_val(&r
)));
2418 /* ECMA-262 3rd Edition 11.4.2 */
2419 HRESULT
delete_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2421 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2422 VARIANT_BOOL b
= VARIANT_FALSE
;
2428 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2432 switch(exprval
.type
) {
2433 case EXPRVAL_IDREF
: {
2434 IDispatchEx
*dispex
;
2436 hres
= IDispatch_QueryInterface(exprval
.u
.idref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2437 if(SUCCEEDED(hres
)) {
2438 hres
= IDispatchEx_DeleteMemberByDispID(dispex
, exprval
.u
.idref
.id
);
2440 IDispatchEx_Release(dispex
);
2445 FIXME("unsupported type %d\n", exprval
.type
);
2449 exprval_release(&exprval
);
2453 return return_bool(ret
, b
);
2456 /* ECMA-262 3rd Edition 11.4.2 */
2457 static HRESULT
interp_delete(exec_ctx_t
*ctx
)
2459 VARIANT
*obj_var
, *name_var
;
2460 IDispatchEx
*dispex
;
2468 name_var
= stack_pop(ctx
);
2469 obj_var
= stack_pop(ctx
);
2471 hres
= to_object(ctx
->parser
->script
, obj_var
, &obj
);
2472 VariantClear(obj_var
);
2474 VariantClear(name_var
);
2478 hres
= to_string(ctx
->parser
->script
, name_var
, &ctx
->ei
, &name
);
2479 VariantClear(name_var
);
2481 IDispatch_Release(obj
);
2485 hres
= IDispatch_QueryInterface(obj
, &IID_IDispatchEx
, (void**)&dispex
);
2486 if(SUCCEEDED(hres
)) {
2487 hres
= IDispatchEx_DeleteMemberByName(dispex
, name
, make_grfdex(ctx
->parser
->script
, fdexNameCaseSensitive
));
2489 IDispatchEx_Release(dispex
);
2495 IDispatch_Release(obj
);
2496 SysFreeString(name
);
2500 return stack_push_bool(ctx
, ret
);
2503 /* ECMA-262 3rd Edition 11.4.2 */
2504 static HRESULT
interp_void(exec_ctx_t
*ctx
)
2512 V_VT(&v
) = VT_EMPTY
;
2513 return stack_push(ctx
, &v
);
2516 /* ECMA-262 3rd Edition 11.4.3 */
2517 static HRESULT
typeof_exprval(script_ctx_t
*ctx
, exprval_t
*exprval
, jsexcept_t
*ei
, const WCHAR
**ret
)
2522 static const WCHAR booleanW
[] = {'b','o','o','l','e','a','n',0};
2523 static const WCHAR functionW
[] = {'f','u','n','c','t','i','o','n',0};
2524 static const WCHAR numberW
[] = {'n','u','m','b','e','r',0};
2525 static const WCHAR objectW
[] = {'o','b','j','e','c','t',0};
2526 static const WCHAR stringW
[] = {'s','t','r','i','n','g',0};
2527 static const WCHAR undefinedW
[] = {'u','n','d','e','f','i','n','e','d',0};
2528 static const WCHAR unknownW
[] = {'u','n','k','n','o','w','n',0};
2530 if(exprval
->type
== EXPRVAL_INVALID
) {
2535 hres
= exprval_to_value(ctx
, exprval
, ei
, &val
);
2537 if(exprval
->type
== EXPRVAL_IDREF
) {
2544 switch(V_VT(&val
)) {
2564 if(V_DISPATCH(&val
) && (dispex
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(&val
)))) {
2565 *ret
= is_class(dispex
, JSCLASS_FUNCTION
) ? functionW
: objectW
;
2566 jsdisp_release(dispex
);
2573 FIXME("unhandled vt %d\n", V_VT(&val
));
2581 HRESULT
typeof_expression_eval(script_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2583 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2584 const WCHAR
*str
= NULL
;
2590 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2594 hres
= typeof_exprval(ctx
, &exprval
, ei
, &str
);
2595 exprval_release(&exprval
);
2599 ret
->type
= EXPRVAL_VARIANT
;
2600 V_VT(&ret
->u
.var
) = VT_BSTR
;
2601 V_BSTR(&ret
->u
.var
) = SysAllocString(str
);
2602 if(!V_BSTR(&ret
->u
.var
))
2603 return E_OUTOFMEMORY
;
2608 /* ECMA-262 3rd Edition 11.4.7 */
2609 static HRESULT
interp_minus(exec_ctx_t
*ctx
)
2616 hres
= stack_pop_number(ctx
, &n
);
2620 return stack_push_number(ctx
, -num_val(&n
));
2623 /* ECMA-262 3rd Edition 11.4.6 */
2624 static HRESULT
interp_tonum(exec_ctx_t
*ctx
)
2632 hres
= to_number(ctx
->parser
->script
, v
, &ctx
->ei
, &num
);
2637 return stack_push(ctx
, &num
);
2640 /* ECMA-262 3rd Edition 11.3.1 */
2641 static HRESULT
interp_postinc(exec_ctx_t
*ctx
)
2643 const int arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
2651 obj
= stack_pop_objid(ctx
, &id
);
2653 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_OBJECT_EXPECTED
, NULL
);
2655 hres
= disp_propget(ctx
->parser
->script
, obj
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
2656 if(SUCCEEDED(hres
)) {
2659 hres
= to_number(ctx
->parser
->script
, &v
, &ctx
->ei
, &n
);
2660 if(SUCCEEDED(hres
)) {
2661 num_set_val(&inc
, num_val(&n
)+(double)arg
);
2662 hres
= disp_propput(ctx
->parser
->script
, obj
, id
, &inc
, &ctx
->ei
, NULL
/*FIXME*/);
2667 IDispatch_Release(obj
);
2671 return stack_push(ctx
, &v
);
2674 /* ECMA-262 3rd Edition 11.4.4, 11.4.5 */
2675 static HRESULT
interp_preinc(exec_ctx_t
*ctx
)
2677 const int arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.lng
;
2685 obj
= stack_pop_objid(ctx
, &id
);
2687 return throw_type_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_OBJECT_EXPECTED
, NULL
);
2689 hres
= disp_propget(ctx
->parser
->script
, obj
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
2690 if(SUCCEEDED(hres
)) {
2693 hres
= to_number(ctx
->parser
->script
, &v
, &ctx
->ei
, &n
);
2695 if(SUCCEEDED(hres
)) {
2696 num_set_val(&v
, num_val(&n
)+(double)arg
);
2697 hres
= disp_propput(ctx
->parser
->script
, obj
, id
, &v
, &ctx
->ei
, NULL
/*FIXME*/);
2700 IDispatch_Release(obj
);
2704 return stack_push(ctx
, &v
);
2707 /* ECMA-262 3rd Edition 11.9.3 */
2708 static HRESULT
equal_values(script_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, BOOL
*ret
)
2710 if(V_VT(lval
) == V_VT(rval
) || (is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
))))
2711 return equal2_values(lval
, rval
, ret
);
2713 /* FIXME: NULL disps should be handled in more general way */
2714 if(V_VT(lval
) == VT_DISPATCH
&& !V_DISPATCH(lval
)) {
2717 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2720 if(V_VT(rval
) == VT_DISPATCH
&& !V_DISPATCH(rval
)) {
2723 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2726 if((V_VT(lval
) == VT_NULL
&& V_VT(rval
) == VT_EMPTY
) ||
2727 (V_VT(lval
) == VT_EMPTY
&& V_VT(rval
) == VT_NULL
)) {
2732 if(V_VT(lval
) == VT_BSTR
&& is_num_vt(V_VT(rval
))) {
2736 hres
= to_number(ctx
, lval
, ei
, &v
);
2740 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2743 if(V_VT(rval
) == VT_BSTR
&& is_num_vt(V_VT(lval
))) {
2747 hres
= to_number(ctx
, rval
, ei
, &v
);
2751 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2754 if(V_VT(rval
) == VT_BOOL
) {
2758 V_I4(&v
) = V_BOOL(rval
) ? 1 : 0;
2759 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2762 if(V_VT(lval
) == VT_BOOL
) {
2766 V_I4(&v
) = V_BOOL(lval
) ? 1 : 0;
2767 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2771 if(V_VT(rval
) == VT_DISPATCH
&& (V_VT(lval
) == VT_BSTR
|| is_num_vt(V_VT(lval
)))) {
2775 hres
= to_primitive(ctx
, rval
, ei
, &v
, NO_HINT
);
2779 hres
= equal_values(ctx
, lval
, &v
, ei
, ret
);
2786 if(V_VT(lval
) == VT_DISPATCH
&& (V_VT(rval
) == VT_BSTR
|| is_num_vt(V_VT(rval
)))) {
2790 hres
= to_primitive(ctx
, lval
, ei
, &v
, NO_HINT
);
2794 hres
= equal_values(ctx
, &v
, rval
, ei
, ret
);
2805 /* ECMA-262 3rd Edition 11.9.1 */
2806 static HRESULT
interp_eq(exec_ctx_t
*ctx
)
2815 TRACE("%s == %s\n", debugstr_variant(l
), debugstr_variant(r
));
2817 hres
= equal_values(ctx
->parser
->script
, l
, r
, &ctx
->ei
, &b
);
2823 return stack_push_bool(ctx
, b
);
2826 /* ECMA-262 3rd Edition 11.9.2 */
2827 static HRESULT
interp_neq(exec_ctx_t
*ctx
)
2836 TRACE("%s != %s\n", debugstr_variant(l
), debugstr_variant(r
));
2838 hres
= equal_values(ctx
->parser
->script
, l
, r
, &ctx
->ei
, &b
);
2844 return stack_push_bool(ctx
, !b
);
2847 /* ECMA-262 3rd Edition 11.9.4 */
2848 static HRESULT
interp_eq2(exec_ctx_t
*ctx
)
2859 hres
= equal2_values(r
, l
, &b
);
2865 return stack_push_bool(ctx
, b
);
2868 /* ECMA-262 3rd Edition 11.9.5 */
2869 static HRESULT
interp_neq2(exec_ctx_t
*ctx
)
2880 hres
= equal2_values(r
, l
, &b
);
2886 return stack_push_bool(ctx
, !b
);
2889 /* ECMA-262 3rd Edition 11.8.5 */
2890 static HRESULT
less_eval(script_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, BOOL greater
, jsexcept_t
*ei
, BOOL
*ret
)
2892 VARIANT l
, r
, ln
, rn
;
2895 hres
= to_primitive(ctx
, lval
, ei
, &l
, NO_HINT
);
2899 hres
= to_primitive(ctx
, rval
, ei
, &r
, NO_HINT
);
2905 if(V_VT(&l
) == VT_BSTR
&& V_VT(&r
) == VT_BSTR
) {
2906 *ret
= (strcmpW(V_BSTR(&l
), V_BSTR(&r
)) < 0) ^ greater
;
2907 SysFreeString(V_BSTR(&l
));
2908 SysFreeString(V_BSTR(&r
));
2912 hres
= to_number(ctx
, &l
, ei
, &ln
);
2915 hres
= to_number(ctx
, &r
, ei
, &rn
);
2920 if(V_VT(&ln
) == VT_I4
&& V_VT(&rn
) == VT_I4
) {
2921 *ret
= (V_I4(&ln
) < V_I4(&rn
)) ^ greater
;
2923 DOUBLE ld
= num_val(&ln
);
2924 DOUBLE rd
= num_val(&rn
);
2926 *ret
= !isnan(ld
) && !isnan(rd
) && ((ld
< rd
) ^ greater
);
2932 /* ECMA-262 3rd Edition 11.8.1 */
2933 static HRESULT
interp_lt(exec_ctx_t
*ctx
)
2942 TRACE("%s < %s\n", debugstr_variant(l
), debugstr_variant(r
));
2944 hres
= less_eval(ctx
->parser
->script
, l
, r
, FALSE
, &ctx
->ei
, &b
);
2950 return stack_push_bool(ctx
, b
);
2953 /* ECMA-262 3rd Edition 11.8.1 */
2954 static HRESULT
interp_lteq(exec_ctx_t
*ctx
)
2963 TRACE("%s <= %s\n", debugstr_variant(l
), debugstr_variant(r
));
2965 hres
= less_eval(ctx
->parser
->script
, r
, l
, TRUE
, &ctx
->ei
, &b
);
2971 return stack_push_bool(ctx
, b
);
2974 /* ECMA-262 3rd Edition 11.8.2 */
2975 static HRESULT
interp_gt(exec_ctx_t
*ctx
)
2984 TRACE("%s > %s\n", debugstr_variant(l
), debugstr_variant(r
));
2986 hres
= less_eval(ctx
->parser
->script
, r
, l
, FALSE
, &ctx
->ei
, &b
);
2992 return stack_push_bool(ctx
, b
);
2995 /* ECMA-262 3rd Edition 11.8.4 */
2996 static HRESULT
interp_gteq(exec_ctx_t
*ctx
)
3005 TRACE("%s >= %s\n", debugstr_variant(l
), debugstr_variant(r
));
3007 hres
= less_eval(ctx
->parser
->script
, l
, r
, TRUE
, &ctx
->ei
, &b
);
3013 return stack_push_bool(ctx
, b
);
3016 /* ECMA-262 3rd Edition 11.4.8 */
3017 static HRESULT
interp_bneg(exec_ctx_t
*ctx
)
3026 hres
= to_int32(ctx
->parser
->script
, v
, &ctx
->ei
, &i
);
3033 return stack_push(ctx
, &r
);
3036 /* ECMA-262 3rd Edition 11.4.9 */
3037 static HRESULT
interp_neg(exec_ctx_t
*ctx
)
3046 hres
= to_boolean(v
, &b
);
3051 return stack_push_bool(ctx
, !b
);
3054 /* ECMA-262 3rd Edition 11.7.1 */
3055 static HRESULT
interp_lshift(exec_ctx_t
*ctx
)
3061 hres
= stack_pop_uint(ctx
, &r
);
3065 hres
= stack_pop_int(ctx
, &l
);
3069 return stack_push_int(ctx
, l
<< (r
&0x1f));
3072 /* ECMA-262 3rd Edition 11.7.2 */
3073 static HRESULT
interp_rshift(exec_ctx_t
*ctx
)
3079 hres
= stack_pop_uint(ctx
, &r
);
3083 hres
= stack_pop_int(ctx
, &l
);
3087 return stack_push_int(ctx
, l
>> (r
&0x1f));
3090 /* ECMA-262 3rd Edition 11.7.3 */
3091 static HRESULT
interp_rshift2(exec_ctx_t
*ctx
)
3096 hres
= stack_pop_uint(ctx
, &r
);
3100 hres
= stack_pop_uint(ctx
, &l
);
3104 return stack_push_int(ctx
, l
>> (r
&0x1f));
3107 /* ECMA-262 3rd Edition 11.13.1 */
3108 static HRESULT
interp_assign(exec_ctx_t
*ctx
)
3118 disp
= stack_pop_objid(ctx
, &id
);
3121 return throw_reference_error(ctx
->parser
->script
, &ctx
->ei
, JS_E_ILLEGAL_ASSIGN
, NULL
);
3123 hres
= disp_propput(ctx
->parser
->script
, disp
, id
, v
, &ctx
->ei
, NULL
/*FIXME*/);
3124 IDispatch_Release(disp
);
3130 return stack_push(ctx
, v
);
3133 static HRESULT
interp_undefined(exec_ctx_t
*ctx
)
3139 V_VT(&v
) = VT_EMPTY
;
3140 return stack_push(ctx
, &v
);
3143 static HRESULT
interp_jmp(exec_ctx_t
*ctx
)
3145 const unsigned arg
= ctx
->parser
->code
->instrs
[ctx
->ip
].arg1
.uint
;
3153 static HRESULT
interp_pop(exec_ctx_t
*ctx
)
3161 static HRESULT
interp_ret(exec_ctx_t
*ctx
)
3169 static HRESULT
interp_tree(exec_ctx_t
*ctx
)
3171 instr_t
*instr
= ctx
->parser
->code
->instrs
+ctx
->ip
;
3178 hres
= expr_eval(ctx
->parser
->script
, instr
->arg1
.expr
, 0, &ctx
->ei
, &val
);
3182 hres
= exprval_to_value(ctx
->parser
->script
, &val
, &ctx
->ei
, &v
);
3183 exprval_release(&val
);
3187 return stack_push(ctx
, &v
);
3190 typedef HRESULT (*op_func_t
)(exec_ctx_t
*);
3192 static const op_func_t op_funcs
[] = {
3193 #define X(x,a,b,c) interp_##x,
3198 static const unsigned op_move
[] = {
3199 #define X(a,x,b,c) x,
3204 static HRESULT
interp_expression_eval(script_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3206 exec_ctx_t
*exec_ctx
= ctx
->exec_ctx
;
3207 unsigned prev_ip
, prev_top
;
3209 HRESULT hres
= S_OK
;
3213 prev_top
= exec_ctx
->top
;
3214 prev_ip
= exec_ctx
->ip
;
3215 exec_ctx
->ip
= expr
->instr_off
;
3217 while(exec_ctx
->ip
!= -1) {
3218 op
= exec_ctx
->parser
->code
->instrs
[exec_ctx
->ip
].op
;
3219 hres
= op_funcs
[op
](exec_ctx
);
3222 exec_ctx
->ip
+= op_move
[op
];
3225 exec_ctx
->ip
= prev_ip
;
3228 stack_popn(exec_ctx
, exec_ctx
->top
-prev_top
);
3230 memset(&exec_ctx
->ei
, 0, sizeof(exec_ctx
->ei
));
3234 assert(exec_ctx
->top
== prev_top
+1 || ((flags
&EXPR_NOVAL
) && exec_ctx
->top
== prev_top
));
3236 ret
->type
= EXPRVAL_VARIANT
;
3237 if(exec_ctx
->top
== prev_top
)
3238 V_VT(&ret
->u
.var
) = VT_EMPTY
;
3240 ret
->u
.var
= *stack_pop(exec_ctx
);
3244 HRESULT
compiled_expression_eval(script_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3250 hres
= compile_subscript(ctx
->exec_ctx
->parser
, expr
, !(flags
& EXPR_NOVAL
), &expr
->instr_off
);
3254 if(expr
->eval
== compiled_expression_eval
)
3255 expr
->eval
= interp_expression_eval
;
3257 return expr
->eval(ctx
, expr
, flags
, ei
, ret
);