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
);
63 /* ECMA-262 3rd Edition 8.7.1 */
64 static HRESULT
exprval_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
70 return VariantCopy(ret
, &val
->u
.var
);
72 if(!val
->u
.idref
.disp
) {
73 FIXME("throw ReferenceError\n");
77 return disp_propget(val
->u
.idref
.disp
, val
->u
.idref
.id
, ctx
->lcid
, ret
, ei
, NULL
/*FIXME*/);
79 ERR("type %d\n", val
->type
);
84 static HRESULT
exprval_to_value(script_ctx_t
*ctx
, exprval_t
*val
, jsexcept_t
*ei
, VARIANT
*ret
)
86 if(val
->type
== EXPRVAL_VARIANT
) {
88 V_VT(&val
->u
.var
) = VT_EMPTY
;
92 return exprval_value(ctx
, val
, ei
, ret
);
95 static HRESULT
exprval_to_boolean(script_ctx_t
*ctx
, exprval_t
*exprval
, jsexcept_t
*ei
, VARIANT_BOOL
*b
)
97 if(exprval
->type
!= EXPRVAL_VARIANT
) {
101 hres
= exprval_to_value(ctx
, exprval
, ei
, &val
);
105 hres
= to_boolean(&val
, b
);
110 return to_boolean(&exprval
->u
.var
, b
);
113 static void exprval_init(exprval_t
*val
)
115 val
->type
= EXPRVAL_VARIANT
;
116 V_VT(&val
->u
.var
) = VT_EMPTY
;
119 static void exprval_set_idref(exprval_t
*val
, IDispatch
*disp
, DISPID id
)
121 val
->type
= EXPRVAL_IDREF
;
122 val
->u
.idref
.disp
= disp
;
123 val
->u
.idref
.id
= id
;
126 IDispatch_AddRef(disp
);
129 HRESULT
scope_push(scope_chain_t
*scope
, DispatchEx
*obj
, scope_chain_t
**ret
)
131 scope_chain_t
*new_scope
;
133 new_scope
= heap_alloc(sizeof(scope_chain_t
));
135 return E_OUTOFMEMORY
;
139 IDispatchEx_AddRef(_IDispatchEx_(obj
));
140 new_scope
->obj
= obj
;
144 new_scope
->next
= scope
;
146 new_scope
->next
= NULL
;
153 static void scope_pop(scope_chain_t
**scope
)
162 void scope_release(scope_chain_t
*scope
)
168 scope_release(scope
->next
);
170 IDispatchEx_Release(_IDispatchEx_(scope
->obj
));
174 HRESULT
create_exec_ctx(IDispatch
*this_obj
, DispatchEx
*var_disp
, scope_chain_t
*scope
, exec_ctx_t
**ret
)
178 ctx
= heap_alloc_zero(sizeof(exec_ctx_t
));
180 return E_OUTOFMEMORY
;
182 IDispatch_AddRef(this_obj
);
183 ctx
->this_obj
= this_obj
;
185 IDispatchEx_AddRef(_IDispatchEx_(var_disp
));
186 ctx
->var_disp
= var_disp
;
190 ctx
->scope_chain
= scope
;
197 void exec_release(exec_ctx_t
*ctx
)
203 scope_release(ctx
->scope_chain
);
205 IDispatchEx_Release(_IDispatchEx_(ctx
->var_disp
));
207 IDispatch_Release(ctx
->this_obj
);
211 static HRESULT
disp_get_id(IDispatch
*disp
, BSTR name
, DWORD flags
, DISPID
*id
)
216 hres
= IDispatch_QueryInterface(disp
, &IID_IDispatchEx
, (void**)&dispex
);
218 TRACE("unsing IDispatch\n");
221 return IDispatch_GetIDsOfNames(disp
, &IID_NULL
, &name
, 1, 0, id
);
225 hres
= IDispatchEx_GetDispID(dispex
, name
, flags
|fdexNameCaseSensitive
, id
);
226 IDispatchEx_Release(dispex
);
230 /* ECMA-262 3rd Edition 8.7.2 */
231 static HRESULT
put_value(script_ctx_t
*ctx
, exprval_t
*ref
, VARIANT
*v
, jsexcept_t
*ei
)
233 if(ref
->type
!= EXPRVAL_IDREF
) {
234 FIXME("throw ReferemceError\n");
238 return disp_propput(ref
->u
.idref
.disp
, ref
->u
.idref
.id
, ctx
->lcid
, v
, ei
, NULL
/*FIXME*/);
241 static HRESULT
disp_cmp(IDispatch
*disp1
, IDispatch
*disp2
, BOOL
*ret
)
243 IObjectIdentity
*identity
;
244 IUnknown
*unk1
, *unk2
;
252 hres
= IDispatch_QueryInterface(disp1
, &IID_IUnknown
, (void**)&unk1
);
256 hres
= IDispatch_QueryInterface(disp2
, &IID_IUnknown
, (void**)&unk2
);
258 IUnknown_Release(unk1
);
265 hres
= IUnknown_QueryInterface(unk1
, &IID_IObjectIdentity
, (void**)&identity
);
266 if(SUCCEEDED(hres
)) {
267 hres
= IObjectIdentity_IsEqualObject(identity
, unk2
);
268 IObjectIdentity_Release(identity
);
275 IUnknown_Release(unk1
);
276 IUnknown_Release(unk2
);
280 /* ECMA-262 3rd Edition 11.9.6 */
281 HRESULT
equal2_values(VARIANT
*lval
, VARIANT
*rval
, BOOL
*ret
)
285 if(V_VT(lval
) != V_VT(rval
)) {
286 if(is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
))) {
287 *ret
= num_val(lval
) == num_val(rval
);
301 *ret
= V_I4(lval
) == V_I4(rval
);
304 *ret
= V_R8(lval
) == V_R8(rval
);
307 *ret
= !strcmpW(V_BSTR(lval
), V_BSTR(rval
));
310 return disp_cmp(V_DISPATCH(lval
), V_DISPATCH(rval
), ret
);
312 *ret
= !V_BOOL(lval
) == !V_BOOL(rval
);
315 FIXME("unimplemented vt %d\n", V_VT(lval
));
322 static HRESULT
literal_to_var(literal_t
*literal
, VARIANT
*v
)
324 V_VT(v
) = literal
->vt
;
331 V_I4(v
) = literal
->u
.lval
;
334 V_R8(v
) = literal
->u
.dval
;
337 V_BSTR(v
) = SysAllocString(literal
->u
.wstr
);
340 V_BOOL(v
) = literal
->u
.bval
;
343 IDispatch_AddRef(literal
->u
.disp
);
344 V_DISPATCH(v
) = literal
->u
.disp
;
347 ERR("wrong type %d\n", V_VT(v
));
354 HRESULT
exec_source(exec_ctx_t
*ctx
, parser_ctx_t
*parser
, source_elements_t
*source
, jsexcept_t
*ei
, VARIANT
*retv
)
356 script_ctx_t
*script
= parser
->script
;
357 function_declaration_t
*func
;
358 parser_ctx_t
*prev_parser
;
362 exec_ctx_t
*prev_ctx
;
366 for(func
= source
->functions
; func
; func
= func
->next
) {
367 DispatchEx
*func_obj
;
370 hres
= create_source_function(parser
, func
->expr
->parameter_list
, func
->expr
->source_elements
,
371 ctx
->scope_chain
, func
->expr
->src_str
, func
->expr
->src_len
, &func_obj
);
375 V_VT(&var
) = VT_DISPATCH
;
376 V_DISPATCH(&var
) = (IDispatch
*)_IDispatchEx_(func_obj
);
377 hres
= jsdisp_propput_name(ctx
->var_disp
, func
->expr
->identifier
, script
->lcid
, &var
, ei
, NULL
);
378 jsdisp_release(func_obj
);
383 for(var
= source
->variables
; var
; var
= var
->next
) {
386 hres
= jsdisp_get_id(ctx
->var_disp
, var
->identifier
, fdexNameEnsure
, &id
);
391 prev_ctx
= script
->exec_ctx
;
392 script
->exec_ctx
= ctx
;
394 prev_parser
= ctx
->parser
;
395 ctx
->parser
= parser
;
397 V_VT(&val
) = VT_EMPTY
;
398 memset(&rt
, 0, sizeof(rt
));
401 for(stat
= source
->statement
; stat
; stat
= stat
->next
) {
402 hres
= stat_eval(ctx
, stat
, &rt
, &tmp
);
408 if(rt
.type
!= RT_NORMAL
)
412 script
->exec_ctx
= prev_ctx
;
413 ctx
->parser
= prev_parser
;
415 if(rt
.type
!= RT_NORMAL
&& rt
.type
!= RT_RETURN
) {
416 FIXME("wrong rt %d\n", rt
.type
);
433 /* ECMA-262 3rd Edition 10.1.4 */
434 static HRESULT
identifier_eval(exec_ctx_t
*ctx
, BSTR identifier
, DWORD flags
, exprval_t
*ret
)
436 scope_chain_t
*scope
;
441 TRACE("%s\n", debugstr_w(identifier
));
443 for(scope
= ctx
->scope_chain
; scope
; scope
= scope
->next
) {
444 hres
= jsdisp_get_id(scope
->obj
, identifier
, 0, &id
);
450 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(scope
->obj
), id
);
454 hres
= jsdisp_get_id(ctx
->parser
->script
->global
, identifier
, 0, &id
);
455 if(SUCCEEDED(hres
)) {
456 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->parser
->script
->global
), id
);
460 for(item
= ctx
->parser
->script
->named_items
; item
; item
= item
->next
) {
461 if((item
->flags
& SCRIPTITEM_ISVISIBLE
) && !strcmpW(item
->name
, identifier
)) {
462 ret
->type
= EXPRVAL_VARIANT
;
463 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
464 V_DISPATCH(&ret
->u
.var
) = item
->disp
;
465 IDispatch_AddRef(item
->disp
);
470 for(item
= ctx
->parser
->script
->named_items
; item
; item
= item
->next
) {
471 hres
= disp_get_id(item
->disp
, identifier
, 0, &id
);
477 exprval_set_idref(ret
, (IDispatch
*)item
->disp
, id
);
481 hres
= jsdisp_get_id(ctx
->parser
->script
->script_disp
, identifier
, 0, &id
);
482 if(SUCCEEDED(hres
)) {
483 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->parser
->script
->script_disp
), id
);
487 if(flags
& EXPR_NEWREF
) {
488 hres
= jsdisp_get_id(ctx
->var_disp
, identifier
, fdexNameEnsure
, &id
);
492 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->var_disp
), id
);
496 WARN("Could not find identifier %s\n", debugstr_w(identifier
));
500 /* ECMA-262 3rd Edition 12.1 */
501 HRESULT
block_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
503 block_statement_t
*stat
= (block_statement_t
*)_stat
;
510 V_VT(&val
) = VT_EMPTY
;
511 for(iter
= stat
->stat_list
; iter
; iter
= iter
->next
) {
512 hres
= stat_eval(ctx
, iter
, rt
, &tmp
);
518 if(rt
->type
!= RT_NORMAL
)
531 /* ECMA-262 3rd Edition 12.2 */
532 static HRESULT
variable_list_eval(exec_ctx_t
*ctx
, variable_declaration_t
*var_list
, jsexcept_t
*ei
)
534 variable_declaration_t
*iter
;
537 for(iter
= var_list
; iter
; iter
= iter
->next
) {
544 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
548 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
549 exprval_release(&exprval
);
553 hres
= jsdisp_propput_name(ctx
->var_disp
, iter
->identifier
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
562 /* ECMA-262 3rd Edition 12.2 */
563 HRESULT
var_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
565 var_statement_t
*stat
= (var_statement_t
*)_stat
;
570 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
574 V_VT(ret
) = VT_EMPTY
;
578 /* ECMA-262 3rd Edition 12.3 */
579 HRESULT
empty_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
583 V_VT(ret
) = VT_EMPTY
;
587 /* ECMA-262 3rd Edition 12.4 */
588 HRESULT
expression_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
590 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
597 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NOVAL
, &rt
->ei
, &exprval
);
601 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
602 exprval_release(&exprval
);
607 TRACE("= %s\n", debugstr_variant(ret
));
611 /* ECMA-262 3rd Edition 12.5 */
612 HRESULT
if_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
614 if_statement_t
*stat
= (if_statement_t
*)_stat
;
621 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
625 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
626 exprval_release(&exprval
);
631 hres
= stat_eval(ctx
, stat
->if_stat
, rt
, ret
);
632 else if(stat
->else_stat
)
633 hres
= stat_eval(ctx
, stat
->else_stat
, rt
, ret
);
635 V_VT(ret
) = VT_EMPTY
;
640 /* ECMA-262 3rd Edition 12.6.2 */
641 HRESULT
while_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
643 while_statement_t
*stat
= (while_statement_t
*)_stat
;
652 V_VT(&val
) = VT_EMPTY
;
653 test_expr
= !stat
->do_while
;
657 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
661 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
662 exprval_release(&exprval
);
663 if(FAILED(hres
) || !b
)
669 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
676 if(rt
->type
== RT_CONTINUE
)
677 rt
->type
= RT_NORMAL
;
678 if(rt
->type
!= RT_NORMAL
)
687 if(rt
->type
== RT_BREAK
)
688 rt
->type
= RT_NORMAL
;
694 /* ECMA-262 3rd Edition 12.6.3 */
695 HRESULT
for_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
697 for_statement_t
*stat
= (for_statement_t
*)_stat
;
698 VARIANT val
, tmp
, retv
;
705 if(stat
->variable_list
) {
706 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
709 }else if(stat
->begin_expr
) {
710 hres
= expr_eval(ctx
, stat
->begin_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
714 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
715 exprval_release(&exprval
);
722 V_VT(&retv
) = VT_EMPTY
;
726 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
730 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
731 exprval_release(&exprval
);
732 if(FAILED(hres
) || !b
)
736 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
743 if(rt
->type
== RT_CONTINUE
)
744 rt
->type
= RT_NORMAL
;
745 else if(rt
->type
!= RT_NORMAL
)
749 hres
= expr_eval(ctx
, stat
->end_expr
, 0, &rt
->ei
, &exprval
);
753 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
754 exprval_release(&exprval
);
767 if(rt
->type
== RT_BREAK
)
768 rt
->type
= RT_NORMAL
;
774 /* ECMA-262 3rd Edition 12.6.4 */
775 HRESULT
forin_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
777 forin_statement_t
*stat
= (forin_statement_t
*)_stat
;
778 VARIANT val
, name
, retv
, tmp
;
779 DISPID id
= DISPID_STARTENUM
;
780 BSTR str
, identifier
= NULL
;
788 hres
= variable_list_eval(ctx
, stat
->variable
, &rt
->ei
);
793 hres
= expr_eval(ctx
, stat
->in_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
797 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
798 exprval_release(&exprval
);
802 if(V_VT(&val
) != VT_DISPATCH
) {
803 TRACE("in vt %d\n", V_VT(&val
));
805 V_VT(ret
) = VT_EMPTY
;
809 hres
= IDispatch_QueryInterface(V_DISPATCH(&val
), &IID_IDispatchEx
, (void**)&in_obj
);
810 IDispatch_Release(V_DISPATCH(&val
));
812 FIXME("Object doesn't support IDispatchEx\n");
816 V_VT(&retv
) = VT_EMPTY
;
819 identifier
= SysAllocString(stat
->variable
->identifier
);
822 hres
= IDispatchEx_GetNextDispID(in_obj
, fdexEnumDefault
, id
, &id
);
823 if(FAILED(hres
) || hres
== S_FALSE
)
826 hres
= IDispatchEx_GetMemberName(in_obj
, id
, &str
);
830 TRACE("iter %s\n", debugstr_w(str
));
833 hres
= identifier_eval(ctx
, identifier
, 0, &exprval
);
835 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
836 if(SUCCEEDED(hres
)) {
837 V_VT(&name
) = VT_BSTR
;
839 hres
= put_value(ctx
->parser
->script
, &exprval
, &name
, &rt
->ei
);
840 exprval_release(&exprval
);
846 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
853 if(rt
->type
== RT_CONTINUE
)
854 rt
->type
= RT_NORMAL
;
855 else if(rt
->type
!= RT_NORMAL
)
859 SysFreeString(identifier
);
860 IDispatchEx_Release(in_obj
);
866 if(rt
->type
== RT_BREAK
)
867 rt
->type
= RT_NORMAL
;
873 /* ECMA-262 3rd Edition 12.7 */
874 HRESULT
continue_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
876 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
880 if(stat
->identifier
) {
881 FIXME("indentifier not implemented\n");
885 rt
->type
= RT_CONTINUE
;
886 V_VT(ret
) = VT_EMPTY
;
890 /* ECMA-262 3rd Edition 12.8 */
891 HRESULT
break_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
893 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
897 if(stat
->identifier
) {
898 FIXME("indentifier not implemented\n");
903 V_VT(ret
) = VT_EMPTY
;
907 /* ECMA-262 3rd Edition 12.9 */
908 HRESULT
return_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
910 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
918 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
922 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, ret
);
923 exprval_release(&exprval
);
927 V_VT(ret
) = VT_EMPTY
;
930 TRACE("= %s\n", debugstr_variant(ret
));
931 rt
->type
= RT_RETURN
;
935 /* ECMA-262 3rd Edition 12.10 */
936 HRESULT
with_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
938 with_statement_t
*stat
= (with_statement_t
*)_stat
;
947 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
951 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
952 exprval_release(&exprval
);
956 hres
= to_object(ctx
, &val
, &disp
);
961 obj
= iface_to_jsdisp((IUnknown
*)disp
);
962 IDispatch_Release(disp
);
964 FIXME("disp id not jsdisp\n");
968 hres
= scope_push(ctx
->scope_chain
, obj
, &ctx
->scope_chain
);
973 hres
= stat_eval(ctx
, stat
->statement
, rt
, ret
);
975 scope_pop(&ctx
->scope_chain
);
979 /* ECMA-262 3rd Edition 12.12 */
980 HRESULT
labelled_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
986 /* ECMA-262 3rd Edition 12.13 */
987 HRESULT
switch_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
989 switch_statement_t
*stat
= (switch_statement_t
*)_stat
;
990 case_clausule_t
*iter
, *default_clausule
= NULL
;
991 statement_t
*stat_iter
;
999 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1003 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1004 exprval_release(&exprval
);
1008 for(iter
= stat
->case_list
; iter
; iter
= iter
->next
) {
1010 default_clausule
= iter
;
1014 hres
= expr_eval(ctx
, iter
->expr
, 0, &rt
->ei
, &exprval
);
1018 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &cval
);
1019 exprval_release(&exprval
);
1023 hres
= equal2_values(&val
, &cval
, &b
);
1024 VariantClear(&cval
);
1025 if(FAILED(hres
) || b
)
1034 iter
= default_clausule
;
1036 V_VT(&val
) = VT_EMPTY
;
1040 for(stat_iter
= iter
->stat
; stat_iter
; stat_iter
= stat_iter
->next
) {
1041 hres
= stat_eval(ctx
, stat_iter
, rt
, &tmp
);
1048 if(rt
->type
!= RT_NORMAL
)
1058 if(rt
->type
== RT_BREAK
)
1059 rt
->type
= RT_NORMAL
;
1065 /* ECMA-262 3rd Edition 12.13 */
1066 HRESULT
throw_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1068 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
1075 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1079 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1080 exprval_release(&exprval
);
1085 return DISP_E_EXCEPTION
;
1088 /* ECMA-262 3rd Edition 12.14 */
1089 static HRESULT
catch_eval(exec_ctx_t
*ctx
, catch_block_t
*block
, return_type_t
*rt
, VARIANT
*ret
)
1091 DispatchEx
*var_disp
;
1096 memset(&rt
->ei
, 0, sizeof(jsexcept_t
));
1098 hres
= create_dispex(ctx
->parser
->script
, NULL
, NULL
, &var_disp
);
1099 if(SUCCEEDED(hres
)) {
1100 hres
= jsdisp_propput_name(var_disp
, block
->identifier
, ctx
->parser
->script
->lcid
,
1101 &ex
, &rt
->ei
, NULL
/*FIXME*/);
1102 if(SUCCEEDED(hres
)) {
1103 hres
= scope_push(ctx
->scope_chain
, var_disp
, &ctx
->scope_chain
);
1104 if(SUCCEEDED(hres
)) {
1105 hres
= stat_eval(ctx
, block
->statement
, rt
, &val
);
1106 scope_pop(&ctx
->scope_chain
);
1110 jsdisp_release(var_disp
);
1121 /* ECMA-262 3rd Edition 12.14 */
1122 HRESULT
try_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1124 try_statement_t
*stat
= (try_statement_t
*)_stat
;
1130 hres
= stat_eval(ctx
, stat
->try_statement
, rt
, &val
);
1132 TRACE("EXCEPTION\n");
1133 if(!stat
->catch_block
)
1136 hres
= catch_eval(ctx
, stat
->catch_block
, rt
, &val
);
1141 if(stat
->finally_statement
) {
1143 hres
= stat_eval(ctx
, stat
->finally_statement
, rt
, &val
);
1152 static HRESULT
return_bool(exprval_t
*ret
, DWORD b
)
1154 ret
->type
= EXPRVAL_VARIANT
;
1155 V_VT(&ret
->u
.var
) = VT_BOOL
;
1156 V_BOOL(&ret
->u
.var
) = b
? VARIANT_TRUE
: VARIANT_FALSE
;
1161 static HRESULT
get_binary_expr_values(exec_ctx_t
*ctx
, binary_expression_t
*expr
, jsexcept_t
*ei
, VARIANT
*lval
, VARIANT
*rval
)
1166 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1170 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, lval
);
1171 exprval_release(&exprval
);
1175 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1176 if(SUCCEEDED(hres
)) {
1177 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, rval
);
1178 exprval_release(&exprval
);
1189 typedef HRESULT (*oper_t
)(exec_ctx_t
*,VARIANT
*,VARIANT
*,jsexcept_t
*,VARIANT
*);
1191 static HRESULT
binary_expr_eval(exec_ctx_t
*ctx
, binary_expression_t
*expr
, oper_t oper
, jsexcept_t
*ei
,
1194 VARIANT lval
, rval
, retv
;
1197 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1201 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1202 VariantClear(&lval
);
1203 VariantClear(&rval
);
1207 ret
->type
= EXPRVAL_VARIANT
;
1212 /* ECMA-262 3rd Edition 11.13.2 */
1213 static HRESULT
assign_oper_eval(exec_ctx_t
*ctx
, expression_t
*lexpr
, expression_t
*rexpr
, oper_t oper
,
1214 jsexcept_t
*ei
, exprval_t
*ret
)
1216 VARIANT retv
, lval
, rval
;
1217 exprval_t exprval
, exprvalr
;
1220 hres
= expr_eval(ctx
, lexpr
, EXPR_NEWREF
, ei
, &exprval
);
1224 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &lval
);
1225 if(SUCCEEDED(hres
)) {
1226 hres
= expr_eval(ctx
, rexpr
, 0, ei
, &exprvalr
);
1227 if(SUCCEEDED(hres
)) {
1228 hres
= exprval_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
1229 exprval_release(&exprvalr
);
1231 if(SUCCEEDED(hres
)) {
1232 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1233 VariantClear(&rval
);
1235 VariantClear(&lval
);
1238 if(SUCCEEDED(hres
)) {
1239 hres
= put_value(ctx
->parser
->script
, &exprval
, &retv
, ei
);
1241 VariantClear(&retv
);
1243 exprval_release(&exprval
);
1248 ret
->type
= EXPRVAL_VARIANT
;
1253 /* ECMA-262 3rd Edition 13 */
1254 HRESULT
function_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1256 function_expression_t
*expr
= (function_expression_t
*)_expr
;
1262 if(expr
->identifier
) {
1263 hres
= jsdisp_propget_name(ctx
->var_disp
, expr
->identifier
, ctx
->parser
->script
->lcid
, &var
, ei
, NULL
/*FIXME*/);
1269 hres
= create_source_function(ctx
->parser
, expr
->parameter_list
, expr
->source_elements
, ctx
->scope_chain
,
1270 expr
->src_str
, expr
->src_len
, &dispex
);
1274 V_VT(&var
) = VT_DISPATCH
;
1275 V_DISPATCH(&var
) = (IDispatch
*)_IDispatchEx_(dispex
);
1278 ret
->type
= EXPRVAL_VARIANT
;
1283 /* ECMA-262 3rd Edition 11.12 */
1284 HRESULT
conditional_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1286 conditional_expression_t
*expr
= (conditional_expression_t
*)_expr
;
1293 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1297 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
1298 exprval_release(&exprval
);
1302 return expr_eval(ctx
, b
? expr
->true_expression
: expr
->false_expression
, flags
, ei
, ret
);
1305 /* ECMA-262 3rd Edition 11.2.1 */
1306 HRESULT
array_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1308 array_expression_t
*expr
= (array_expression_t
*)_expr
;
1310 VARIANT member
, val
;
1313 IDispatch
*obj
= NULL
;
1318 hres
= expr_eval(ctx
, expr
->member_expr
, EXPR_NEWREF
, ei
, &exprval
);
1322 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1323 exprval_release(&exprval
);
1327 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
1328 if(SUCCEEDED(hres
)) {
1329 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1330 exprval_release(&exprval
);
1334 hres
= to_object(ctx
, &member
, &obj
);
1335 VariantClear(&member
);
1336 if(SUCCEEDED(hres
)) {
1337 hres
= to_string(ctx
->parser
->script
, &val
, ei
, &str
);
1338 if(SUCCEEDED(hres
)) {
1339 if(flags
& EXPR_STRREF
) {
1340 ret
->type
= EXPRVAL_NAMEREF
;
1341 ret
->u
.nameref
.disp
= obj
;
1342 ret
->u
.nameref
.name
= str
;
1346 hres
= disp_get_id(obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1349 if(SUCCEEDED(hres
)) {
1350 exprval_set_idref(ret
, obj
, id
);
1351 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1356 IDispatch_Release(obj
);
1362 /* ECMA-262 3rd Edition 11.2.1 */
1363 HRESULT
member_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1365 member_expression_t
*expr
= (member_expression_t
*)_expr
;
1366 IDispatch
*obj
= NULL
;
1375 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1379 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1380 exprval_release(&exprval
);
1384 hres
= to_object(ctx
, &member
, &obj
);
1385 VariantClear(&member
);
1389 str
= SysAllocString(expr
->identifier
);
1390 if(flags
& EXPR_STRREF
) {
1391 ret
->type
= EXPRVAL_NAMEREF
;
1392 ret
->u
.nameref
.disp
= obj
;
1393 ret
->u
.nameref
.name
= str
;
1397 hres
= disp_get_id(obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1399 if(SUCCEEDED(hres
)) {
1400 exprval_set_idref(ret
, obj
, id
);
1401 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1406 IDispatch_Release(obj
);
1410 static void free_dp(DISPPARAMS
*dp
)
1414 for(i
=0; i
< dp
->cArgs
; i
++)
1415 VariantClear(dp
->rgvarg
+i
);
1416 heap_free(dp
->rgvarg
);
1419 static HRESULT
args_to_param(exec_ctx_t
*ctx
, argument_t
*args
, jsexcept_t
*ei
, DISPPARAMS
*dp
)
1425 HRESULT hres
= S_OK
;
1427 memset(dp
, 0, sizeof(*dp
));
1431 for(iter
= args
; iter
; iter
= iter
->next
)
1434 vargs
= heap_alloc_zero(cnt
* sizeof(*vargs
));
1436 return E_OUTOFMEMORY
;
1438 for(i
= cnt
, iter
= args
; iter
; iter
= iter
->next
) {
1439 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
1443 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, vargs
+ (--i
));
1444 exprval_release(&exprval
);
1459 /* ECMA-262 3rd Edition 11.2.2 */
1460 HRESULT
new_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1462 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1464 VARIANT constr
, var
;
1470 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1474 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1476 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &constr
);
1477 exprval_release(&exprval
);
1481 if(V_VT(&constr
) != VT_DISPATCH
) {
1482 FIXME("throw TypeError\n");
1483 VariantClear(&constr
);
1487 hres
= disp_call(V_DISPATCH(&constr
), DISPID_VALUE
, ctx
->parser
->script
->lcid
,
1488 DISPATCH_CONSTRUCT
, &dp
, &var
, ei
, NULL
/*FIXME*/);
1489 IDispatch_Release(V_DISPATCH(&constr
));
1493 ret
->type
= EXPRVAL_VARIANT
;
1498 /* ECMA-262 3rd Edition 11.2.3 */
1499 HRESULT
call_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1501 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1509 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1513 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1514 if(SUCCEEDED(hres
)) {
1515 switch(exprval
.type
) {
1517 hres
= disp_call(exprval
.u
.idref
.disp
, exprval
.u
.idref
.id
, ctx
->parser
->script
->lcid
, DISPATCH_METHOD
,
1518 &dp
, flags
& EXPR_NOVAL
? NULL
: &var
, ei
, NULL
/*FIXME*/);
1519 if(flags
& EXPR_NOVAL
)
1520 V_VT(&var
) = VT_EMPTY
;
1523 FIXME("unimplemented type %d\n", V_VT(&func
));
1530 exprval_release(&exprval
);
1534 TRACE("= %s\n", debugstr_variant(&var
));
1535 ret
->type
= EXPRVAL_VARIANT
;
1540 /* ECMA-262 3rd Edition 11.1.1 */
1541 HRESULT
this_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1545 ret
->type
= EXPRVAL_VARIANT
;
1546 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1547 V_DISPATCH(&ret
->u
.var
) = ctx
->this_obj
;
1548 IDispatch_AddRef(ctx
->this_obj
);
1552 /* ECMA-262 3rd Edition 10.1.4 */
1553 HRESULT
identifier_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1555 identifier_expression_t
*expr
= (identifier_expression_t
*)_expr
;
1561 identifier
= SysAllocString(expr
->identifier
);
1563 return E_OUTOFMEMORY
;
1565 hres
= identifier_eval(ctx
, identifier
, flags
, ret
);
1567 SysFreeString(identifier
);
1571 /* ECMA-262 3rd Edition 7.8 */
1572 HRESULT
literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1574 literal_expression_t
*expr
= (literal_expression_t
*)_expr
;
1580 hres
= literal_to_var(expr
->literal
, &var
);
1584 ret
->type
= EXPRVAL_VARIANT
;
1589 /* ECMA-262 3rd Edition 11.1.4 */
1590 HRESULT
array_literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1592 array_literal_expression_t
*expr
= (array_literal_expression_t
*)_expr
;
1593 DWORD length
= 0, i
= 0;
1594 array_element_t
*elem
;
1602 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
)
1603 length
+= elem
->elision
+1;
1604 length
+= expr
->length
;
1606 hres
= create_array(ctx
->parser
->script
, length
, &array
);
1610 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
) {
1613 hres
= expr_eval(ctx
, elem
->expr
, 0, ei
, &exprval
);
1617 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1618 exprval_release(&exprval
);
1622 hres
= jsdisp_propput_idx(array
, i
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
1631 jsdisp_release(array
);
1635 ret
->type
= EXPRVAL_VARIANT
;
1636 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1637 V_DISPATCH(&ret
->u
.var
) = (IDispatch
*)_IDispatchEx_(array
);
1641 /* ECMA-262 3rd Edition 11.1.5 */
1642 HRESULT
property_value_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1644 property_value_expression_t
*expr
= (property_value_expression_t
*)_expr
;
1654 hres
= create_object(ctx
->parser
->script
, NULL
, &obj
);
1658 for(iter
= expr
->property_list
; iter
; iter
= iter
->next
) {
1659 hres
= literal_to_var(iter
->name
, &tmp
);
1663 hres
= to_string(ctx
->parser
->script
, &tmp
, ei
, &name
);
1668 hres
= expr_eval(ctx
, iter
->value
, 0, ei
, &exprval
);
1669 if(SUCCEEDED(hres
)) {
1670 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1671 exprval_release(&exprval
);
1672 if(SUCCEEDED(hres
)) {
1673 hres
= jsdisp_propput_name(obj
, name
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
1678 SysFreeString(name
);
1684 jsdisp_release(obj
);
1688 ret
->type
= EXPRVAL_VARIANT
;
1689 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1690 V_DISPATCH(&ret
->u
.var
) = (IDispatch
*)_IDispatchEx_(obj
);
1694 /* ECMA-262 3rd Edition 11.14 */
1695 HRESULT
comma_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1697 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1703 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1707 VariantClear(&lval
);
1709 ret
->type
= EXPRVAL_VARIANT
;
1714 /* ECMA-262 3rd Edition 11.11 */
1715 HRESULT
logical_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1717 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1725 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1729 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1730 exprval_release(&exprval
);
1734 hres
= to_boolean(&val
, &b
);
1735 if(SUCCEEDED(hres
) && b
) {
1736 ret
->type
= EXPRVAL_VARIANT
;
1745 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1749 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1750 exprval_release(&exprval
);
1754 ret
->type
= EXPRVAL_VARIANT
;
1759 /* ECMA-262 3rd Edition 11.11 */
1760 HRESULT
logical_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1762 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1770 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1774 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1775 exprval_release(&exprval
);
1779 hres
= to_boolean(&val
, &b
);
1780 if(SUCCEEDED(hres
) && !b
) {
1781 ret
->type
= EXPRVAL_VARIANT
;
1790 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1794 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1795 exprval_release(&exprval
);
1799 ret
->type
= EXPRVAL_VARIANT
;
1804 /* ECMA-262 3rd Edition 11.10 */
1805 static HRESULT
bitor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1810 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1814 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1823 /* ECMA-262 3rd Edition 11.10 */
1824 HRESULT
binary_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1826 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1830 return binary_expr_eval(ctx
, expr
, bitor_eval
, ei
, ret
);
1833 /* ECMA-262 3rd Edition 11.10 */
1834 static HRESULT
xor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1839 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1843 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1852 /* ECMA-262 3rd Edition 11.10 */
1853 HRESULT
binary_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1855 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1859 return binary_expr_eval(ctx
, expr
, xor_eval
, ei
, ret
);
1862 /* ECMA-262 3rd Edition 11.10 */
1863 static HRESULT
bitand_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1868 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1872 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1881 /* ECMA-262 3rd Edition 11.10 */
1882 HRESULT
binary_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1884 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1888 return binary_expr_eval(ctx
, expr
, bitand_eval
, ei
, ret
);
1891 /* ECMA-262 3rd Edition 11.8.6 */
1892 HRESULT
instanceof_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1898 /* ECMA-262 3rd Edition 11.8.7 */
1899 HRESULT
in_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1905 /* ECMA-262 3rd Edition 11.6.1 */
1906 static HRESULT
add_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1911 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
);
1915 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
);
1921 if(V_VT(&l
) == VT_BSTR
|| V_VT(&r
) == VT_BSTR
) {
1922 BSTR lstr
= NULL
, rstr
= NULL
;
1924 if(V_VT(&l
) == VT_BSTR
)
1927 hres
= to_string(ctx
->parser
->script
, &l
, ei
, &lstr
);
1929 if(SUCCEEDED(hres
)) {
1930 if(V_VT(&r
) == VT_BSTR
)
1933 hres
= to_string(ctx
->parser
->script
, &r
, ei
, &rstr
);
1936 if(SUCCEEDED(hres
)) {
1939 len1
= SysStringLen(lstr
);
1940 len2
= SysStringLen(rstr
);
1942 V_VT(retv
) = VT_BSTR
;
1943 V_BSTR(retv
) = SysAllocStringLen(NULL
, len1
+len2
);
1944 memcpy(V_BSTR(retv
), lstr
, len1
*sizeof(WCHAR
));
1945 memcpy(V_BSTR(retv
)+len1
, rstr
, (len2
+1)*sizeof(WCHAR
));
1948 if(V_VT(&l
) != VT_BSTR
)
1949 SysFreeString(lstr
);
1950 if(V_VT(&r
) != VT_BSTR
)
1951 SysFreeString(rstr
);
1955 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &nl
);
1956 if(SUCCEEDED(hres
)) {
1957 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &nr
);
1959 num_set_val(retv
, num_val(&nl
) + num_val(&nr
));
1968 /* ECMA-262 3rd Edition 11.6.1 */
1969 HRESULT
add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1971 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1975 return binary_expr_eval(ctx
, expr
, add_eval
, ei
, ret
);
1978 /* ECMA-262 3rd Edition 11.6.2 */
1979 static HRESULT
sub_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1984 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
1988 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
1992 num_set_val(retv
, num_val(&lnum
) - num_val(&rnum
));
1996 /* ECMA-262 3rd Edition 11.6.2 */
1997 HRESULT
sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1999 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2003 return binary_expr_eval(ctx
, expr
, sub_eval
, ei
, ret
);
2006 /* ECMA-262 3rd Edition 11.5.1 */
2007 static HRESULT
mul_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2012 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2016 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2020 num_set_val(retv
, num_val(&lnum
) * num_val(&rnum
));
2024 /* ECMA-262 3rd Edition 11.5.1 */
2025 HRESULT
mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2027 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2031 return binary_expr_eval(ctx
, expr
, mul_eval
, ei
, ret
);
2034 /* ECMA-262 3rd Edition 11.5.2 */
2035 static HRESULT
div_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2040 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2044 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2048 num_set_val(retv
, num_val(&lnum
) / num_val(&rnum
));
2052 /* ECMA-262 3rd Edition 11.5.2 */
2053 HRESULT
div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2055 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2059 return binary_expr_eval(ctx
, expr
, div_eval
, ei
, ret
);
2062 /* ECMA-262 3rd Edition 11.5.3 */
2063 static HRESULT
mod_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2068 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2072 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2076 num_set_val(retv
, fmod(num_val(&lnum
), num_val(&rnum
)));
2080 /* ECMA-262 3rd Edition 11.5.3 */
2081 HRESULT
mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2083 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2087 return binary_expr_eval(ctx
, expr
, mod_eval
, ei
, ret
);
2090 /* ECMA-262 3rd Edition 11.4.2 */
2091 HRESULT
delete_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2093 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2094 VARIANT_BOOL b
= VARIANT_FALSE
;
2100 hres
= expr_eval(ctx
, expr
->expression
, EXPR_STRREF
, ei
, &exprval
);
2104 switch(exprval
.type
) {
2105 case EXPRVAL_IDREF
: {
2106 IDispatchEx
*dispex
;
2108 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2109 if(SUCCEEDED(hres
)) {
2110 hres
= IDispatchEx_DeleteMemberByDispID(dispex
, exprval
.u
.idref
.id
);
2112 IDispatchEx_Release(dispex
);
2116 case EXPRVAL_NAMEREF
: {
2117 IDispatchEx
*dispex
;
2119 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2120 if(SUCCEEDED(hres
)) {
2121 hres
= IDispatchEx_DeleteMemberByName(dispex
, exprval
.u
.nameref
.name
, fdexNameCaseSensitive
);
2123 IDispatchEx_Release(dispex
);
2128 FIXME("unsupported type %d\n", exprval
.type
);
2132 exprval_release(&exprval
);
2136 return return_bool(ret
, b
);
2139 /* ECMA-262 3rd Edition 11.4.2 */
2140 HRESULT
void_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2142 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2149 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2153 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &tmp
);
2154 exprval_release(&exprval
);
2160 ret
->type
= EXPRVAL_VARIANT
;
2161 V_VT(&ret
->u
.var
) = VT_EMPTY
;
2165 /* ECMA-262 3rd Edition 11.4.3 */
2166 HRESULT
typeof_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2168 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2174 static const WCHAR booleanW
[] = {'b','o','o','l','e','a','n',0};
2175 static const WCHAR functionW
[] = {'f','u','n','c','t','i','o','n',0};
2176 static const WCHAR numberW
[] = {'n','u','m','b','e','r',0};
2177 static const WCHAR objectW
[] = {'o','b','j','e','c','t',0};
2178 static const WCHAR stringW
[] = {'s','t','r','i','n','g',0};
2179 static const WCHAR undefinedW
[] = {'u','n','d','e','f','i','n','e','d',0};
2183 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2187 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2188 exprval_release(&exprval
);
2192 switch(V_VT(&val
)) {
2212 dispex
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(&val
));
2214 str
= dispex
->builtin_info
->class == JSCLASS_FUNCTION
? functionW
: objectW
;
2215 IDispatchEx_Release(_IDispatchEx_(dispex
));
2222 FIXME("unhandled vt %d\n", V_VT(&val
));
2229 ret
->type
= EXPRVAL_VARIANT
;
2230 V_VT(&ret
->u
.var
) = VT_BSTR
;
2231 V_BSTR(&ret
->u
.var
) = SysAllocString(str
);
2235 /* ECMA-262 3rd Edition 11.4.7 */
2236 HRESULT
minus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2238 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2245 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2249 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2250 exprval_release(&exprval
);
2254 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2259 ret
->type
= EXPRVAL_VARIANT
;
2260 num_set_val(&ret
->u
.var
, -num_val(&num
));
2264 /* ECMA-262 3rd Edition 11.4.6 */
2265 HRESULT
plus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2267 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2274 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2278 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2279 exprval_release(&exprval
);
2283 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2287 ret
->type
= EXPRVAL_VARIANT
;
2292 /* ECMA-262 3rd Edition 11.3.1 */
2293 HRESULT
post_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2295 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2302 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2306 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2307 if(SUCCEEDED(hres
)) {
2308 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2312 if(SUCCEEDED(hres
)) {
2314 num_set_val(&inc
, num_val(&num
)+1.0);
2315 hres
= put_value(ctx
->parser
->script
, &exprval
, &inc
, ei
);
2318 exprval_release(&exprval
);
2322 ret
->type
= EXPRVAL_VARIANT
;
2327 /* ECMA-262 3rd Edition 11.3.2 */
2328 HRESULT
post_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2330 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2337 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2341 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2342 if(SUCCEEDED(hres
)) {
2343 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2347 if(SUCCEEDED(hres
)) {
2349 num_set_val(&dec
, num_val(&num
)-1.0);
2350 hres
= put_value(ctx
->parser
->script
, &exprval
, &dec
, ei
);
2353 exprval_release(&exprval
);
2357 ret
->type
= EXPRVAL_VARIANT
;
2362 /* ECMA-262 3rd Edition 11.4.4 */
2363 HRESULT
pre_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2365 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2372 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2376 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2377 if(SUCCEEDED(hres
)) {
2378 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2382 if(SUCCEEDED(hres
)) {
2383 num_set_val(&val
, num_val(&num
)+1.0);
2384 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2387 exprval_release(&exprval
);
2391 ret
->type
= EXPRVAL_VARIANT
;
2396 /* ECMA-262 3rd Edition 11.4.5 */
2397 HRESULT
pre_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2399 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2406 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2410 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2411 if(SUCCEEDED(hres
)) {
2412 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2416 if(SUCCEEDED(hres
)) {
2417 num_set_val(&val
, num_val(&num
)-1.0);
2418 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2421 exprval_release(&exprval
);
2425 ret
->type
= EXPRVAL_VARIANT
;
2430 /* ECMA-262 3rd Edition 11.9.3 */
2431 static HRESULT
equal_values(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, BOOL
*ret
)
2433 if(V_VT(lval
) == V_VT(rval
) || (is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
))))
2434 return equal2_values(lval
, rval
, ret
);
2436 /* FIXME: NULL disps should be handled in more general way */
2437 if(V_VT(lval
) == VT_DISPATCH
&& !V_DISPATCH(lval
)) {
2440 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2443 if(V_VT(rval
) == VT_DISPATCH
&& !V_DISPATCH(rval
)) {
2446 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2449 if((V_VT(lval
) == VT_NULL
&& V_VT(rval
) == VT_EMPTY
) ||
2450 (V_VT(lval
) == VT_EMPTY
&& V_VT(rval
) == VT_NULL
)) {
2455 if(V_VT(lval
) == VT_BSTR
&& is_num_vt(V_VT(rval
))) {
2459 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &v
);
2463 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2466 if(V_VT(rval
) == VT_BSTR
&& is_num_vt(V_VT(lval
))) {
2470 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &v
);
2474 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2477 if(V_VT(rval
) == VT_BOOL
) {
2481 V_I4(&v
) = V_BOOL(rval
) ? 1 : 0;
2482 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2485 if(V_VT(lval
) == VT_BOOL
) {
2489 V_I4(&v
) = V_BOOL(lval
) ? 1 : 0;
2490 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2494 if(V_VT(rval
) == VT_DISPATCH
&& (V_VT(lval
) == VT_BSTR
|| is_num_vt(V_VT(lval
)))) {
2498 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &v
);
2502 hres
= equal_values(ctx
, lval
, &v
, ei
, ret
);
2509 if(V_VT(lval
) == VT_DISPATCH
&& (V_VT(rval
) == VT_BSTR
|| is_num_vt(V_VT(rval
)))) {
2513 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &v
);
2517 hres
= equal_values(ctx
, &v
, rval
, ei
, ret
);
2528 /* ECMA-262 3rd Edition 11.9.1 */
2529 HRESULT
equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2531 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2538 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2542 hres
= equal_values(ctx
, &rval
, &lval
, ei
, &b
);
2546 return return_bool(ret
, b
);
2549 /* ECMA-262 3rd Edition 11.9.4 */
2550 HRESULT
equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2552 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2559 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2563 hres
= equal2_values(&rval
, &lval
, &b
);
2567 return return_bool(ret
, b
);
2570 /* ECMA-262 3rd Edition 11.9.2 */
2571 HRESULT
not_equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2573 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2580 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2584 hres
= equal_values(ctx
, &lval
, &rval
, ei
, &b
);
2588 return return_bool(ret
, !b
);
2591 /* ECMA-262 3rd Edition 11.9.5 */
2592 HRESULT
not_equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2594 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2601 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2605 hres
= equal2_values(&lval
, &rval
, &b
);
2609 return return_bool(ret
, !b
);
2612 /* ECMA-262 3rd Edition 11.8.5 */
2613 static HRESULT
less_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, BOOL greater
, jsexcept_t
*ei
, BOOL
*ret
)
2615 VARIANT l
, r
, ln
, rn
;
2618 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
);
2622 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
);
2628 if(V_VT(&l
) == VT_BSTR
&& V_VT(&r
) == VT_BSTR
) {
2629 *ret
= (strcmpW(V_BSTR(&l
), V_BSTR(&r
)) < 0) ^ greater
;
2630 SysFreeString(V_BSTR(&l
));
2631 SysFreeString(V_BSTR(&r
));
2635 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &ln
);
2638 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &rn
);
2643 if(V_VT(&ln
) == VT_I4
&& V_VT(&rn
) == VT_I4
) {
2644 *ret
= (V_I4(&ln
) < V_I4(&rn
)) ^ greater
;
2646 DOUBLE ld
= num_val(&ln
);
2647 DOUBLE rd
= num_val(&rn
);
2649 *ret
= !isnan(ld
) && !isnan(rd
) && ((ld
< rd
) ^ greater
);
2655 /* ECMA-262 3rd Edition 11.8.1 */
2656 HRESULT
less_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2658 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2665 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2669 hres
= less_eval(ctx
, &lval
, &rval
, FALSE
, ei
, &b
);
2670 VariantClear(&lval
);
2671 VariantClear(&rval
);
2675 return return_bool(ret
, b
);
2678 /* ECMA-262 3rd Edition 11.8.3 */
2679 HRESULT
lesseq_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2681 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2688 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2692 hres
= less_eval(ctx
, &rval
, &lval
, TRUE
, ei
, &b
);
2693 VariantClear(&lval
);
2694 VariantClear(&rval
);
2698 return return_bool(ret
, b
);
2701 /* ECMA-262 3rd Edition 11.8.2 */
2702 HRESULT
greater_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2704 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2711 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2715 hres
= less_eval(ctx
, &rval
, &lval
, FALSE
, ei
, &b
);
2716 VariantClear(&lval
);
2717 VariantClear(&rval
);
2721 return return_bool(ret
, b
);
2724 /* ECMA-262 3rd Edition 11.8.4 */
2725 HRESULT
greatereq_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2727 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2734 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2738 hres
= less_eval(ctx
, &lval
, &rval
, TRUE
, ei
, &b
);
2739 VariantClear(&lval
);
2740 VariantClear(&rval
);
2744 return return_bool(ret
, b
);
2747 /* ECMA-262 3rd Edition 11.4.8 */
2748 HRESULT
binary_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2750 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2758 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2762 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2763 exprval_release(&exprval
);
2767 hres
= to_int32(ctx
->parser
->script
, &val
, ei
, &i
);
2771 ret
->type
= EXPRVAL_VARIANT
;
2772 V_VT(&ret
->u
.var
) = VT_I4
;
2773 V_I4(&ret
->u
.var
) = ~i
;
2777 /* ECMA-262 3rd Edition 11.4.9 */
2778 HRESULT
logical_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2780 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2787 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2791 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
2792 exprval_release(&exprval
);
2796 return return_bool(ret
, !b
);
2799 /* ECMA-262 3rd Edition 11.7.1 */
2800 static HRESULT
lshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2806 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
2810 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2815 V_I4(retv
) = li
<< (ri
&0x1f);
2819 /* ECMA-262 3rd Edition 11.7.1 */
2820 HRESULT
left_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2822 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2826 return binary_expr_eval(ctx
, expr
, lshift_eval
, ei
, ret
);
2829 /* ECMA-262 3rd Edition 11.7.2 */
2830 static HRESULT
rshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2836 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
2840 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2845 V_I4(retv
) = li
>> (ri
&0x1f);
2849 /* ECMA-262 3rd Edition 11.7.2 */
2850 HRESULT
right_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2852 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2856 return binary_expr_eval(ctx
, expr
, rshift_eval
, ei
, ret
);
2859 /* ECMA-262 3rd Edition 11.7.3 */
2860 static HRESULT
rshift2_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2865 hres
= to_uint32(ctx
->parser
->script
, lval
, ei
, &li
);
2869 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2874 V_I4(retv
) = li
>> (ri
&0x1f);
2878 /* ECMA-262 3rd Edition 11.7.3 */
2879 HRESULT
right2_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2881 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2885 return binary_expr_eval(ctx
, expr
, rshift2_eval
, ei
, ret
);
2888 /* ECMA-262 3rd Edition 11.13.1 */
2889 HRESULT
assign_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2891 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2892 exprval_t exprval
, exprvalr
;
2898 hres
= expr_eval(ctx
, expr
->expression1
, EXPR_NEWREF
, ei
, &exprval
);
2902 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprvalr
);
2903 if(SUCCEEDED(hres
)) {
2904 hres
= exprval_to_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
2905 exprval_release(&exprvalr
);
2909 hres
= put_value(ctx
->parser
->script
, &exprval
, &rval
, ei
);
2911 exprval_release(&exprval
);
2915 ret
->type
= EXPRVAL_VARIANT
;
2920 /* ECMA-262 3rd Edition 11.13.2 */
2921 HRESULT
assign_lshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2923 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2927 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, lshift_eval
, ei
, ret
);
2930 /* ECMA-262 3rd Edition 11.13.2 */
2931 HRESULT
assign_rshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2933 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2937 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift_eval
, ei
, ret
);
2940 /* ECMA-262 3rd Edition 11.13.2 */
2941 HRESULT
assign_rrshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2943 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2947 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift2_eval
, ei
, ret
);
2950 /* ECMA-262 3rd Edition 11.13.2 */
2951 HRESULT
assign_add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2953 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2957 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, add_eval
, ei
, ret
);
2960 /* ECMA-262 3rd Edition 11.13.2 */
2961 HRESULT
assign_sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2963 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2967 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, sub_eval
, ei
, ret
);
2970 /* ECMA-262 3rd Edition 11.13.2 */
2971 HRESULT
assign_mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2973 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2977 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mul_eval
, ei
, ret
);
2980 /* ECMA-262 3rd Edition 11.13.2 */
2981 HRESULT
assign_div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2983 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2987 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, div_eval
, ei
, ret
);
2990 /* ECMA-262 3rd Edition 11.13.2 */
2991 HRESULT
assign_mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2993 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2997 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mod_eval
, ei
, ret
);
3000 /* ECMA-262 3rd Edition 11.13.2 */
3001 HRESULT
assign_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3003 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3007 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitand_eval
, ei
, ret
);
3010 /* ECMA-262 3rd Edition 11.13.2 */
3011 HRESULT
assign_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3013 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3017 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitor_eval
, ei
, ret
);
3020 /* ECMA-262 3rd Edition 11.13.2 */
3021 HRESULT
assign_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3023 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3027 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, xor_eval
, ei
, ret
);