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"
27 #include "wine/debug.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(jscript
);
31 #define EXPR_NOVAL 0x0001
32 #define EXPR_NEWREF 0x0002
33 #define EXPR_STRREF 0x0004
35 static inline HRESULT
stat_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
37 return stat
->eval(ctx
, stat
, rt
, ret
);
40 static inline HRESULT
expr_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
42 return _expr
->eval(ctx
, _expr
, flags
, ei
, ret
);
45 static void exprval_release(exprval_t
*val
)
49 if(V_VT(&val
->u
.var
) != VT_EMPTY
)
50 VariantClear(&val
->u
.var
);
54 IDispatch_Release(val
->u
.idref
.disp
);
57 if(val
->u
.nameref
.disp
)
58 IDispatch_Release(val
->u
.nameref
.disp
);
59 SysFreeString(val
->u
.nameref
.name
);
62 SysFreeString(val
->u
.identifier
);
66 /* ECMA-262 3rd Edition 8.7.1 */
67 static HRESULT
exprval_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
73 return VariantCopy(ret
, &val
->u
.var
);
75 if(!val
->u
.idref
.disp
) {
76 FIXME("throw ReferenceError\n");
80 return disp_propget(ctx
, val
->u
.idref
.disp
, val
->u
.idref
.id
, ret
, ei
, NULL
/*FIXME*/);
84 return throw_type_error(ctx
, ei
, IDS_UNDEFINED
, val
->u
.identifier
);
87 ERR("type %d\n", val
->type
);
91 static HRESULT
exprval_to_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
93 if(val
->type
== EXPRVAL_VARIANT
) {
95 V_VT(&val
->u
.var
) = VT_EMPTY
;
99 return exprval_value(ctx
, val
, ei
, ret
);
102 static HRESULT
exprval_to_boolean(script_ctx_t
*ctx
, exprval_t
*exprval
, jsexcept_t
*ei
, VARIANT_BOOL
*b
)
104 if(exprval
->type
!= EXPRVAL_VARIANT
) {
108 hres
= exprval_to_value(ctx
, exprval
, ei
, &val
);
112 hres
= to_boolean(&val
, b
);
117 return to_boolean(&exprval
->u
.var
, b
);
120 static void exprval_init(exprval_t
*val
)
122 val
->type
= EXPRVAL_VARIANT
;
123 V_VT(&val
->u
.var
) = VT_EMPTY
;
126 static void exprval_set_idref(exprval_t
*val
, IDispatch
*disp
, DISPID id
)
128 val
->type
= EXPRVAL_IDREF
;
129 val
->u
.idref
.disp
= disp
;
130 val
->u
.idref
.id
= id
;
133 IDispatch_AddRef(disp
);
136 HRESULT
scope_push(scope_chain_t
*scope
, jsdisp_t
*obj
, scope_chain_t
**ret
)
138 scope_chain_t
*new_scope
;
140 new_scope
= heap_alloc(sizeof(scope_chain_t
));
142 return E_OUTOFMEMORY
;
147 new_scope
->obj
= obj
;
151 new_scope
->next
= scope
;
153 new_scope
->next
= NULL
;
160 static void scope_pop(scope_chain_t
**scope
)
169 void scope_release(scope_chain_t
*scope
)
175 scope_release(scope
->next
);
177 jsdisp_release(scope
->obj
);
181 HRESULT
create_exec_ctx(script_ctx_t
*script_ctx
, IDispatch
*this_obj
, jsdisp_t
*var_disp
,
182 scope_chain_t
*scope
, exec_ctx_t
**ret
)
186 ctx
= heap_alloc_zero(sizeof(exec_ctx_t
));
188 return E_OUTOFMEMORY
;
193 ctx
->this_obj
= this_obj
;
194 else if(script_ctx
->host_global
)
195 ctx
->this_obj
= script_ctx
->host_global
;
197 ctx
->this_obj
= to_disp(script_ctx
->global
);
198 IDispatch_AddRef(ctx
->this_obj
);
200 jsdisp_addref(var_disp
);
201 ctx
->var_disp
= var_disp
;
205 ctx
->scope_chain
= scope
;
212 void exec_release(exec_ctx_t
*ctx
)
218 scope_release(ctx
->scope_chain
);
220 jsdisp_release(ctx
->var_disp
);
222 IDispatch_Release(ctx
->this_obj
);
226 static HRESULT
disp_get_id(script_ctx_t
*ctx
, IDispatch
*disp
, BSTR name
, DWORD flags
, DISPID
*id
)
231 hres
= IDispatch_QueryInterface(disp
, &IID_IDispatchEx
, (void**)&dispex
);
233 TRACE("unsing IDispatch\n");
236 return IDispatch_GetIDsOfNames(disp
, &IID_NULL
, &name
, 1, 0, id
);
240 hres
= IDispatchEx_GetDispID(dispex
, name
, make_grfdex(ctx
, flags
|fdexNameCaseSensitive
), id
);
241 IDispatchEx_Release(dispex
);
245 /* ECMA-262 3rd Edition 8.7.2 */
246 static HRESULT
put_value(script_ctx_t
*ctx
, exprval_t
*ref
, VARIANT
*v
, jsexcept_t
*ei
)
248 if(ref
->type
!= EXPRVAL_IDREF
)
249 return throw_reference_error(ctx
, ei
, IDS_ILLEGAL_ASSIGN
, NULL
);
251 return disp_propput(ctx
, ref
->u
.idref
.disp
, ref
->u
.idref
.id
, v
, ei
, NULL
/*FIXME*/);
254 static inline BOOL
is_null(const VARIANT
*v
)
256 return V_VT(v
) == VT_NULL
|| (V_VT(v
) == VT_DISPATCH
&& !V_DISPATCH(v
));
259 static HRESULT
disp_cmp(IDispatch
*disp1
, IDispatch
*disp2
, BOOL
*ret
)
261 IObjectIdentity
*identity
;
262 IUnknown
*unk1
, *unk2
;
270 if(!disp1
|| !disp2
) {
275 hres
= IDispatch_QueryInterface(disp1
, &IID_IUnknown
, (void**)&unk1
);
279 hres
= IDispatch_QueryInterface(disp2
, &IID_IUnknown
, (void**)&unk2
);
281 IUnknown_Release(unk1
);
288 hres
= IUnknown_QueryInterface(unk1
, &IID_IObjectIdentity
, (void**)&identity
);
289 if(SUCCEEDED(hres
)) {
290 hres
= IObjectIdentity_IsEqualObject(identity
, unk2
);
291 IObjectIdentity_Release(identity
);
298 IUnknown_Release(unk1
);
299 IUnknown_Release(unk2
);
303 /* ECMA-262 3rd Edition 11.9.6 */
304 static HRESULT
equal2_values(VARIANT
*lval
, VARIANT
*rval
, BOOL
*ret
)
308 if(V_VT(lval
) != V_VT(rval
)) {
309 if(is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
)))
310 *ret
= num_val(lval
) == num_val(rval
);
311 else if(is_null(lval
))
312 *ret
= is_null(rval
);
324 *ret
= V_I4(lval
) == V_I4(rval
);
327 *ret
= V_R8(lval
) == V_R8(rval
);
331 *ret
= SysStringLen(V_BSTR(rval
))?FALSE
:TRUE
;
332 else if(!V_BSTR(rval
))
333 *ret
= SysStringLen(V_BSTR(lval
))?FALSE
:TRUE
;
335 *ret
= !strcmpW(V_BSTR(lval
), V_BSTR(rval
));
338 return disp_cmp(V_DISPATCH(lval
), V_DISPATCH(rval
), ret
);
340 *ret
= !V_BOOL(lval
) == !V_BOOL(rval
);
343 FIXME("unimplemented vt %d\n", V_VT(lval
));
350 static HRESULT
literal_to_var(script_ctx_t
*ctx
, literal_t
*literal
, VARIANT
*v
)
352 switch(literal
->type
) {
358 V_I4(v
) = literal
->u
.lval
;
362 V_R8(v
) = literal
->u
.dval
;
365 BSTR str
= SysAllocString(literal
->u
.wstr
);
367 return E_OUTOFMEMORY
;
375 V_BOOL(v
) = literal
->u
.bval
;
381 hres
= create_regexp(ctx
, literal
->u
.regexp
.str
, literal
->u
.regexp
.str_len
,
382 literal
->u
.regexp
.flags
, ®exp
);
386 var_set_jsdisp(v
, regexp
);
393 static BOOL
lookup_global_members(script_ctx_t
*ctx
, BSTR identifier
, exprval_t
*ret
)
399 for(item
= ctx
->named_items
; item
; item
= item
->next
) {
400 if(item
->flags
& SCRIPTITEM_GLOBALMEMBERS
) {
401 hres
= disp_get_id(ctx
, item
->disp
, identifier
, 0, &id
);
402 if(SUCCEEDED(hres
)) {
404 exprval_set_idref(ret
, item
->disp
, id
);
413 HRESULT
exec_source(exec_ctx_t
*ctx
, parser_ctx_t
*parser
, source_elements_t
*source
, exec_type_t exec_type
,
414 jsexcept_t
*ei
, VARIANT
*retv
)
416 script_ctx_t
*script
= parser
->script
;
417 function_declaration_t
*func
;
418 parser_ctx_t
*prev_parser
;
422 exec_ctx_t
*prev_ctx
;
426 for(func
= source
->functions
; func
; func
= func
->next
) {
430 hres
= create_source_function(parser
, func
->expr
->parameter_list
, func
->expr
->source_elements
,
431 ctx
->scope_chain
, func
->expr
->src_str
, func
->expr
->src_len
, &func_obj
);
435 var_set_jsdisp(&var
, func_obj
);
436 hres
= jsdisp_propput_name(ctx
->var_disp
, func
->expr
->identifier
, &var
, ei
, NULL
);
437 jsdisp_release(func_obj
);
442 for(var
= source
->variables
; var
; var
= var
->next
) {
446 name
= SysAllocString(var
->identifier
);
448 return E_OUTOFMEMORY
;
450 if(!lookup_global_members(parser
->script
, name
, NULL
))
451 hres
= jsdisp_get_id(ctx
->var_disp
, var
->identifier
, fdexNameEnsure
, &id
);
457 prev_ctx
= script
->exec_ctx
;
458 script
->exec_ctx
= ctx
;
460 prev_parser
= ctx
->parser
;
461 ctx
->parser
= parser
;
463 V_VT(&val
) = VT_EMPTY
;
464 memset(&rt
, 0, sizeof(rt
));
467 for(stat
= source
->statement
; stat
; stat
= stat
->next
) {
468 hres
= stat_eval(ctx
, stat
, &rt
, &tmp
);
474 if(rt
.type
!= RT_NORMAL
)
478 script
->exec_ctx
= prev_ctx
;
479 ctx
->parser
= prev_parser
;
481 if(rt
.type
!= RT_NORMAL
&& rt
.type
!= RT_RETURN
) {
482 FIXME("wrong rt %d\n", rt
.type
);
492 if(retv
&& (exec_type
== EXECT_EVAL
|| rt
.type
== RT_RETURN
))
503 /* ECMA-262 3rd Edition 10.1.4 */
504 static HRESULT
identifier_eval(exec_ctx_t
*ctx
, BSTR identifier
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
506 scope_chain_t
*scope
;
511 TRACE("%s\n", debugstr_w(identifier
));
513 for(scope
= ctx
->scope_chain
; scope
; scope
= scope
->next
) {
514 hres
= jsdisp_get_id(scope
->obj
, identifier
, 0, &id
);
520 exprval_set_idref(ret
, to_disp(scope
->obj
), id
);
524 hres
= jsdisp_get_id(ctx
->parser
->script
->global
, identifier
, 0, &id
);
525 if(SUCCEEDED(hres
)) {
526 exprval_set_idref(ret
, to_disp(ctx
->parser
->script
->global
), id
);
530 for(item
= ctx
->parser
->script
->named_items
; item
; item
= item
->next
) {
531 if((item
->flags
& SCRIPTITEM_ISVISIBLE
) && !strcmpW(item
->name
, identifier
)) {
535 if(!ctx
->parser
->script
->site
)
538 hres
= IActiveScriptSite_GetItemInfo(ctx
->parser
->script
->site
, identifier
,
539 SCRIPTINFO_IUNKNOWN
, &unk
, NULL
);
541 WARN("GetItemInfo failed: %08x\n", hres
);
545 hres
= IUnknown_QueryInterface(unk
, &IID_IDispatch
, (void**)&item
->disp
);
546 IUnknown_Release(unk
);
548 WARN("object does not implement IDispatch\n");
553 ret
->type
= EXPRVAL_VARIANT
;
554 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
555 V_DISPATCH(&ret
->u
.var
) = item
->disp
;
556 IDispatch_AddRef(item
->disp
);
561 if(lookup_global_members(ctx
->parser
->script
, identifier
, ret
))
564 if(flags
& EXPR_NEWREF
) {
565 hres
= jsdisp_get_id(ctx
->parser
->script
->global
, identifier
, fdexNameEnsure
, &id
);
569 exprval_set_idref(ret
, to_disp(ctx
->parser
->script
->global
), id
);
573 ret
->type
= EXPRVAL_INVALID
;
574 ret
->u
.identifier
= SysAllocString(identifier
);
575 if(!ret
->u
.identifier
)
576 return E_OUTOFMEMORY
;
581 /* ECMA-262 3rd Edition 12.1 */
582 HRESULT
block_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
584 block_statement_t
*stat
= (block_statement_t
*)_stat
;
591 V_VT(&val
) = VT_EMPTY
;
592 for(iter
= stat
->stat_list
; iter
; iter
= iter
->next
) {
593 hres
= stat_eval(ctx
, iter
, rt
, &tmp
);
599 if(rt
->type
!= RT_NORMAL
)
612 /* ECMA-262 3rd Edition 12.2 */
613 static HRESULT
variable_list_eval(exec_ctx_t
*ctx
, variable_declaration_t
*var_list
, jsexcept_t
*ei
)
615 variable_declaration_t
*iter
;
618 for(iter
= var_list
; iter
; iter
= iter
->next
) {
625 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
629 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
630 exprval_release(&exprval
);
634 hres
= jsdisp_propput_name(ctx
->var_disp
, iter
->identifier
, &val
, ei
, NULL
/*FIXME*/);
643 /* ECMA-262 3rd Edition 12.2 */
644 HRESULT
var_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
646 var_statement_t
*stat
= (var_statement_t
*)_stat
;
651 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
655 V_VT(ret
) = VT_EMPTY
;
659 /* ECMA-262 3rd Edition 12.3 */
660 HRESULT
empty_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
664 V_VT(ret
) = VT_EMPTY
;
668 /* ECMA-262 3rd Edition 12.4 */
669 HRESULT
expression_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
671 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
678 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NOVAL
, &rt
->ei
, &exprval
);
682 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
683 exprval_release(&exprval
);
688 TRACE("= %s\n", debugstr_variant(ret
));
692 /* ECMA-262 3rd Edition 12.5 */
693 HRESULT
if_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
695 if_statement_t
*stat
= (if_statement_t
*)_stat
;
702 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
706 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
707 exprval_release(&exprval
);
712 hres
= stat_eval(ctx
, stat
->if_stat
, rt
, ret
);
713 else if(stat
->else_stat
)
714 hres
= stat_eval(ctx
, stat
->else_stat
, rt
, ret
);
716 V_VT(ret
) = VT_EMPTY
;
721 /* ECMA-262 3rd Edition 12.6.2 */
722 HRESULT
while_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
724 while_statement_t
*stat
= (while_statement_t
*)_stat
;
733 V_VT(&val
) = VT_EMPTY
;
734 test_expr
= !stat
->do_while
;
738 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
742 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
743 exprval_release(&exprval
);
744 if(FAILED(hres
) || !b
)
750 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
757 if(rt
->type
== RT_CONTINUE
)
758 rt
->type
= RT_NORMAL
;
759 if(rt
->type
!= RT_NORMAL
)
768 if(rt
->type
== RT_BREAK
)
769 rt
->type
= RT_NORMAL
;
775 /* ECMA-262 3rd Edition 12.6.3 */
776 HRESULT
for_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
778 for_statement_t
*stat
= (for_statement_t
*)_stat
;
779 VARIANT val
, tmp
, retv
;
786 if(stat
->variable_list
) {
787 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
790 }else if(stat
->begin_expr
) {
791 hres
= expr_eval(ctx
, stat
->begin_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
795 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
796 exprval_release(&exprval
);
803 V_VT(&retv
) = VT_EMPTY
;
807 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
811 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
812 exprval_release(&exprval
);
813 if(FAILED(hres
) || !b
)
817 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
824 if(rt
->type
== RT_CONTINUE
)
825 rt
->type
= RT_NORMAL
;
826 else if(rt
->type
!= RT_NORMAL
)
830 hres
= expr_eval(ctx
, stat
->end_expr
, 0, &rt
->ei
, &exprval
);
834 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
835 exprval_release(&exprval
);
848 if(rt
->type
== RT_BREAK
)
849 rt
->type
= RT_NORMAL
;
855 /* ECMA-262 3rd Edition 12.6.4 */
856 HRESULT
forin_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
858 forin_statement_t
*stat
= (forin_statement_t
*)_stat
;
859 VARIANT val
, name
, retv
, tmp
;
860 DISPID id
= DISPID_STARTENUM
;
861 BSTR str
, identifier
= NULL
;
869 hres
= variable_list_eval(ctx
, stat
->variable
, &rt
->ei
);
874 hres
= expr_eval(ctx
, stat
->in_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
878 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
879 exprval_release(&exprval
);
883 if(V_VT(&val
) != VT_DISPATCH
) {
884 TRACE("in vt %d\n", V_VT(&val
));
886 V_VT(ret
) = VT_EMPTY
;
890 hres
= IDispatch_QueryInterface(V_DISPATCH(&val
), &IID_IDispatchEx
, (void**)&in_obj
);
891 IDispatch_Release(V_DISPATCH(&val
));
893 FIXME("Object doesn't support IDispatchEx\n");
897 V_VT(&retv
) = VT_EMPTY
;
900 identifier
= SysAllocString(stat
->variable
->identifier
);
903 hres
= IDispatchEx_GetNextDispID(in_obj
, fdexEnumDefault
, id
, &id
);
904 if(FAILED(hres
) || hres
== S_FALSE
)
907 hres
= IDispatchEx_GetMemberName(in_obj
, id
, &str
);
911 TRACE("iter %s\n", debugstr_w(str
));
914 hres
= identifier_eval(ctx
, identifier
, 0, NULL
, &exprval
);
916 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
917 if(SUCCEEDED(hres
)) {
918 V_VT(&name
) = VT_BSTR
;
920 hres
= put_value(ctx
->parser
->script
, &exprval
, &name
, &rt
->ei
);
921 exprval_release(&exprval
);
927 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
934 if(rt
->type
== RT_CONTINUE
)
935 rt
->type
= RT_NORMAL
;
936 else if(rt
->type
!= RT_NORMAL
)
940 SysFreeString(identifier
);
941 IDispatchEx_Release(in_obj
);
947 if(rt
->type
== RT_BREAK
)
948 rt
->type
= RT_NORMAL
;
954 /* ECMA-262 3rd Edition 12.7 */
955 HRESULT
continue_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
957 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
961 if(stat
->identifier
) {
962 FIXME("indentifier not implemented\n");
966 rt
->type
= RT_CONTINUE
;
967 V_VT(ret
) = VT_EMPTY
;
971 /* ECMA-262 3rd Edition 12.8 */
972 HRESULT
break_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
974 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
978 if(stat
->identifier
) {
979 FIXME("indentifier not implemented\n");
984 V_VT(ret
) = VT_EMPTY
;
988 /* ECMA-262 3rd Edition 12.9 */
989 HRESULT
return_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
991 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
999 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1003 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, ret
);
1004 exprval_release(&exprval
);
1008 V_VT(ret
) = VT_EMPTY
;
1011 TRACE("= %s\n", debugstr_variant(ret
));
1012 rt
->type
= RT_RETURN
;
1016 /* ECMA-262 3rd Edition 12.10 */
1017 HRESULT
with_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1019 with_statement_t
*stat
= (with_statement_t
*)_stat
;
1028 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1032 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1033 exprval_release(&exprval
);
1037 hres
= to_object(ctx
->parser
->script
, &val
, &disp
);
1042 obj
= iface_to_jsdisp((IUnknown
*)disp
);
1043 IDispatch_Release(disp
);
1045 FIXME("disp id not jsdisp\n");
1049 hres
= scope_push(ctx
->scope_chain
, obj
, &ctx
->scope_chain
);
1050 jsdisp_release(obj
);
1054 hres
= stat_eval(ctx
, stat
->statement
, rt
, ret
);
1056 scope_pop(&ctx
->scope_chain
);
1060 /* ECMA-262 3rd Edition 12.12 */
1061 HRESULT
labelled_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
1067 /* ECMA-262 3rd Edition 12.13 */
1068 HRESULT
switch_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1070 switch_statement_t
*stat
= (switch_statement_t
*)_stat
;
1071 case_clausule_t
*iter
, *default_clausule
= NULL
;
1072 statement_t
*stat_iter
;
1080 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1084 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1085 exprval_release(&exprval
);
1089 for(iter
= stat
->case_list
; iter
; iter
= iter
->next
) {
1091 default_clausule
= iter
;
1095 hres
= expr_eval(ctx
, iter
->expr
, 0, &rt
->ei
, &exprval
);
1099 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &cval
);
1100 exprval_release(&exprval
);
1104 hres
= equal2_values(&val
, &cval
, &b
);
1105 VariantClear(&cval
);
1106 if(FAILED(hres
) || b
)
1115 iter
= default_clausule
;
1117 V_VT(&val
) = VT_EMPTY
;
1121 for(stat_iter
= iter
->stat
; stat_iter
; stat_iter
= stat_iter
->next
) {
1122 hres
= stat_eval(ctx
, stat_iter
, rt
, &tmp
);
1129 if(rt
->type
!= RT_NORMAL
)
1139 if(rt
->type
== RT_BREAK
)
1140 rt
->type
= RT_NORMAL
;
1146 /* ECMA-262 3rd Edition 12.13 */
1147 HRESULT
throw_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1149 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
1156 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1160 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1161 exprval_release(&exprval
);
1166 return DISP_E_EXCEPTION
;
1169 /* ECMA-262 3rd Edition 12.14 */
1170 static HRESULT
catch_eval(exec_ctx_t
*ctx
, catch_block_t
*block
, return_type_t
*rt
, VARIANT
*ret
)
1177 memset(&rt
->ei
, 0, sizeof(jsexcept_t
));
1179 hres
= create_dispex(ctx
->parser
->script
, NULL
, NULL
, &var_disp
);
1180 if(SUCCEEDED(hres
)) {
1181 hres
= jsdisp_propput_name(var_disp
, block
->identifier
, &ex
, &rt
->ei
, NULL
/*FIXME*/);
1182 if(SUCCEEDED(hres
)) {
1183 hres
= scope_push(ctx
->scope_chain
, var_disp
, &ctx
->scope_chain
);
1184 if(SUCCEEDED(hres
)) {
1185 hres
= stat_eval(ctx
, block
->statement
, rt
, &val
);
1186 scope_pop(&ctx
->scope_chain
);
1190 jsdisp_release(var_disp
);
1201 /* ECMA-262 3rd Edition 12.14 */
1202 HRESULT
try_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1204 try_statement_t
*stat
= (try_statement_t
*)_stat
;
1210 hres
= stat_eval(ctx
, stat
->try_statement
, rt
, &val
);
1212 TRACE("EXCEPTION\n");
1213 if(!stat
->catch_block
)
1216 hres
= catch_eval(ctx
, stat
->catch_block
, rt
, &val
);
1221 if(stat
->finally_statement
) {
1223 hres
= stat_eval(ctx
, stat
->finally_statement
, rt
, &val
);
1232 static HRESULT
return_bool(exprval_t
*ret
, DWORD b
)
1234 ret
->type
= EXPRVAL_VARIANT
;
1235 V_VT(&ret
->u
.var
) = VT_BOOL
;
1236 V_BOOL(&ret
->u
.var
) = b
? VARIANT_TRUE
: VARIANT_FALSE
;
1241 static HRESULT
get_binary_expr_values(exec_ctx_t
*ctx
, binary_expression_t
*expr
, jsexcept_t
*ei
, VARIANT
*lval
, VARIANT
*rval
)
1246 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1250 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, lval
);
1251 exprval_release(&exprval
);
1255 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1256 if(SUCCEEDED(hres
)) {
1257 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, rval
);
1258 exprval_release(&exprval
);
1269 typedef HRESULT (*oper_t
)(exec_ctx_t
*,VARIANT
*,VARIANT
*,jsexcept_t
*,VARIANT
*);
1271 static HRESULT
binary_expr_eval(exec_ctx_t
*ctx
, binary_expression_t
*expr
, oper_t oper
, jsexcept_t
*ei
,
1274 VARIANT lval
, rval
, retv
;
1277 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1281 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1282 VariantClear(&lval
);
1283 VariantClear(&rval
);
1287 ret
->type
= EXPRVAL_VARIANT
;
1292 /* ECMA-262 3rd Edition 11.13.2 */
1293 static HRESULT
assign_oper_eval(exec_ctx_t
*ctx
, expression_t
*lexpr
, expression_t
*rexpr
, oper_t oper
,
1294 jsexcept_t
*ei
, exprval_t
*ret
)
1296 VARIANT retv
, lval
, rval
;
1297 exprval_t exprval
, exprvalr
;
1300 hres
= expr_eval(ctx
, lexpr
, EXPR_NEWREF
, ei
, &exprval
);
1304 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &lval
);
1305 if(SUCCEEDED(hres
)) {
1306 hres
= expr_eval(ctx
, rexpr
, 0, ei
, &exprvalr
);
1307 if(SUCCEEDED(hres
)) {
1308 hres
= exprval_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
1309 exprval_release(&exprvalr
);
1311 if(SUCCEEDED(hres
)) {
1312 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1313 VariantClear(&rval
);
1315 VariantClear(&lval
);
1318 if(SUCCEEDED(hres
)) {
1319 hres
= put_value(ctx
->parser
->script
, &exprval
, &retv
, ei
);
1321 VariantClear(&retv
);
1323 exprval_release(&exprval
);
1328 ret
->type
= EXPRVAL_VARIANT
;
1333 /* ECMA-262 3rd Edition 13 */
1334 HRESULT
function_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1336 function_expression_t
*expr
= (function_expression_t
*)_expr
;
1342 if(expr
->identifier
) {
1343 hres
= jsdisp_propget_name(ctx
->var_disp
, expr
->identifier
, &var
, ei
, NULL
/*FIXME*/);
1349 hres
= create_source_function(ctx
->parser
, expr
->parameter_list
, expr
->source_elements
, ctx
->scope_chain
,
1350 expr
->src_str
, expr
->src_len
, &dispex
);
1354 var_set_jsdisp(&var
, dispex
);
1357 ret
->type
= EXPRVAL_VARIANT
;
1362 /* ECMA-262 3rd Edition 11.12 */
1363 HRESULT
conditional_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1365 conditional_expression_t
*expr
= (conditional_expression_t
*)_expr
;
1372 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1376 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
1377 exprval_release(&exprval
);
1381 return expr_eval(ctx
, b
? expr
->true_expression
: expr
->false_expression
, flags
, ei
, ret
);
1384 /* ECMA-262 3rd Edition 11.2.1 */
1385 HRESULT
array_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1387 array_expression_t
*expr
= (array_expression_t
*)_expr
;
1389 VARIANT member
, val
;
1392 IDispatch
*obj
= NULL
;
1397 hres
= expr_eval(ctx
, expr
->member_expr
, 0, ei
, &exprval
);
1401 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1402 exprval_release(&exprval
);
1406 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
1407 if(SUCCEEDED(hres
)) {
1408 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1409 exprval_release(&exprval
);
1412 if(SUCCEEDED(hres
)) {
1413 hres
= to_object(ctx
->parser
->script
, &member
, &obj
);
1417 VariantClear(&member
);
1418 if(SUCCEEDED(hres
)) {
1419 hres
= to_string(ctx
->parser
->script
, &val
, ei
, &str
);
1421 if(SUCCEEDED(hres
)) {
1422 if(flags
& EXPR_STRREF
) {
1423 ret
->type
= EXPRVAL_NAMEREF
;
1424 ret
->u
.nameref
.disp
= obj
;
1425 ret
->u
.nameref
.name
= str
;
1429 hres
= disp_get_id(ctx
->parser
->script
, obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1433 if(SUCCEEDED(hres
)) {
1434 exprval_set_idref(ret
, obj
, id
);
1435 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1440 IDispatch_Release(obj
);
1446 /* ECMA-262 3rd Edition 11.2.1 */
1447 HRESULT
member_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1449 member_expression_t
*expr
= (member_expression_t
*)_expr
;
1450 IDispatch
*obj
= NULL
;
1459 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1463 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1464 exprval_release(&exprval
);
1468 hres
= to_object(ctx
->parser
->script
, &member
, &obj
);
1469 VariantClear(&member
);
1473 str
= SysAllocString(expr
->identifier
);
1474 if(flags
& EXPR_STRREF
) {
1475 ret
->type
= EXPRVAL_NAMEREF
;
1476 ret
->u
.nameref
.disp
= obj
;
1477 ret
->u
.nameref
.name
= str
;
1481 hres
= disp_get_id(ctx
->parser
->script
, obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1483 if(SUCCEEDED(hres
)) {
1484 exprval_set_idref(ret
, obj
, id
);
1485 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1490 IDispatch_Release(obj
);
1494 static void free_dp(DISPPARAMS
*dp
)
1498 for(i
=0; i
< dp
->cArgs
; i
++)
1499 VariantClear(dp
->rgvarg
+i
);
1500 heap_free(dp
->rgvarg
);
1503 static HRESULT
args_to_param(exec_ctx_t
*ctx
, argument_t
*args
, jsexcept_t
*ei
, DISPPARAMS
*dp
)
1509 HRESULT hres
= S_OK
;
1511 memset(dp
, 0, sizeof(*dp
));
1515 for(iter
= args
; iter
; iter
= iter
->next
)
1518 vargs
= heap_alloc_zero(cnt
* sizeof(*vargs
));
1520 return E_OUTOFMEMORY
;
1522 for(i
= cnt
, iter
= args
; iter
; iter
= iter
->next
) {
1523 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
1527 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, vargs
+ (--i
));
1528 exprval_release(&exprval
);
1543 /* ECMA-262 3rd Edition 11.2.2 */
1544 HRESULT
new_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1546 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1548 VARIANT constr
, var
;
1554 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1558 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1560 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &constr
);
1561 exprval_release(&exprval
);
1565 if(V_VT(&constr
) != VT_DISPATCH
) {
1566 FIXME("throw TypeError\n");
1567 VariantClear(&constr
);
1571 hres
= disp_call(ctx
->parser
->script
, V_DISPATCH(&constr
), DISPID_VALUE
,
1572 DISPATCH_CONSTRUCT
, &dp
, &var
, ei
, NULL
/*FIXME*/);
1573 IDispatch_Release(V_DISPATCH(&constr
));
1578 ret
->type
= EXPRVAL_VARIANT
;
1583 /* ECMA-262 3rd Edition 11.2.3 */
1584 HRESULT
call_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1586 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1594 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1598 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1599 if(SUCCEEDED(hres
)) {
1600 switch(exprval
.type
) {
1601 case EXPRVAL_VARIANT
:
1602 if(V_VT(&exprval
.u
.var
) == VT_DISPATCH
)
1603 hres
= disp_call(ctx
->parser
->script
, V_DISPATCH(&exprval
.u
.var
), DISPID_VALUE
,
1604 DISPATCH_METHOD
, &dp
, flags
& EXPR_NOVAL
? NULL
: &var
, ei
, NULL
/*FIXME*/);
1606 hres
= throw_type_error(ctx
->parser
->script
, ei
, IDS_NO_PROPERTY
, NULL
);
1609 hres
= disp_call(ctx
->parser
->script
, exprval
.u
.idref
.disp
, exprval
.u
.idref
.id
,
1610 DISPATCH_METHOD
, &dp
, flags
& EXPR_NOVAL
? NULL
: &var
, ei
, NULL
/*FIXME*/);
1612 case EXPRVAL_INVALID
:
1613 hres
= throw_type_error(ctx
->parser
->script
, ei
, IDS_OBJECT_EXPECTED
, NULL
);
1616 FIXME("unimplemented type %d\n", exprval
.type
);
1623 exprval_release(&exprval
);
1627 ret
->type
= EXPRVAL_VARIANT
;
1628 if(flags
& EXPR_NOVAL
) {
1629 V_VT(&ret
->u
.var
) = VT_EMPTY
;
1631 TRACE("= %s\n", debugstr_variant(&var
));
1637 /* ECMA-262 3rd Edition 11.1.1 */
1638 HRESULT
this_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1642 ret
->type
= EXPRVAL_VARIANT
;
1643 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1644 V_DISPATCH(&ret
->u
.var
) = ctx
->this_obj
;
1645 IDispatch_AddRef(ctx
->this_obj
);
1649 /* ECMA-262 3rd Edition 10.1.4 */
1650 HRESULT
identifier_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1652 identifier_expression_t
*expr
= (identifier_expression_t
*)_expr
;
1658 identifier
= SysAllocString(expr
->identifier
);
1660 return E_OUTOFMEMORY
;
1662 hres
= identifier_eval(ctx
, identifier
, flags
, ei
, ret
);
1664 SysFreeString(identifier
);
1668 /* ECMA-262 3rd Edition 7.8 */
1669 HRESULT
literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1671 literal_expression_t
*expr
= (literal_expression_t
*)_expr
;
1677 hres
= literal_to_var(ctx
->parser
->script
, expr
->literal
, &var
);
1681 ret
->type
= EXPRVAL_VARIANT
;
1686 /* ECMA-262 3rd Edition 11.1.4 */
1687 HRESULT
array_literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1689 array_literal_expression_t
*expr
= (array_literal_expression_t
*)_expr
;
1690 DWORD length
= 0, i
= 0;
1691 array_element_t
*elem
;
1699 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
)
1700 length
+= elem
->elision
+1;
1701 length
+= expr
->length
;
1703 hres
= create_array(ctx
->parser
->script
, length
, &array
);
1707 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
) {
1710 hres
= expr_eval(ctx
, elem
->expr
, 0, ei
, &exprval
);
1714 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1715 exprval_release(&exprval
);
1719 hres
= jsdisp_propput_idx(array
, i
, &val
, ei
, NULL
/*FIXME*/);
1728 jsdisp_release(array
);
1732 ret
->type
= EXPRVAL_VARIANT
;
1733 var_set_jsdisp(&ret
->u
.var
, array
);
1737 /* ECMA-262 3rd Edition 11.1.5 */
1738 HRESULT
property_value_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1740 property_value_expression_t
*expr
= (property_value_expression_t
*)_expr
;
1750 hres
= create_object(ctx
->parser
->script
, NULL
, &obj
);
1754 for(iter
= expr
->property_list
; iter
; iter
= iter
->next
) {
1755 hres
= literal_to_var(ctx
->parser
->script
, iter
->name
, &tmp
);
1759 hres
= to_string(ctx
->parser
->script
, &tmp
, ei
, &name
);
1764 hres
= expr_eval(ctx
, iter
->value
, 0, ei
, &exprval
);
1765 if(SUCCEEDED(hres
)) {
1766 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1767 exprval_release(&exprval
);
1768 if(SUCCEEDED(hres
)) {
1769 hres
= jsdisp_propput_name(obj
, name
, &val
, ei
, NULL
/*FIXME*/);
1774 SysFreeString(name
);
1780 jsdisp_release(obj
);
1784 ret
->type
= EXPRVAL_VARIANT
;
1785 var_set_jsdisp(&ret
->u
.var
, obj
);
1789 /* ECMA-262 3rd Edition 11.14 */
1790 HRESULT
comma_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1792 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1798 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1802 VariantClear(&lval
);
1804 ret
->type
= EXPRVAL_VARIANT
;
1809 /* ECMA-262 3rd Edition 11.11 */
1810 HRESULT
logical_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1812 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1820 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1824 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1825 exprval_release(&exprval
);
1829 hres
= to_boolean(&val
, &b
);
1830 if(SUCCEEDED(hres
) && b
) {
1831 ret
->type
= EXPRVAL_VARIANT
;
1840 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1844 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1845 exprval_release(&exprval
);
1849 ret
->type
= EXPRVAL_VARIANT
;
1854 /* ECMA-262 3rd Edition 11.11 */
1855 HRESULT
logical_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1857 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1865 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1869 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1870 exprval_release(&exprval
);
1874 hres
= to_boolean(&val
, &b
);
1875 if(SUCCEEDED(hres
) && !b
) {
1876 ret
->type
= EXPRVAL_VARIANT
;
1885 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1889 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1890 exprval_release(&exprval
);
1894 ret
->type
= EXPRVAL_VARIANT
;
1899 /* ECMA-262 3rd Edition 11.10 */
1900 static HRESULT
bitor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1905 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1909 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1918 /* ECMA-262 3rd Edition 11.10 */
1919 HRESULT
binary_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1921 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1925 return binary_expr_eval(ctx
, expr
, bitor_eval
, ei
, ret
);
1928 /* ECMA-262 3rd Edition 11.10 */
1929 static HRESULT
xor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1934 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1938 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1947 /* ECMA-262 3rd Edition 11.10 */
1948 HRESULT
binary_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1950 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1954 return binary_expr_eval(ctx
, expr
, xor_eval
, ei
, ret
);
1957 /* ECMA-262 3rd Edition 11.10 */
1958 static HRESULT
bitand_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1963 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1967 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1976 /* ECMA-262 3rd Edition 11.10 */
1977 HRESULT
binary_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1979 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1983 return binary_expr_eval(ctx
, expr
, bitand_eval
, ei
, ret
);
1986 /* ECMA-262 3rd Edition 11.8.6 */
1987 static HRESULT
instanceof_eval(exec_ctx_t
*ctx
, VARIANT
*inst
, VARIANT
*objv
, jsexcept_t
*ei
, VARIANT
*retv
)
1989 jsdisp_t
*obj
, *iter
, *tmp
= NULL
;
1990 VARIANT_BOOL ret
= VARIANT_FALSE
;
1995 static const WCHAR prototypeW
[] = {'p','r','o','t','o','t', 'y', 'p','e',0};
1997 if(V_VT(objv
) != VT_DISPATCH
|| !V_DISPATCH(objv
))
1998 return throw_type_error(ctx
->parser
->script
, ei
, IDS_NOT_FUNC
, NULL
);
2000 obj
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(objv
));
2002 FIXME("throw TypeError\n");
2006 if(is_class(obj
, JSCLASS_FUNCTION
)) {
2007 hres
= jsdisp_propget_name(obj
, prototypeW
, &var
, ei
, NULL
/*FIXME*/);
2009 FIXME("throw TypeError\n");
2012 jsdisp_release(obj
);
2016 if(V_VT(&var
) == VT_DISPATCH
) {
2017 if(V_VT(inst
) == VT_DISPATCH
)
2018 tmp
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(inst
));
2019 for(iter
= tmp
; iter
; iter
= iter
->prototype
) {
2020 hres
= disp_cmp(V_DISPATCH(&var
), to_disp(iter
), &b
);
2030 jsdisp_release(tmp
);
2032 FIXME("prototype is not an object\n");
2040 V_VT(retv
) = VT_BOOL
;
2045 /* ECMA-262 3rd Edition 11.8.6 */
2046 HRESULT
instanceof_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2048 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2052 return binary_expr_eval(ctx
, expr
, instanceof_eval
, ei
, ret
);
2055 /* ECMA-262 3rd Edition 11.8.7 */
2056 static HRESULT
in_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*obj
, jsexcept_t
*ei
, VARIANT
*retv
)
2063 if(V_VT(obj
) != VT_DISPATCH
|| !V_DISPATCH(obj
))
2064 return throw_type_error(ctx
->parser
->script
, ei
, IDS_OBJECT_EXPECTED
, NULL
);
2066 hres
= to_string(ctx
->parser
->script
, lval
, ei
, &str
);
2070 hres
= disp_get_id(ctx
->parser
->script
, V_DISPATCH(obj
), str
, 0, &id
);
2074 else if(hres
== DISP_E_UNKNOWNNAME
)
2075 ret
= VARIANT_FALSE
;
2079 V_VT(retv
) = VT_BOOL
;
2084 /* ECMA-262 3rd Edition 11.8.7 */
2085 HRESULT
in_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2087 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2091 return binary_expr_eval(ctx
, expr
, in_eval
, ei
, ret
);
2094 /* ECMA-262 3rd Edition 11.6.1 */
2095 static HRESULT
add_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2100 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
, NO_HINT
);
2104 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
, NO_HINT
);
2110 if(V_VT(&l
) == VT_BSTR
|| V_VT(&r
) == VT_BSTR
) {
2111 BSTR lstr
= NULL
, rstr
= NULL
;
2113 if(V_VT(&l
) == VT_BSTR
)
2116 hres
= to_string(ctx
->parser
->script
, &l
, ei
, &lstr
);
2118 if(SUCCEEDED(hres
)) {
2119 if(V_VT(&r
) == VT_BSTR
)
2122 hres
= to_string(ctx
->parser
->script
, &r
, ei
, &rstr
);
2125 if(SUCCEEDED(hres
)) {
2128 len1
= SysStringLen(lstr
);
2129 len2
= SysStringLen(rstr
);
2131 V_VT(retv
) = VT_BSTR
;
2132 V_BSTR(retv
) = SysAllocStringLen(NULL
, len1
+len2
);
2133 memcpy(V_BSTR(retv
), lstr
, len1
*sizeof(WCHAR
));
2134 memcpy(V_BSTR(retv
)+len1
, rstr
, (len2
+1)*sizeof(WCHAR
));
2137 if(V_VT(&l
) != VT_BSTR
)
2138 SysFreeString(lstr
);
2139 if(V_VT(&r
) != VT_BSTR
)
2140 SysFreeString(rstr
);
2144 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &nl
);
2145 if(SUCCEEDED(hres
)) {
2146 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &nr
);
2148 num_set_val(retv
, num_val(&nl
) + num_val(&nr
));
2157 /* ECMA-262 3rd Edition 11.6.1 */
2158 HRESULT
add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2160 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2164 return binary_expr_eval(ctx
, expr
, add_eval
, ei
, ret
);
2167 /* ECMA-262 3rd Edition 11.6.2 */
2168 static HRESULT
sub_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2173 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2177 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2181 num_set_val(retv
, num_val(&lnum
) - num_val(&rnum
));
2185 /* ECMA-262 3rd Edition 11.6.2 */
2186 HRESULT
sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2188 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2192 return binary_expr_eval(ctx
, expr
, sub_eval
, ei
, ret
);
2195 /* ECMA-262 3rd Edition 11.5.1 */
2196 static HRESULT
mul_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2201 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2205 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2209 num_set_val(retv
, num_val(&lnum
) * num_val(&rnum
));
2213 /* ECMA-262 3rd Edition 11.5.1 */
2214 HRESULT
mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2216 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2220 return binary_expr_eval(ctx
, expr
, mul_eval
, ei
, ret
);
2223 /* ECMA-262 3rd Edition 11.5.2 */
2224 static HRESULT
div_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2229 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2233 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2237 num_set_val(retv
, num_val(&lnum
) / num_val(&rnum
));
2241 /* ECMA-262 3rd Edition 11.5.2 */
2242 HRESULT
div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2244 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2248 return binary_expr_eval(ctx
, expr
, div_eval
, ei
, ret
);
2251 /* ECMA-262 3rd Edition 11.5.3 */
2252 static HRESULT
mod_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2257 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2261 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2265 num_set_val(retv
, fmod(num_val(&lnum
), num_val(&rnum
)));
2269 /* ECMA-262 3rd Edition 11.5.3 */
2270 HRESULT
mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2272 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2276 return binary_expr_eval(ctx
, expr
, mod_eval
, ei
, ret
);
2279 /* ECMA-262 3rd Edition 11.4.2 */
2280 HRESULT
delete_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2282 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2283 VARIANT_BOOL b
= VARIANT_FALSE
;
2289 hres
= expr_eval(ctx
, expr
->expression
, EXPR_STRREF
, ei
, &exprval
);
2293 switch(exprval
.type
) {
2294 case EXPRVAL_IDREF
: {
2295 IDispatchEx
*dispex
;
2297 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2298 if(SUCCEEDED(hres
)) {
2299 hres
= IDispatchEx_DeleteMemberByDispID(dispex
, exprval
.u
.idref
.id
);
2301 IDispatchEx_Release(dispex
);
2305 case EXPRVAL_NAMEREF
: {
2306 IDispatchEx
*dispex
;
2308 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2309 if(SUCCEEDED(hres
)) {
2310 hres
= IDispatchEx_DeleteMemberByName(dispex
, exprval
.u
.nameref
.name
,
2311 make_grfdex(ctx
->parser
->script
, fdexNameCaseSensitive
));
2313 IDispatchEx_Release(dispex
);
2318 FIXME("unsupported type %d\n", exprval
.type
);
2322 exprval_release(&exprval
);
2326 return return_bool(ret
, b
);
2329 /* ECMA-262 3rd Edition 11.4.2 */
2330 HRESULT
void_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2332 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2339 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2343 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &tmp
);
2344 exprval_release(&exprval
);
2350 ret
->type
= EXPRVAL_VARIANT
;
2351 V_VT(&ret
->u
.var
) = VT_EMPTY
;
2355 /* ECMA-262 3rd Edition 11.4.3 */
2356 static HRESULT
typeof_exprval(exec_ctx_t
*ctx
, exprval_t
*exprval
, jsexcept_t
*ei
, const WCHAR
**ret
)
2361 static const WCHAR booleanW
[] = {'b','o','o','l','e','a','n',0};
2362 static const WCHAR functionW
[] = {'f','u','n','c','t','i','o','n',0};
2363 static const WCHAR numberW
[] = {'n','u','m','b','e','r',0};
2364 static const WCHAR objectW
[] = {'o','b','j','e','c','t',0};
2365 static const WCHAR stringW
[] = {'s','t','r','i','n','g',0};
2366 static const WCHAR undefinedW
[] = {'u','n','d','e','f','i','n','e','d',0};
2368 if(exprval
->type
== EXPRVAL_INVALID
) {
2373 hres
= exprval_to_value(ctx
->parser
->script
, exprval
, ei
, &val
);
2377 switch(V_VT(&val
)) {
2397 if(V_DISPATCH(&val
) && (dispex
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(&val
)))) {
2398 *ret
= is_class(dispex
, JSCLASS_FUNCTION
) ? functionW
: objectW
;
2399 jsdisp_release(dispex
);
2406 FIXME("unhandled vt %d\n", V_VT(&val
));
2414 HRESULT
typeof_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2416 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2417 const WCHAR
*str
= NULL
;
2423 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2427 hres
= typeof_exprval(ctx
, &exprval
, ei
, &str
);
2428 exprval_release(&exprval
);
2432 ret
->type
= EXPRVAL_VARIANT
;
2433 V_VT(&ret
->u
.var
) = VT_BSTR
;
2434 V_BSTR(&ret
->u
.var
) = SysAllocString(str
);
2435 if(!V_BSTR(&ret
->u
.var
))
2436 return E_OUTOFMEMORY
;
2441 /* ECMA-262 3rd Edition 11.4.7 */
2442 HRESULT
minus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2444 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2451 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2455 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2456 exprval_release(&exprval
);
2460 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2465 ret
->type
= EXPRVAL_VARIANT
;
2466 num_set_val(&ret
->u
.var
, -num_val(&num
));
2470 /* ECMA-262 3rd Edition 11.4.6 */
2471 HRESULT
plus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2473 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2480 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2484 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2485 exprval_release(&exprval
);
2489 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2494 ret
->type
= EXPRVAL_VARIANT
;
2499 /* ECMA-262 3rd Edition 11.3.1 */
2500 HRESULT
post_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2502 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2509 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2513 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2514 if(SUCCEEDED(hres
)) {
2515 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2519 if(SUCCEEDED(hres
)) {
2521 num_set_val(&inc
, num_val(&num
)+1.0);
2522 hres
= put_value(ctx
->parser
->script
, &exprval
, &inc
, ei
);
2525 exprval_release(&exprval
);
2529 ret
->type
= EXPRVAL_VARIANT
;
2534 /* ECMA-262 3rd Edition 11.3.2 */
2535 HRESULT
post_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2537 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2544 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2548 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2549 if(SUCCEEDED(hres
)) {
2550 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2554 if(SUCCEEDED(hres
)) {
2556 num_set_val(&dec
, num_val(&num
)-1.0);
2557 hres
= put_value(ctx
->parser
->script
, &exprval
, &dec
, ei
);
2560 exprval_release(&exprval
);
2564 ret
->type
= EXPRVAL_VARIANT
;
2569 /* ECMA-262 3rd Edition 11.4.4 */
2570 HRESULT
pre_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2572 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2579 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2583 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2584 if(SUCCEEDED(hres
)) {
2585 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2589 if(SUCCEEDED(hres
)) {
2590 num_set_val(&val
, num_val(&num
)+1.0);
2591 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2594 exprval_release(&exprval
);
2598 ret
->type
= EXPRVAL_VARIANT
;
2603 /* ECMA-262 3rd Edition 11.4.5 */
2604 HRESULT
pre_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2606 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2613 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2617 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2618 if(SUCCEEDED(hres
)) {
2619 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2623 if(SUCCEEDED(hres
)) {
2624 num_set_val(&val
, num_val(&num
)-1.0);
2625 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2628 exprval_release(&exprval
);
2632 ret
->type
= EXPRVAL_VARIANT
;
2637 /* ECMA-262 3rd Edition 11.9.3 */
2638 static HRESULT
equal_values(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, BOOL
*ret
)
2640 if(V_VT(lval
) == V_VT(rval
) || (is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
))))
2641 return equal2_values(lval
, rval
, ret
);
2643 /* FIXME: NULL disps should be handled in more general way */
2644 if(V_VT(lval
) == VT_DISPATCH
&& !V_DISPATCH(lval
)) {
2647 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2650 if(V_VT(rval
) == VT_DISPATCH
&& !V_DISPATCH(rval
)) {
2653 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2656 if((V_VT(lval
) == VT_NULL
&& V_VT(rval
) == VT_EMPTY
) ||
2657 (V_VT(lval
) == VT_EMPTY
&& V_VT(rval
) == VT_NULL
)) {
2662 if(V_VT(lval
) == VT_BSTR
&& is_num_vt(V_VT(rval
))) {
2666 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &v
);
2670 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2673 if(V_VT(rval
) == VT_BSTR
&& is_num_vt(V_VT(lval
))) {
2677 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &v
);
2681 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2684 if(V_VT(rval
) == VT_BOOL
) {
2688 V_I4(&v
) = V_BOOL(rval
) ? 1 : 0;
2689 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2692 if(V_VT(lval
) == VT_BOOL
) {
2696 V_I4(&v
) = V_BOOL(lval
) ? 1 : 0;
2697 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2701 if(V_VT(rval
) == VT_DISPATCH
&& (V_VT(lval
) == VT_BSTR
|| is_num_vt(V_VT(lval
)))) {
2705 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &v
, NO_HINT
);
2709 hres
= equal_values(ctx
, lval
, &v
, ei
, ret
);
2716 if(V_VT(lval
) == VT_DISPATCH
&& (V_VT(rval
) == VT_BSTR
|| is_num_vt(V_VT(rval
)))) {
2720 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &v
, NO_HINT
);
2724 hres
= equal_values(ctx
, &v
, rval
, ei
, ret
);
2735 /* ECMA-262 3rd Edition 11.9.1 */
2736 HRESULT
equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2738 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2745 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2749 hres
= equal_values(ctx
, &rval
, &lval
, ei
, &b
);
2750 VariantClear(&lval
);
2751 VariantClear(&rval
);
2755 return return_bool(ret
, b
);
2758 /* ECMA-262 3rd Edition 11.9.4 */
2759 HRESULT
equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2761 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2768 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2772 hres
= equal2_values(&rval
, &lval
, &b
);
2773 VariantClear(&lval
);
2774 VariantClear(&rval
);
2778 return return_bool(ret
, b
);
2781 /* ECMA-262 3rd Edition 11.9.2 */
2782 HRESULT
not_equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2784 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2791 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2795 hres
= equal_values(ctx
, &lval
, &rval
, ei
, &b
);
2796 VariantClear(&lval
);
2797 VariantClear(&rval
);
2801 return return_bool(ret
, !b
);
2804 /* ECMA-262 3rd Edition 11.9.5 */
2805 HRESULT
not_equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2807 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2814 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2818 hres
= equal2_values(&lval
, &rval
, &b
);
2819 VariantClear(&lval
);
2820 VariantClear(&rval
);
2824 return return_bool(ret
, !b
);
2827 /* ECMA-262 3rd Edition 11.8.5 */
2828 static HRESULT
less_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, BOOL greater
, jsexcept_t
*ei
, BOOL
*ret
)
2830 VARIANT l
, r
, ln
, rn
;
2833 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
, NO_HINT
);
2837 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
, NO_HINT
);
2843 if(V_VT(&l
) == VT_BSTR
&& V_VT(&r
) == VT_BSTR
) {
2844 *ret
= (strcmpW(V_BSTR(&l
), V_BSTR(&r
)) < 0) ^ greater
;
2845 SysFreeString(V_BSTR(&l
));
2846 SysFreeString(V_BSTR(&r
));
2850 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &ln
);
2853 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &rn
);
2858 if(V_VT(&ln
) == VT_I4
&& V_VT(&rn
) == VT_I4
) {
2859 *ret
= (V_I4(&ln
) < V_I4(&rn
)) ^ greater
;
2861 DOUBLE ld
= num_val(&ln
);
2862 DOUBLE rd
= num_val(&rn
);
2864 *ret
= !isnan(ld
) && !isnan(rd
) && ((ld
< rd
) ^ greater
);
2870 /* ECMA-262 3rd Edition 11.8.1 */
2871 HRESULT
less_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2873 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2880 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2884 hres
= less_eval(ctx
, &lval
, &rval
, FALSE
, ei
, &b
);
2885 VariantClear(&lval
);
2886 VariantClear(&rval
);
2890 return return_bool(ret
, b
);
2893 /* ECMA-262 3rd Edition 11.8.3 */
2894 HRESULT
lesseq_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2896 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2903 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2907 hres
= less_eval(ctx
, &rval
, &lval
, TRUE
, ei
, &b
);
2908 VariantClear(&lval
);
2909 VariantClear(&rval
);
2913 return return_bool(ret
, b
);
2916 /* ECMA-262 3rd Edition 11.8.2 */
2917 HRESULT
greater_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2919 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2926 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2930 hres
= less_eval(ctx
, &rval
, &lval
, FALSE
, ei
, &b
);
2931 VariantClear(&lval
);
2932 VariantClear(&rval
);
2936 return return_bool(ret
, b
);
2939 /* ECMA-262 3rd Edition 11.8.4 */
2940 HRESULT
greatereq_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2942 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2949 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2953 hres
= less_eval(ctx
, &lval
, &rval
, TRUE
, ei
, &b
);
2954 VariantClear(&lval
);
2955 VariantClear(&rval
);
2959 return return_bool(ret
, b
);
2962 /* ECMA-262 3rd Edition 11.4.8 */
2963 HRESULT
binary_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2965 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2973 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2977 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2978 exprval_release(&exprval
);
2982 hres
= to_int32(ctx
->parser
->script
, &val
, ei
, &i
);
2986 ret
->type
= EXPRVAL_VARIANT
;
2987 V_VT(&ret
->u
.var
) = VT_I4
;
2988 V_I4(&ret
->u
.var
) = ~i
;
2992 /* ECMA-262 3rd Edition 11.4.9 */
2993 HRESULT
logical_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2995 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
3002 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
3006 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
3007 exprval_release(&exprval
);
3011 return return_bool(ret
, !b
);
3014 /* ECMA-262 3rd Edition 11.7.1 */
3015 static HRESULT
lshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
3021 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
3025 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
3030 V_I4(retv
) = li
<< (ri
&0x1f);
3034 /* ECMA-262 3rd Edition 11.7.1 */
3035 HRESULT
left_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3037 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3041 return binary_expr_eval(ctx
, expr
, lshift_eval
, ei
, ret
);
3044 /* ECMA-262 3rd Edition 11.7.2 */
3045 static HRESULT
rshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
3051 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
3055 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
3060 V_I4(retv
) = li
>> (ri
&0x1f);
3064 /* ECMA-262 3rd Edition 11.7.2 */
3065 HRESULT
right_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3067 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3071 return binary_expr_eval(ctx
, expr
, rshift_eval
, ei
, ret
);
3074 /* ECMA-262 3rd Edition 11.7.3 */
3075 static HRESULT
rshift2_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
3080 hres
= to_uint32(ctx
->parser
->script
, lval
, ei
, &li
);
3084 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
3089 V_I4(retv
) = li
>> (ri
&0x1f);
3093 /* ECMA-262 3rd Edition 11.7.3 */
3094 HRESULT
right2_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3096 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3100 return binary_expr_eval(ctx
, expr
, rshift2_eval
, ei
, ret
);
3103 /* ECMA-262 3rd Edition 11.13.1 */
3104 HRESULT
assign_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3106 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3107 exprval_t exprval
, exprvalr
;
3113 hres
= expr_eval(ctx
, expr
->expression1
, EXPR_NEWREF
, ei
, &exprval
);
3117 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprvalr
);
3118 if(SUCCEEDED(hres
)) {
3119 hres
= exprval_to_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
3120 exprval_release(&exprvalr
);
3123 if(SUCCEEDED(hres
)) {
3124 hres
= put_value(ctx
->parser
->script
, &exprval
, &rval
, ei
);
3126 VariantClear(&rval
);
3129 exprval_release(&exprval
);
3133 ret
->type
= EXPRVAL_VARIANT
;
3138 /* ECMA-262 3rd Edition 11.13.2 */
3139 HRESULT
assign_lshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3141 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3145 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, lshift_eval
, ei
, ret
);
3148 /* ECMA-262 3rd Edition 11.13.2 */
3149 HRESULT
assign_rshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3151 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3155 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift_eval
, ei
, ret
);
3158 /* ECMA-262 3rd Edition 11.13.2 */
3159 HRESULT
assign_rrshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3161 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3165 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift2_eval
, ei
, ret
);
3168 /* ECMA-262 3rd Edition 11.13.2 */
3169 HRESULT
assign_add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3171 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3175 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, add_eval
, ei
, ret
);
3178 /* ECMA-262 3rd Edition 11.13.2 */
3179 HRESULT
assign_sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3181 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3185 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, sub_eval
, ei
, ret
);
3188 /* ECMA-262 3rd Edition 11.13.2 */
3189 HRESULT
assign_mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3191 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3195 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mul_eval
, ei
, ret
);
3198 /* ECMA-262 3rd Edition 11.13.2 */
3199 HRESULT
assign_div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3201 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3205 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, div_eval
, ei
, ret
);
3208 /* ECMA-262 3rd Edition 11.13.2 */
3209 HRESULT
assign_mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3211 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3215 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mod_eval
, ei
, ret
);
3218 /* ECMA-262 3rd Edition 11.13.2 */
3219 HRESULT
assign_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3221 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3225 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitand_eval
, ei
, ret
);
3228 /* ECMA-262 3rd Edition 11.13.2 */
3229 HRESULT
assign_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3231 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3235 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitor_eval
, ei
, ret
);
3238 /* ECMA-262 3rd Edition 11.13.2 */
3239 HRESULT
assign_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3241 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3245 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, xor_eval
, ei
, ret
);