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
;
184 IDispatch_AddRef(this_obj
);
185 ctx
->this_obj
= this_obj
;
187 IDispatchEx_AddRef(_IDispatchEx_(var_disp
));
188 ctx
->var_disp
= var_disp
;
192 ctx
->scope_chain
= scope
;
199 void exec_release(exec_ctx_t
*ctx
)
205 scope_release(ctx
->scope_chain
);
207 IDispatchEx_Release(_IDispatchEx_(ctx
->var_disp
));
209 IDispatch_Release(ctx
->this_obj
);
213 static HRESULT
disp_get_id(IDispatch
*disp
, BSTR name
, DWORD flags
, DISPID
*id
)
218 hres
= IDispatch_QueryInterface(disp
, &IID_IDispatchEx
, (void**)&dispex
);
220 TRACE("unsing IDispatch\n");
223 return IDispatch_GetIDsOfNames(disp
, &IID_NULL
, &name
, 1, 0, id
);
227 hres
= IDispatchEx_GetDispID(dispex
, name
, flags
|fdexNameCaseSensitive
, id
);
228 IDispatchEx_Release(dispex
);
232 /* ECMA-262 3rd Edition 8.7.2 */
233 static HRESULT
put_value(script_ctx_t
*ctx
, exprval_t
*ref
, VARIANT
*v
, jsexcept_t
*ei
)
235 if(ref
->type
!= EXPRVAL_IDREF
)
236 return throw_reference_error(ctx
, ei
, IDS_ILLEGAL_ASSIGN
, NULL
);
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 static 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
);
308 *ret
= SysStringLen(V_BSTR(rval
))?FALSE
:TRUE
;
309 else if(!V_BSTR(rval
))
310 *ret
= SysStringLen(V_BSTR(lval
))?FALSE
:TRUE
;
312 *ret
= !strcmpW(V_BSTR(lval
), V_BSTR(rval
));
315 return disp_cmp(V_DISPATCH(lval
), V_DISPATCH(rval
), ret
);
317 *ret
= !V_BOOL(lval
) == !V_BOOL(rval
);
320 FIXME("unimplemented vt %d\n", V_VT(lval
));
327 static HRESULT
literal_to_var(literal_t
*literal
, VARIANT
*v
)
329 V_VT(v
) = literal
->vt
;
336 V_I4(v
) = literal
->u
.lval
;
339 V_R8(v
) = literal
->u
.dval
;
342 V_BSTR(v
) = SysAllocString(literal
->u
.wstr
);
345 V_BOOL(v
) = literal
->u
.bval
;
348 IDispatch_AddRef(literal
->u
.disp
);
349 V_DISPATCH(v
) = literal
->u
.disp
;
352 ERR("wrong type %d\n", V_VT(v
));
359 static BOOL
lookup_global_members(script_ctx_t
*ctx
, BSTR identifier
, exprval_t
*ret
)
365 for(item
= ctx
->named_items
; item
; item
= item
->next
) {
366 if(item
->flags
& SCRIPTITEM_GLOBALMEMBERS
) {
367 hres
= disp_get_id(item
->disp
, identifier
, 0, &id
);
368 if(SUCCEEDED(hres
)) {
370 exprval_set_idref(ret
, item
->disp
, id
);
379 HRESULT
exec_source(exec_ctx_t
*ctx
, parser_ctx_t
*parser
, source_elements_t
*source
, jsexcept_t
*ei
, VARIANT
*retv
)
381 script_ctx_t
*script
= parser
->script
;
382 function_declaration_t
*func
;
383 parser_ctx_t
*prev_parser
;
387 exec_ctx_t
*prev_ctx
;
391 for(func
= source
->functions
; func
; func
= func
->next
) {
392 DispatchEx
*func_obj
;
395 hres
= create_source_function(parser
, func
->expr
->parameter_list
, func
->expr
->source_elements
,
396 ctx
->scope_chain
, func
->expr
->src_str
, func
->expr
->src_len
, &func_obj
);
400 V_VT(&var
) = VT_DISPATCH
;
401 V_DISPATCH(&var
) = (IDispatch
*)_IDispatchEx_(func_obj
);
402 hres
= jsdisp_propput_name(ctx
->var_disp
, func
->expr
->identifier
, script
->lcid
, &var
, ei
, NULL
);
403 jsdisp_release(func_obj
);
408 for(var
= source
->variables
; var
; var
= var
->next
) {
411 hres
= jsdisp_get_id(ctx
->var_disp
, var
->identifier
, fdexNameEnsure
, &id
);
416 prev_ctx
= script
->exec_ctx
;
417 script
->exec_ctx
= ctx
;
419 prev_parser
= ctx
->parser
;
420 ctx
->parser
= parser
;
422 V_VT(&val
) = VT_EMPTY
;
423 memset(&rt
, 0, sizeof(rt
));
426 for(stat
= source
->statement
; stat
; stat
= stat
->next
) {
427 hres
= stat_eval(ctx
, stat
, &rt
, &tmp
);
433 if(rt
.type
!= RT_NORMAL
)
437 script
->exec_ctx
= prev_ctx
;
438 ctx
->parser
= prev_parser
;
440 if(rt
.type
!= RT_NORMAL
&& rt
.type
!= RT_RETURN
) {
441 FIXME("wrong rt %d\n", rt
.type
);
458 /* ECMA-262 3rd Edition 10.1.4 */
459 static HRESULT
identifier_eval(exec_ctx_t
*ctx
, BSTR identifier
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
461 scope_chain_t
*scope
;
466 TRACE("%s\n", debugstr_w(identifier
));
468 for(scope
= ctx
->scope_chain
; scope
; scope
= scope
->next
) {
469 hres
= jsdisp_get_id(scope
->obj
, identifier
, 0, &id
);
475 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(scope
->obj
), id
);
479 hres
= jsdisp_get_id(ctx
->parser
->script
->global
, identifier
, 0, &id
);
480 if(SUCCEEDED(hres
)) {
481 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->parser
->script
->global
), id
);
485 for(item
= ctx
->parser
->script
->named_items
; item
; item
= item
->next
) {
486 if((item
->flags
& SCRIPTITEM_ISVISIBLE
) && !strcmpW(item
->name
, identifier
)) {
490 if(!ctx
->parser
->script
->site
)
493 hres
= IActiveScriptSite_GetItemInfo(ctx
->parser
->script
->site
, identifier
,
494 SCRIPTINFO_IUNKNOWN
, &unk
, NULL
);
496 WARN("GetItemInfo failed: %08x\n", hres
);
500 hres
= IUnknown_QueryInterface(unk
, &IID_IDispatch
, (void**)&item
->disp
);
501 IUnknown_Release(unk
);
503 WARN("object does not implement IDispatch\n");
508 ret
->type
= EXPRVAL_VARIANT
;
509 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
510 V_DISPATCH(&ret
->u
.var
) = item
->disp
;
511 IDispatch_AddRef(item
->disp
);
516 hres
= jsdisp_get_id(ctx
->parser
->script
->script_disp
, identifier
, 0, &id
);
517 if(SUCCEEDED(hres
)) {
518 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->parser
->script
->script_disp
), id
);
522 if(lookup_global_members(ctx
->parser
->script
, identifier
, ret
))
525 if(flags
& EXPR_NEWREF
) {
526 hres
= jsdisp_get_id(ctx
->var_disp
, identifier
, fdexNameEnsure
, &id
);
530 exprval_set_idref(ret
, (IDispatch
*)_IDispatchEx_(ctx
->var_disp
), id
);
534 return throw_type_error(ctx
->var_disp
->ctx
, ei
, IDS_UNDEFINED
, identifier
);
537 /* ECMA-262 3rd Edition 12.1 */
538 HRESULT
block_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
540 block_statement_t
*stat
= (block_statement_t
*)_stat
;
547 V_VT(&val
) = VT_EMPTY
;
548 for(iter
= stat
->stat_list
; iter
; iter
= iter
->next
) {
549 hres
= stat_eval(ctx
, iter
, rt
, &tmp
);
555 if(rt
->type
!= RT_NORMAL
)
568 /* ECMA-262 3rd Edition 12.2 */
569 static HRESULT
variable_list_eval(exec_ctx_t
*ctx
, variable_declaration_t
*var_list
, jsexcept_t
*ei
)
571 variable_declaration_t
*iter
;
574 for(iter
= var_list
; iter
; iter
= iter
->next
) {
581 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
585 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
586 exprval_release(&exprval
);
590 hres
= jsdisp_propput_name(ctx
->var_disp
, iter
->identifier
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
599 /* ECMA-262 3rd Edition 12.2 */
600 HRESULT
var_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
602 var_statement_t
*stat
= (var_statement_t
*)_stat
;
607 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
611 V_VT(ret
) = VT_EMPTY
;
615 /* ECMA-262 3rd Edition 12.3 */
616 HRESULT
empty_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
620 V_VT(ret
) = VT_EMPTY
;
624 /* ECMA-262 3rd Edition 12.4 */
625 HRESULT
expression_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
627 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
634 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NOVAL
, &rt
->ei
, &exprval
);
638 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
639 exprval_release(&exprval
);
644 TRACE("= %s\n", debugstr_variant(ret
));
648 /* ECMA-262 3rd Edition 12.5 */
649 HRESULT
if_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
651 if_statement_t
*stat
= (if_statement_t
*)_stat
;
658 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
662 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
663 exprval_release(&exprval
);
668 hres
= stat_eval(ctx
, stat
->if_stat
, rt
, ret
);
669 else if(stat
->else_stat
)
670 hres
= stat_eval(ctx
, stat
->else_stat
, rt
, ret
);
672 V_VT(ret
) = VT_EMPTY
;
677 /* ECMA-262 3rd Edition 12.6.2 */
678 HRESULT
while_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
680 while_statement_t
*stat
= (while_statement_t
*)_stat
;
689 V_VT(&val
) = VT_EMPTY
;
690 test_expr
= !stat
->do_while
;
694 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
698 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
699 exprval_release(&exprval
);
700 if(FAILED(hres
) || !b
)
706 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
713 if(rt
->type
== RT_CONTINUE
)
714 rt
->type
= RT_NORMAL
;
715 if(rt
->type
!= RT_NORMAL
)
724 if(rt
->type
== RT_BREAK
)
725 rt
->type
= RT_NORMAL
;
731 /* ECMA-262 3rd Edition 12.6.3 */
732 HRESULT
for_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
734 for_statement_t
*stat
= (for_statement_t
*)_stat
;
735 VARIANT val
, tmp
, retv
;
742 if(stat
->variable_list
) {
743 hres
= variable_list_eval(ctx
, stat
->variable_list
, &rt
->ei
);
746 }else if(stat
->begin_expr
) {
747 hres
= expr_eval(ctx
, stat
->begin_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
751 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
752 exprval_release(&exprval
);
759 V_VT(&retv
) = VT_EMPTY
;
763 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
767 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, &rt
->ei
, &b
);
768 exprval_release(&exprval
);
769 if(FAILED(hres
) || !b
)
773 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
780 if(rt
->type
== RT_CONTINUE
)
781 rt
->type
= RT_NORMAL
;
782 else if(rt
->type
!= RT_NORMAL
)
786 hres
= expr_eval(ctx
, stat
->end_expr
, 0, &rt
->ei
, &exprval
);
790 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
791 exprval_release(&exprval
);
804 if(rt
->type
== RT_BREAK
)
805 rt
->type
= RT_NORMAL
;
811 /* ECMA-262 3rd Edition 12.6.4 */
812 HRESULT
forin_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
814 forin_statement_t
*stat
= (forin_statement_t
*)_stat
;
815 VARIANT val
, name
, retv
, tmp
;
816 DISPID id
= DISPID_STARTENUM
;
817 BSTR str
, identifier
= NULL
;
825 hres
= variable_list_eval(ctx
, stat
->variable
, &rt
->ei
);
830 hres
= expr_eval(ctx
, stat
->in_expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
834 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
835 exprval_release(&exprval
);
839 if(V_VT(&val
) != VT_DISPATCH
) {
840 TRACE("in vt %d\n", V_VT(&val
));
842 V_VT(ret
) = VT_EMPTY
;
846 hres
= IDispatch_QueryInterface(V_DISPATCH(&val
), &IID_IDispatchEx
, (void**)&in_obj
);
847 IDispatch_Release(V_DISPATCH(&val
));
849 FIXME("Object doesn't support IDispatchEx\n");
853 V_VT(&retv
) = VT_EMPTY
;
856 identifier
= SysAllocString(stat
->variable
->identifier
);
859 hres
= IDispatchEx_GetNextDispID(in_obj
, fdexEnumDefault
, id
, &id
);
860 if(FAILED(hres
) || hres
== S_FALSE
)
863 hres
= IDispatchEx_GetMemberName(in_obj
, id
, &str
);
867 TRACE("iter %s\n", debugstr_w(str
));
870 hres
= identifier_eval(ctx
, identifier
, 0, NULL
, &exprval
);
872 hres
= expr_eval(ctx
, stat
->expr
, EXPR_NEWREF
, &rt
->ei
, &exprval
);
873 if(SUCCEEDED(hres
)) {
874 V_VT(&name
) = VT_BSTR
;
876 hres
= put_value(ctx
->parser
->script
, &exprval
, &name
, &rt
->ei
);
877 exprval_release(&exprval
);
883 hres
= stat_eval(ctx
, stat
->statement
, rt
, &tmp
);
890 if(rt
->type
== RT_CONTINUE
)
891 rt
->type
= RT_NORMAL
;
892 else if(rt
->type
!= RT_NORMAL
)
896 SysFreeString(identifier
);
897 IDispatchEx_Release(in_obj
);
903 if(rt
->type
== RT_BREAK
)
904 rt
->type
= RT_NORMAL
;
910 /* ECMA-262 3rd Edition 12.7 */
911 HRESULT
continue_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
913 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
917 if(stat
->identifier
) {
918 FIXME("indentifier not implemented\n");
922 rt
->type
= RT_CONTINUE
;
923 V_VT(ret
) = VT_EMPTY
;
927 /* ECMA-262 3rd Edition 12.8 */
928 HRESULT
break_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
930 branch_statement_t
*stat
= (branch_statement_t
*)_stat
;
934 if(stat
->identifier
) {
935 FIXME("indentifier not implemented\n");
940 V_VT(ret
) = VT_EMPTY
;
944 /* ECMA-262 3rd Edition 12.9 */
945 HRESULT
return_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
947 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
955 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
959 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, ret
);
960 exprval_release(&exprval
);
964 V_VT(ret
) = VT_EMPTY
;
967 TRACE("= %s\n", debugstr_variant(ret
));
968 rt
->type
= RT_RETURN
;
972 /* ECMA-262 3rd Edition 12.10 */
973 HRESULT
with_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
975 with_statement_t
*stat
= (with_statement_t
*)_stat
;
984 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
988 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
989 exprval_release(&exprval
);
993 hres
= to_object(ctx
, &val
, &disp
);
998 obj
= iface_to_jsdisp((IUnknown
*)disp
);
999 IDispatch_Release(disp
);
1001 FIXME("disp id not jsdisp\n");
1005 hres
= scope_push(ctx
->scope_chain
, obj
, &ctx
->scope_chain
);
1006 jsdisp_release(obj
);
1010 hres
= stat_eval(ctx
, stat
->statement
, rt
, ret
);
1012 scope_pop(&ctx
->scope_chain
);
1016 /* ECMA-262 3rd Edition 12.12 */
1017 HRESULT
labelled_statement_eval(exec_ctx_t
*ctx
, statement_t
*stat
, return_type_t
*rt
, VARIANT
*ret
)
1023 /* ECMA-262 3rd Edition 12.13 */
1024 HRESULT
switch_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1026 switch_statement_t
*stat
= (switch_statement_t
*)_stat
;
1027 case_clausule_t
*iter
, *default_clausule
= NULL
;
1028 statement_t
*stat_iter
;
1036 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1040 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1041 exprval_release(&exprval
);
1045 for(iter
= stat
->case_list
; iter
; iter
= iter
->next
) {
1047 default_clausule
= iter
;
1051 hres
= expr_eval(ctx
, iter
->expr
, 0, &rt
->ei
, &exprval
);
1055 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &cval
);
1056 exprval_release(&exprval
);
1060 hres
= equal2_values(&val
, &cval
, &b
);
1061 VariantClear(&cval
);
1062 if(FAILED(hres
) || b
)
1071 iter
= default_clausule
;
1073 V_VT(&val
) = VT_EMPTY
;
1077 for(stat_iter
= iter
->stat
; stat_iter
; stat_iter
= stat_iter
->next
) {
1078 hres
= stat_eval(ctx
, stat_iter
, rt
, &tmp
);
1085 if(rt
->type
!= RT_NORMAL
)
1095 if(rt
->type
== RT_BREAK
)
1096 rt
->type
= RT_NORMAL
;
1102 /* ECMA-262 3rd Edition 12.13 */
1103 HRESULT
throw_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1105 expression_statement_t
*stat
= (expression_statement_t
*)_stat
;
1112 hres
= expr_eval(ctx
, stat
->expr
, 0, &rt
->ei
, &exprval
);
1116 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, &rt
->ei
, &val
);
1117 exprval_release(&exprval
);
1122 return DISP_E_EXCEPTION
;
1125 /* ECMA-262 3rd Edition 12.14 */
1126 static HRESULT
catch_eval(exec_ctx_t
*ctx
, catch_block_t
*block
, return_type_t
*rt
, VARIANT
*ret
)
1128 DispatchEx
*var_disp
;
1133 memset(&rt
->ei
, 0, sizeof(jsexcept_t
));
1135 hres
= create_dispex(ctx
->parser
->script
, NULL
, NULL
, &var_disp
);
1136 if(SUCCEEDED(hres
)) {
1137 hres
= jsdisp_propput_name(var_disp
, block
->identifier
, ctx
->parser
->script
->lcid
,
1138 &ex
, &rt
->ei
, NULL
/*FIXME*/);
1139 if(SUCCEEDED(hres
)) {
1140 hres
= scope_push(ctx
->scope_chain
, var_disp
, &ctx
->scope_chain
);
1141 if(SUCCEEDED(hres
)) {
1142 hres
= stat_eval(ctx
, block
->statement
, rt
, &val
);
1143 scope_pop(&ctx
->scope_chain
);
1147 jsdisp_release(var_disp
);
1158 /* ECMA-262 3rd Edition 12.14 */
1159 HRESULT
try_statement_eval(exec_ctx_t
*ctx
, statement_t
*_stat
, return_type_t
*rt
, VARIANT
*ret
)
1161 try_statement_t
*stat
= (try_statement_t
*)_stat
;
1167 hres
= stat_eval(ctx
, stat
->try_statement
, rt
, &val
);
1169 TRACE("EXCEPTION\n");
1170 if(!stat
->catch_block
)
1173 hres
= catch_eval(ctx
, stat
->catch_block
, rt
, &val
);
1178 if(stat
->finally_statement
) {
1180 hres
= stat_eval(ctx
, stat
->finally_statement
, rt
, &val
);
1189 static HRESULT
return_bool(exprval_t
*ret
, DWORD b
)
1191 ret
->type
= EXPRVAL_VARIANT
;
1192 V_VT(&ret
->u
.var
) = VT_BOOL
;
1193 V_BOOL(&ret
->u
.var
) = b
? VARIANT_TRUE
: VARIANT_FALSE
;
1198 static HRESULT
get_binary_expr_values(exec_ctx_t
*ctx
, binary_expression_t
*expr
, jsexcept_t
*ei
, VARIANT
*lval
, VARIANT
*rval
)
1203 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1207 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, lval
);
1208 exprval_release(&exprval
);
1212 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1213 if(SUCCEEDED(hres
)) {
1214 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, rval
);
1215 exprval_release(&exprval
);
1226 typedef HRESULT (*oper_t
)(exec_ctx_t
*,VARIANT
*,VARIANT
*,jsexcept_t
*,VARIANT
*);
1228 static HRESULT
binary_expr_eval(exec_ctx_t
*ctx
, binary_expression_t
*expr
, oper_t oper
, jsexcept_t
*ei
,
1231 VARIANT lval
, rval
, retv
;
1234 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1238 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1239 VariantClear(&lval
);
1240 VariantClear(&rval
);
1244 ret
->type
= EXPRVAL_VARIANT
;
1249 /* ECMA-262 3rd Edition 11.13.2 */
1250 static HRESULT
assign_oper_eval(exec_ctx_t
*ctx
, expression_t
*lexpr
, expression_t
*rexpr
, oper_t oper
,
1251 jsexcept_t
*ei
, exprval_t
*ret
)
1253 VARIANT retv
, lval
, rval
;
1254 exprval_t exprval
, exprvalr
;
1257 hres
= expr_eval(ctx
, lexpr
, EXPR_NEWREF
, ei
, &exprval
);
1261 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &lval
);
1262 if(SUCCEEDED(hres
)) {
1263 hres
= expr_eval(ctx
, rexpr
, 0, ei
, &exprvalr
);
1264 if(SUCCEEDED(hres
)) {
1265 hres
= exprval_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
1266 exprval_release(&exprvalr
);
1268 if(SUCCEEDED(hres
)) {
1269 hres
= oper(ctx
, &lval
, &rval
, ei
, &retv
);
1270 VariantClear(&rval
);
1272 VariantClear(&lval
);
1275 if(SUCCEEDED(hres
)) {
1276 hres
= put_value(ctx
->parser
->script
, &exprval
, &retv
, ei
);
1278 VariantClear(&retv
);
1280 exprval_release(&exprval
);
1285 ret
->type
= EXPRVAL_VARIANT
;
1290 /* ECMA-262 3rd Edition 13 */
1291 HRESULT
function_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1293 function_expression_t
*expr
= (function_expression_t
*)_expr
;
1299 if(expr
->identifier
) {
1300 hres
= jsdisp_propget_name(ctx
->var_disp
, expr
->identifier
, ctx
->parser
->script
->lcid
, &var
, ei
, NULL
/*FIXME*/);
1306 hres
= create_source_function(ctx
->parser
, expr
->parameter_list
, expr
->source_elements
, ctx
->scope_chain
,
1307 expr
->src_str
, expr
->src_len
, &dispex
);
1311 V_VT(&var
) = VT_DISPATCH
;
1312 V_DISPATCH(&var
) = (IDispatch
*)_IDispatchEx_(dispex
);
1315 ret
->type
= EXPRVAL_VARIANT
;
1320 /* ECMA-262 3rd Edition 11.12 */
1321 HRESULT
conditional_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1323 conditional_expression_t
*expr
= (conditional_expression_t
*)_expr
;
1330 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1334 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
1335 exprval_release(&exprval
);
1339 return expr_eval(ctx
, b
? expr
->true_expression
: expr
->false_expression
, flags
, ei
, ret
);
1342 /* ECMA-262 3rd Edition 11.2.1 */
1343 HRESULT
array_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1345 array_expression_t
*expr
= (array_expression_t
*)_expr
;
1347 VARIANT member
, val
;
1350 IDispatch
*obj
= NULL
;
1355 hres
= expr_eval(ctx
, expr
->member_expr
, EXPR_NEWREF
, ei
, &exprval
);
1359 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1360 exprval_release(&exprval
);
1364 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
1365 if(SUCCEEDED(hres
)) {
1366 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1367 exprval_release(&exprval
);
1371 hres
= to_object(ctx
, &member
, &obj
);
1372 VariantClear(&member
);
1373 if(SUCCEEDED(hres
)) {
1374 hres
= to_string(ctx
->parser
->script
, &val
, ei
, &str
);
1375 if(SUCCEEDED(hres
)) {
1376 if(flags
& EXPR_STRREF
) {
1377 ret
->type
= EXPRVAL_NAMEREF
;
1378 ret
->u
.nameref
.disp
= obj
;
1379 ret
->u
.nameref
.name
= str
;
1383 hres
= disp_get_id(obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1386 if(SUCCEEDED(hres
)) {
1387 exprval_set_idref(ret
, obj
, id
);
1388 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1393 IDispatch_Release(obj
);
1399 /* ECMA-262 3rd Edition 11.2.1 */
1400 HRESULT
member_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1402 member_expression_t
*expr
= (member_expression_t
*)_expr
;
1403 IDispatch
*obj
= NULL
;
1412 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1416 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &member
);
1417 exprval_release(&exprval
);
1421 hres
= to_object(ctx
, &member
, &obj
);
1422 VariantClear(&member
);
1426 str
= SysAllocString(expr
->identifier
);
1427 if(flags
& EXPR_STRREF
) {
1428 ret
->type
= EXPRVAL_NAMEREF
;
1429 ret
->u
.nameref
.disp
= obj
;
1430 ret
->u
.nameref
.name
= str
;
1434 hres
= disp_get_id(obj
, str
, flags
& EXPR_NEWREF
? fdexNameEnsure
: 0, &id
);
1436 if(SUCCEEDED(hres
)) {
1437 exprval_set_idref(ret
, obj
, id
);
1438 }else if(!(flags
& EXPR_NEWREF
) && hres
== DISP_E_UNKNOWNNAME
) {
1443 IDispatch_Release(obj
);
1447 static void free_dp(DISPPARAMS
*dp
)
1451 for(i
=0; i
< dp
->cArgs
; i
++)
1452 VariantClear(dp
->rgvarg
+i
);
1453 heap_free(dp
->rgvarg
);
1456 static HRESULT
args_to_param(exec_ctx_t
*ctx
, argument_t
*args
, jsexcept_t
*ei
, DISPPARAMS
*dp
)
1462 HRESULT hres
= S_OK
;
1464 memset(dp
, 0, sizeof(*dp
));
1468 for(iter
= args
; iter
; iter
= iter
->next
)
1471 vargs
= heap_alloc_zero(cnt
* sizeof(*vargs
));
1473 return E_OUTOFMEMORY
;
1475 for(i
= cnt
, iter
= args
; iter
; iter
= iter
->next
) {
1476 hres
= expr_eval(ctx
, iter
->expr
, 0, ei
, &exprval
);
1480 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, vargs
+ (--i
));
1481 exprval_release(&exprval
);
1496 /* ECMA-262 3rd Edition 11.2.2 */
1497 HRESULT
new_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1499 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1501 VARIANT constr
, var
;
1507 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1511 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1513 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &constr
);
1514 exprval_release(&exprval
);
1518 if(V_VT(&constr
) != VT_DISPATCH
) {
1519 FIXME("throw TypeError\n");
1520 VariantClear(&constr
);
1524 hres
= disp_call(V_DISPATCH(&constr
), DISPID_VALUE
, ctx
->parser
->script
->lcid
,
1525 DISPATCH_CONSTRUCT
, &dp
, &var
, ei
, NULL
/*FIXME*/);
1526 IDispatch_Release(V_DISPATCH(&constr
));
1530 ret
->type
= EXPRVAL_VARIANT
;
1535 /* ECMA-262 3rd Edition 11.2.3 */
1536 HRESULT
call_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1538 call_expression_t
*expr
= (call_expression_t
*)_expr
;
1546 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
1550 hres
= args_to_param(ctx
, expr
->argument_list
, ei
, &dp
);
1551 if(SUCCEEDED(hres
)) {
1552 switch(exprval
.type
) {
1553 case EXPRVAL_VARIANT
:
1554 if(V_VT(&exprval
.u
.var
) != VT_DISPATCH
)
1555 return throw_type_error(ctx
->var_disp
->ctx
, ei
, IDS_NO_PROPERTY
, NULL
);
1557 hres
= disp_call(V_DISPATCH(&exprval
.u
.var
), DISPID_VALUE
, ctx
->parser
->script
->lcid
,
1558 DISPATCH_METHOD
, &dp
, flags
& EXPR_NOVAL
? NULL
: &var
, ei
, NULL
/*FIXME*/);
1561 hres
= disp_call(exprval
.u
.idref
.disp
, exprval
.u
.idref
.id
, ctx
->parser
->script
->lcid
,
1562 DISPATCH_METHOD
, &dp
, flags
& EXPR_NOVAL
? NULL
: &var
, ei
, NULL
/*FIXME*/);
1565 FIXME("unimplemented type %d\n", exprval
.type
);
1572 exprval_release(&exprval
);
1576 ret
->type
= EXPRVAL_VARIANT
;
1577 if(flags
& EXPR_NOVAL
) {
1578 V_VT(&ret
->u
.var
) = VT_EMPTY
;
1580 TRACE("= %s\n", debugstr_variant(&var
));
1586 /* ECMA-262 3rd Edition 11.1.1 */
1587 HRESULT
this_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1591 ret
->type
= EXPRVAL_VARIANT
;
1592 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1593 V_DISPATCH(&ret
->u
.var
) = ctx
->this_obj
;
1594 IDispatch_AddRef(ctx
->this_obj
);
1598 /* ECMA-262 3rd Edition 10.1.4 */
1599 HRESULT
identifier_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1601 identifier_expression_t
*expr
= (identifier_expression_t
*)_expr
;
1607 identifier
= SysAllocString(expr
->identifier
);
1609 return E_OUTOFMEMORY
;
1611 hres
= identifier_eval(ctx
, identifier
, flags
, ei
, ret
);
1613 SysFreeString(identifier
);
1617 /* ECMA-262 3rd Edition 7.8 */
1618 HRESULT
literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1620 literal_expression_t
*expr
= (literal_expression_t
*)_expr
;
1626 hres
= literal_to_var(expr
->literal
, &var
);
1630 ret
->type
= EXPRVAL_VARIANT
;
1635 /* ECMA-262 3rd Edition 11.1.4 */
1636 HRESULT
array_literal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1638 array_literal_expression_t
*expr
= (array_literal_expression_t
*)_expr
;
1639 DWORD length
= 0, i
= 0;
1640 array_element_t
*elem
;
1648 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
)
1649 length
+= elem
->elision
+1;
1650 length
+= expr
->length
;
1652 hres
= create_array(ctx
->parser
->script
, length
, &array
);
1656 for(elem
= expr
->element_list
; elem
; elem
= elem
->next
) {
1659 hres
= expr_eval(ctx
, elem
->expr
, 0, ei
, &exprval
);
1663 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1664 exprval_release(&exprval
);
1668 hres
= jsdisp_propput_idx(array
, i
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
1677 jsdisp_release(array
);
1681 ret
->type
= EXPRVAL_VARIANT
;
1682 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1683 V_DISPATCH(&ret
->u
.var
) = (IDispatch
*)_IDispatchEx_(array
);
1687 /* ECMA-262 3rd Edition 11.1.5 */
1688 HRESULT
property_value_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1690 property_value_expression_t
*expr
= (property_value_expression_t
*)_expr
;
1700 hres
= create_object(ctx
->parser
->script
, NULL
, &obj
);
1704 for(iter
= expr
->property_list
; iter
; iter
= iter
->next
) {
1705 hres
= literal_to_var(iter
->name
, &tmp
);
1709 hres
= to_string(ctx
->parser
->script
, &tmp
, ei
, &name
);
1714 hres
= expr_eval(ctx
, iter
->value
, 0, ei
, &exprval
);
1715 if(SUCCEEDED(hres
)) {
1716 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1717 exprval_release(&exprval
);
1718 if(SUCCEEDED(hres
)) {
1719 hres
= jsdisp_propput_name(obj
, name
, ctx
->parser
->script
->lcid
, &val
, ei
, NULL
/*FIXME*/);
1724 SysFreeString(name
);
1730 jsdisp_release(obj
);
1734 ret
->type
= EXPRVAL_VARIANT
;
1735 V_VT(&ret
->u
.var
) = VT_DISPATCH
;
1736 V_DISPATCH(&ret
->u
.var
) = (IDispatch
*)_IDispatchEx_(obj
);
1740 /* ECMA-262 3rd Edition 11.14 */
1741 HRESULT
comma_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1743 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1749 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
1753 VariantClear(&lval
);
1755 ret
->type
= EXPRVAL_VARIANT
;
1760 /* ECMA-262 3rd Edition 11.11 */
1761 HRESULT
logical_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1763 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1771 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1775 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1776 exprval_release(&exprval
);
1780 hres
= to_boolean(&val
, &b
);
1781 if(SUCCEEDED(hres
) && b
) {
1782 ret
->type
= EXPRVAL_VARIANT
;
1791 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1795 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1796 exprval_release(&exprval
);
1800 ret
->type
= EXPRVAL_VARIANT
;
1805 /* ECMA-262 3rd Edition 11.11 */
1806 HRESULT
logical_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1808 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1816 hres
= expr_eval(ctx
, expr
->expression1
, 0, ei
, &exprval
);
1820 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1821 exprval_release(&exprval
);
1825 hres
= to_boolean(&val
, &b
);
1826 if(SUCCEEDED(hres
) && !b
) {
1827 ret
->type
= EXPRVAL_VARIANT
;
1836 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprval
);
1840 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
1841 exprval_release(&exprval
);
1845 ret
->type
= EXPRVAL_VARIANT
;
1850 /* ECMA-262 3rd Edition 11.10 */
1851 static HRESULT
bitor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1856 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1860 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1869 /* ECMA-262 3rd Edition 11.10 */
1870 HRESULT
binary_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1872 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1876 return binary_expr_eval(ctx
, expr
, bitor_eval
, ei
, ret
);
1879 /* ECMA-262 3rd Edition 11.10 */
1880 static HRESULT
xor_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1885 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1889 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1898 /* ECMA-262 3rd Edition 11.10 */
1899 HRESULT
binary_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1901 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1905 return binary_expr_eval(ctx
, expr
, xor_eval
, ei
, ret
);
1908 /* ECMA-262 3rd Edition 11.10 */
1909 static HRESULT
bitand_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1914 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
1918 hres
= to_int32(ctx
->parser
->script
, rval
, ei
, &ri
);
1927 /* ECMA-262 3rd Edition 11.10 */
1928 HRESULT
binary_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1930 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
1934 return binary_expr_eval(ctx
, expr
, bitand_eval
, ei
, ret
);
1937 /* ECMA-262 3rd Edition 11.8.6 */
1938 HRESULT
instanceof_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1944 /* ECMA-262 3rd Edition 11.8.7 */
1945 HRESULT
in_expression_eval(exec_ctx_t
*ctx
, expression_t
*expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
1951 /* ECMA-262 3rd Edition 11.6.1 */
1952 static HRESULT
add_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
1957 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
, NO_HINT
);
1961 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
, NO_HINT
);
1967 if(V_VT(&l
) == VT_BSTR
|| V_VT(&r
) == VT_BSTR
) {
1968 BSTR lstr
= NULL
, rstr
= NULL
;
1970 if(V_VT(&l
) == VT_BSTR
)
1973 hres
= to_string(ctx
->parser
->script
, &l
, ei
, &lstr
);
1975 if(SUCCEEDED(hres
)) {
1976 if(V_VT(&r
) == VT_BSTR
)
1979 hres
= to_string(ctx
->parser
->script
, &r
, ei
, &rstr
);
1982 if(SUCCEEDED(hres
)) {
1985 len1
= SysStringLen(lstr
);
1986 len2
= SysStringLen(rstr
);
1988 V_VT(retv
) = VT_BSTR
;
1989 V_BSTR(retv
) = SysAllocStringLen(NULL
, len1
+len2
);
1990 memcpy(V_BSTR(retv
), lstr
, len1
*sizeof(WCHAR
));
1991 memcpy(V_BSTR(retv
)+len1
, rstr
, (len2
+1)*sizeof(WCHAR
));
1994 if(V_VT(&l
) != VT_BSTR
)
1995 SysFreeString(lstr
);
1996 if(V_VT(&r
) != VT_BSTR
)
1997 SysFreeString(rstr
);
2001 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &nl
);
2002 if(SUCCEEDED(hres
)) {
2003 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &nr
);
2005 num_set_val(retv
, num_val(&nl
) + num_val(&nr
));
2014 /* ECMA-262 3rd Edition 11.6.1 */
2015 HRESULT
add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2017 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2021 return binary_expr_eval(ctx
, expr
, add_eval
, ei
, ret
);
2024 /* ECMA-262 3rd Edition 11.6.2 */
2025 static HRESULT
sub_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2030 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2034 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2038 num_set_val(retv
, num_val(&lnum
) - num_val(&rnum
));
2042 /* ECMA-262 3rd Edition 11.6.2 */
2043 HRESULT
sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2045 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2049 return binary_expr_eval(ctx
, expr
, sub_eval
, ei
, ret
);
2052 /* ECMA-262 3rd Edition 11.5.1 */
2053 static HRESULT
mul_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2058 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2062 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2066 num_set_val(retv
, num_val(&lnum
) * num_val(&rnum
));
2070 /* ECMA-262 3rd Edition 11.5.1 */
2071 HRESULT
mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2073 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2077 return binary_expr_eval(ctx
, expr
, mul_eval
, ei
, ret
);
2080 /* ECMA-262 3rd Edition 11.5.2 */
2081 static HRESULT
div_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2086 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2090 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2094 num_set_val(retv
, num_val(&lnum
) / num_val(&rnum
));
2098 /* ECMA-262 3rd Edition 11.5.2 */
2099 HRESULT
div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2101 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2105 return binary_expr_eval(ctx
, expr
, div_eval
, ei
, ret
);
2108 /* ECMA-262 3rd Edition 11.5.3 */
2109 static HRESULT
mod_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2114 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &lnum
);
2118 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &rnum
);
2122 num_set_val(retv
, fmod(num_val(&lnum
), num_val(&rnum
)));
2126 /* ECMA-262 3rd Edition 11.5.3 */
2127 HRESULT
mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2129 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2133 return binary_expr_eval(ctx
, expr
, mod_eval
, ei
, ret
);
2136 /* ECMA-262 3rd Edition 11.4.2 */
2137 HRESULT
delete_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2139 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2140 VARIANT_BOOL b
= VARIANT_FALSE
;
2146 hres
= expr_eval(ctx
, expr
->expression
, EXPR_STRREF
, ei
, &exprval
);
2150 switch(exprval
.type
) {
2151 case EXPRVAL_IDREF
: {
2152 IDispatchEx
*dispex
;
2154 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2155 if(SUCCEEDED(hres
)) {
2156 hres
= IDispatchEx_DeleteMemberByDispID(dispex
, exprval
.u
.idref
.id
);
2158 IDispatchEx_Release(dispex
);
2162 case EXPRVAL_NAMEREF
: {
2163 IDispatchEx
*dispex
;
2165 hres
= IDispatch_QueryInterface(exprval
.u
.nameref
.disp
, &IID_IDispatchEx
, (void**)&dispex
);
2166 if(SUCCEEDED(hres
)) {
2167 hres
= IDispatchEx_DeleteMemberByName(dispex
, exprval
.u
.nameref
.name
, fdexNameCaseSensitive
);
2169 IDispatchEx_Release(dispex
);
2174 FIXME("unsupported type %d\n", exprval
.type
);
2178 exprval_release(&exprval
);
2182 return return_bool(ret
, b
);
2185 /* ECMA-262 3rd Edition 11.4.2 */
2186 HRESULT
void_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2188 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2195 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2199 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &tmp
);
2200 exprval_release(&exprval
);
2206 ret
->type
= EXPRVAL_VARIANT
;
2207 V_VT(&ret
->u
.var
) = VT_EMPTY
;
2211 /* ECMA-262 3rd Edition 11.4.3 */
2212 HRESULT
typeof_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2214 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2220 static const WCHAR booleanW
[] = {'b','o','o','l','e','a','n',0};
2221 static const WCHAR functionW
[] = {'f','u','n','c','t','i','o','n',0};
2222 static const WCHAR numberW
[] = {'n','u','m','b','e','r',0};
2223 static const WCHAR objectW
[] = {'o','b','j','e','c','t',0};
2224 static const WCHAR stringW
[] = {'s','t','r','i','n','g',0};
2225 static const WCHAR undefinedW
[] = {'u','n','d','e','f','i','n','e','d',0};
2229 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2233 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2234 exprval_release(&exprval
);
2238 switch(V_VT(&val
)) {
2258 dispex
= iface_to_jsdisp((IUnknown
*)V_DISPATCH(&val
));
2260 str
= dispex
->builtin_info
->class == JSCLASS_FUNCTION
? functionW
: objectW
;
2261 IDispatchEx_Release(_IDispatchEx_(dispex
));
2268 FIXME("unhandled vt %d\n", V_VT(&val
));
2275 ret
->type
= EXPRVAL_VARIANT
;
2276 V_VT(&ret
->u
.var
) = VT_BSTR
;
2277 V_BSTR(&ret
->u
.var
) = SysAllocString(str
);
2281 /* ECMA-262 3rd Edition 11.4.7 */
2282 HRESULT
minus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2284 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2291 hres
= expr_eval(ctx
, expr
->expression
, 0, ei
, &exprval
);
2295 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2296 exprval_release(&exprval
);
2300 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2305 ret
->type
= EXPRVAL_VARIANT
;
2306 num_set_val(&ret
->u
.var
, -num_val(&num
));
2310 /* ECMA-262 3rd Edition 11.4.6 */
2311 HRESULT
plus_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2313 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2320 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2324 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2325 exprval_release(&exprval
);
2329 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2333 ret
->type
= EXPRVAL_VARIANT
;
2338 /* ECMA-262 3rd Edition 11.3.1 */
2339 HRESULT
post_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2341 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2348 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2352 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2353 if(SUCCEEDED(hres
)) {
2354 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2358 if(SUCCEEDED(hres
)) {
2360 num_set_val(&inc
, num_val(&num
)+1.0);
2361 hres
= put_value(ctx
->parser
->script
, &exprval
, &inc
, ei
);
2364 exprval_release(&exprval
);
2368 ret
->type
= EXPRVAL_VARIANT
;
2373 /* ECMA-262 3rd Edition 11.3.2 */
2374 HRESULT
post_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2376 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2383 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2387 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2388 if(SUCCEEDED(hres
)) {
2389 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2393 if(SUCCEEDED(hres
)) {
2395 num_set_val(&dec
, num_val(&num
)-1.0);
2396 hres
= put_value(ctx
->parser
->script
, &exprval
, &dec
, ei
);
2399 exprval_release(&exprval
);
2403 ret
->type
= EXPRVAL_VARIANT
;
2408 /* ECMA-262 3rd Edition 11.4.4 */
2409 HRESULT
pre_increment_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2411 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2418 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2422 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2423 if(SUCCEEDED(hres
)) {
2424 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2428 if(SUCCEEDED(hres
)) {
2429 num_set_val(&val
, num_val(&num
)+1.0);
2430 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2433 exprval_release(&exprval
);
2437 ret
->type
= EXPRVAL_VARIANT
;
2442 /* ECMA-262 3rd Edition 11.4.5 */
2443 HRESULT
pre_decrement_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2445 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2452 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2456 hres
= exprval_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2457 if(SUCCEEDED(hres
)) {
2458 hres
= to_number(ctx
->parser
->script
, &val
, ei
, &num
);
2462 if(SUCCEEDED(hres
)) {
2463 num_set_val(&val
, num_val(&num
)-1.0);
2464 hres
= put_value(ctx
->parser
->script
, &exprval
, &val
, ei
);
2467 exprval_release(&exprval
);
2471 ret
->type
= EXPRVAL_VARIANT
;
2476 /* ECMA-262 3rd Edition 11.9.3 */
2477 static HRESULT
equal_values(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, BOOL
*ret
)
2479 if(V_VT(lval
) == V_VT(rval
) || (is_num_vt(V_VT(lval
)) && is_num_vt(V_VT(rval
))))
2480 return equal2_values(lval
, rval
, ret
);
2482 /* FIXME: NULL disps should be handled in more general way */
2483 if(V_VT(lval
) == VT_DISPATCH
&& !V_DISPATCH(lval
)) {
2486 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2489 if(V_VT(rval
) == VT_DISPATCH
&& !V_DISPATCH(rval
)) {
2492 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2495 if((V_VT(lval
) == VT_NULL
&& V_VT(rval
) == VT_EMPTY
) ||
2496 (V_VT(lval
) == VT_EMPTY
&& V_VT(rval
) == VT_NULL
)) {
2501 if(V_VT(lval
) == VT_BSTR
&& is_num_vt(V_VT(rval
))) {
2505 hres
= to_number(ctx
->parser
->script
, lval
, ei
, &v
);
2509 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2512 if(V_VT(rval
) == VT_BSTR
&& is_num_vt(V_VT(lval
))) {
2516 hres
= to_number(ctx
->parser
->script
, rval
, ei
, &v
);
2520 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2523 if(V_VT(rval
) == VT_BOOL
) {
2527 V_I4(&v
) = V_BOOL(rval
) ? 1 : 0;
2528 return equal_values(ctx
, lval
, &v
, ei
, ret
);
2531 if(V_VT(lval
) == VT_BOOL
) {
2535 V_I4(&v
) = V_BOOL(lval
) ? 1 : 0;
2536 return equal_values(ctx
, &v
, rval
, ei
, ret
);
2540 if(V_VT(rval
) == VT_DISPATCH
&& (V_VT(lval
) == VT_BSTR
|| is_num_vt(V_VT(lval
)))) {
2544 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &v
, NO_HINT
);
2548 hres
= equal_values(ctx
, lval
, &v
, ei
, ret
);
2555 if(V_VT(lval
) == VT_DISPATCH
&& (V_VT(rval
) == VT_BSTR
|| is_num_vt(V_VT(rval
)))) {
2559 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &v
, NO_HINT
);
2563 hres
= equal_values(ctx
, &v
, rval
, ei
, ret
);
2574 /* ECMA-262 3rd Edition 11.9.1 */
2575 HRESULT
equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2577 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2584 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2588 hres
= equal_values(ctx
, &rval
, &lval
, ei
, &b
);
2592 return return_bool(ret
, b
);
2595 /* ECMA-262 3rd Edition 11.9.4 */
2596 HRESULT
equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2598 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2605 hres
= get_binary_expr_values(ctx
, expr
, ei
, &rval
, &lval
);
2609 hres
= equal2_values(&rval
, &lval
, &b
);
2613 return return_bool(ret
, b
);
2616 /* ECMA-262 3rd Edition 11.9.2 */
2617 HRESULT
not_equal_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2619 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2626 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2630 hres
= equal_values(ctx
, &lval
, &rval
, ei
, &b
);
2634 return return_bool(ret
, !b
);
2637 /* ECMA-262 3rd Edition 11.9.5 */
2638 HRESULT
not_equal2_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2640 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2647 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2651 hres
= equal2_values(&lval
, &rval
, &b
);
2655 return return_bool(ret
, !b
);
2658 /* ECMA-262 3rd Edition 11.8.5 */
2659 static HRESULT
less_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, BOOL greater
, jsexcept_t
*ei
, BOOL
*ret
)
2661 VARIANT l
, r
, ln
, rn
;
2664 hres
= to_primitive(ctx
->parser
->script
, lval
, ei
, &l
, NO_HINT
);
2668 hres
= to_primitive(ctx
->parser
->script
, rval
, ei
, &r
, NO_HINT
);
2674 if(V_VT(&l
) == VT_BSTR
&& V_VT(&r
) == VT_BSTR
) {
2675 *ret
= (strcmpW(V_BSTR(&l
), V_BSTR(&r
)) < 0) ^ greater
;
2676 SysFreeString(V_BSTR(&l
));
2677 SysFreeString(V_BSTR(&r
));
2681 hres
= to_number(ctx
->parser
->script
, &l
, ei
, &ln
);
2684 hres
= to_number(ctx
->parser
->script
, &r
, ei
, &rn
);
2689 if(V_VT(&ln
) == VT_I4
&& V_VT(&rn
) == VT_I4
) {
2690 *ret
= (V_I4(&ln
) < V_I4(&rn
)) ^ greater
;
2692 DOUBLE ld
= num_val(&ln
);
2693 DOUBLE rd
= num_val(&rn
);
2695 *ret
= !isnan(ld
) && !isnan(rd
) && ((ld
< rd
) ^ greater
);
2701 /* ECMA-262 3rd Edition 11.8.1 */
2702 HRESULT
less_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
, &lval
, &rval
, FALSE
, ei
, &b
);
2716 VariantClear(&lval
);
2717 VariantClear(&rval
);
2721 return return_bool(ret
, b
);
2724 /* ECMA-262 3rd Edition 11.8.3 */
2725 HRESULT
lesseq_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
, &rval
, &lval
, TRUE
, ei
, &b
);
2739 VariantClear(&lval
);
2740 VariantClear(&rval
);
2744 return return_bool(ret
, b
);
2747 /* ECMA-262 3rd Edition 11.8.2 */
2748 HRESULT
greater_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2750 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2757 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2761 hres
= less_eval(ctx
, &rval
, &lval
, FALSE
, ei
, &b
);
2762 VariantClear(&lval
);
2763 VariantClear(&rval
);
2767 return return_bool(ret
, b
);
2770 /* ECMA-262 3rd Edition 11.8.4 */
2771 HRESULT
greatereq_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2773 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2780 hres
= get_binary_expr_values(ctx
, expr
, ei
, &lval
, &rval
);
2784 hres
= less_eval(ctx
, &lval
, &rval
, TRUE
, ei
, &b
);
2785 VariantClear(&lval
);
2786 VariantClear(&rval
);
2790 return return_bool(ret
, b
);
2793 /* ECMA-262 3rd Edition 11.4.8 */
2794 HRESULT
binary_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2796 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2804 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2808 hres
= exprval_to_value(ctx
->parser
->script
, &exprval
, ei
, &val
);
2809 exprval_release(&exprval
);
2813 hres
= to_int32(ctx
->parser
->script
, &val
, ei
, &i
);
2817 ret
->type
= EXPRVAL_VARIANT
;
2818 V_VT(&ret
->u
.var
) = VT_I4
;
2819 V_I4(&ret
->u
.var
) = ~i
;
2823 /* ECMA-262 3rd Edition 11.4.9 */
2824 HRESULT
logical_negation_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2826 unary_expression_t
*expr
= (unary_expression_t
*)_expr
;
2833 hres
= expr_eval(ctx
, expr
->expression
, EXPR_NEWREF
, ei
, &exprval
);
2837 hres
= exprval_to_boolean(ctx
->parser
->script
, &exprval
, ei
, &b
);
2838 exprval_release(&exprval
);
2842 return return_bool(ret
, !b
);
2845 /* ECMA-262 3rd Edition 11.7.1 */
2846 static HRESULT
lshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2852 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
2856 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2861 V_I4(retv
) = li
<< (ri
&0x1f);
2865 /* ECMA-262 3rd Edition 11.7.1 */
2866 HRESULT
left_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2868 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2872 return binary_expr_eval(ctx
, expr
, lshift_eval
, ei
, ret
);
2875 /* ECMA-262 3rd Edition 11.7.2 */
2876 static HRESULT
rshift_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2882 hres
= to_int32(ctx
->parser
->script
, lval
, ei
, &li
);
2886 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2891 V_I4(retv
) = li
>> (ri
&0x1f);
2895 /* ECMA-262 3rd Edition 11.7.2 */
2896 HRESULT
right_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2898 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2902 return binary_expr_eval(ctx
, expr
, rshift_eval
, ei
, ret
);
2905 /* ECMA-262 3rd Edition 11.7.3 */
2906 static HRESULT
rshift2_eval(exec_ctx_t
*ctx
, VARIANT
*lval
, VARIANT
*rval
, jsexcept_t
*ei
, VARIANT
*retv
)
2911 hres
= to_uint32(ctx
->parser
->script
, lval
, ei
, &li
);
2915 hres
= to_uint32(ctx
->parser
->script
, rval
, ei
, &ri
);
2920 V_I4(retv
) = li
>> (ri
&0x1f);
2924 /* ECMA-262 3rd Edition 11.7.3 */
2925 HRESULT
right2_shift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2927 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2931 return binary_expr_eval(ctx
, expr
, rshift2_eval
, ei
, ret
);
2934 /* ECMA-262 3rd Edition 11.13.1 */
2935 HRESULT
assign_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2937 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2938 exprval_t exprval
, exprvalr
;
2944 hres
= expr_eval(ctx
, expr
->expression1
, EXPR_NEWREF
, ei
, &exprval
);
2948 hres
= expr_eval(ctx
, expr
->expression2
, 0, ei
, &exprvalr
);
2949 if(SUCCEEDED(hres
)) {
2950 hres
= exprval_to_value(ctx
->parser
->script
, &exprvalr
, ei
, &rval
);
2951 exprval_release(&exprvalr
);
2955 hres
= put_value(ctx
->parser
->script
, &exprval
, &rval
, ei
);
2957 exprval_release(&exprval
);
2961 ret
->type
= EXPRVAL_VARIANT
;
2966 /* ECMA-262 3rd Edition 11.13.2 */
2967 HRESULT
assign_lshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2969 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2973 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, lshift_eval
, ei
, ret
);
2976 /* ECMA-262 3rd Edition 11.13.2 */
2977 HRESULT
assign_rshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2979 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2983 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift_eval
, ei
, ret
);
2986 /* ECMA-262 3rd Edition 11.13.2 */
2987 HRESULT
assign_rrshift_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2989 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
2993 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, rshift2_eval
, ei
, ret
);
2996 /* ECMA-262 3rd Edition 11.13.2 */
2997 HRESULT
assign_add_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
2999 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3003 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, add_eval
, ei
, ret
);
3006 /* ECMA-262 3rd Edition 11.13.2 */
3007 HRESULT
assign_sub_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3009 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3013 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, sub_eval
, ei
, ret
);
3016 /* ECMA-262 3rd Edition 11.13.2 */
3017 HRESULT
assign_mul_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3019 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3023 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mul_eval
, ei
, ret
);
3026 /* ECMA-262 3rd Edition 11.13.2 */
3027 HRESULT
assign_div_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3029 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3033 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, div_eval
, ei
, ret
);
3036 /* ECMA-262 3rd Edition 11.13.2 */
3037 HRESULT
assign_mod_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3039 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3043 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, mod_eval
, ei
, ret
);
3046 /* ECMA-262 3rd Edition 11.13.2 */
3047 HRESULT
assign_and_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3049 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3053 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitand_eval
, ei
, ret
);
3056 /* ECMA-262 3rd Edition 11.13.2 */
3057 HRESULT
assign_or_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3059 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3063 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, bitor_eval
, ei
, ret
);
3066 /* ECMA-262 3rd Edition 11.13.2 */
3067 HRESULT
assign_xor_expression_eval(exec_ctx_t
*ctx
, expression_t
*_expr
, DWORD flags
, jsexcept_t
*ei
, exprval_t
*ret
)
3069 binary_expression_t
*expr
= (binary_expression_t
*)_expr
;
3073 return assign_oper_eval(ctx
, expr
->expression1
, expr
->expression2
, xor_eval
, ei
, ret
);