2 * Copyright 2011 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
25 #include "wine/debug.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
28 WINE_DECLARE_DEBUG_CHANNEL(jscript_disas);
30 typedef struct _statement_ctx_t {
36 unsigned continue_label;
38 const labelled_statement_t *labelled_stat;
40 struct _statement_ctx_t *next;
56 statement_ctx_t *stat_ctx;
57 function_code_t *func;
59 variable_declaration_t *var_head;
60 variable_declaration_t *var_tail;
62 function_expression_t *func_head;
63 function_expression_t *func_tail;
68 instr_arg_type_t arg1_type;
69 instr_arg_type_t arg2_type;
71 #define X(n,a,b,c) {#n,b,c},
76 static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg)
80 TRACE_(jscript_disas)("\t%s", debugstr_jsstr(arg->str));
83 TRACE_(jscript_disas)("\t%s", debugstr_wn(arg->bstr, SysStringLen(arg->bstr)));
86 TRACE_(jscript_disas)("\t%d", arg->uint);
90 TRACE_(jscript_disas)("\t%u", arg->uint);
100 static void dump_code(compiler_ctx_t *ctx, unsigned off)
104 for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->code_off; instr++) {
105 TRACE_(jscript_disas)("%d:\t%s", (int)(instr-ctx->code->instrs), instr_info[instr->op].op_str);
106 if(instr_info[instr->op].arg1_type == ARG_DBL) {
107 TRACE_(jscript_disas)("\t%lf", instr->u.dbl);
109 dump_instr_arg(instr_info[instr->op].arg1_type, instr->u.arg);
110 dump_instr_arg(instr_info[instr->op].arg2_type, instr->u.arg+1);
112 TRACE_(jscript_disas)("\n");
116 static HRESULT compile_expression(compiler_ctx_t*,expression_t*,BOOL);
117 static HRESULT compile_statement(compiler_ctx_t*,statement_ctx_t*,statement_t*);
119 static inline void *compiler_alloc(bytecode_t *code, size_t size)
121 return jsheap_alloc(&code->heap, size);
124 static jsstr_t *compiler_alloc_string_len(compiler_ctx_t *ctx, const WCHAR *str, unsigned len)
128 if(!ctx->code->str_pool_size) {
129 ctx->code->str_pool = heap_alloc(8 * sizeof(jsstr_t*));
130 if(!ctx->code->str_pool)
132 ctx->code->str_pool_size = 8;
133 }else if(ctx->code->str_pool_size == ctx->code->str_cnt) {
136 new_pool = heap_realloc(ctx->code->str_pool, ctx->code->str_pool_size*2*sizeof(jsstr_t*));
140 ctx->code->str_pool = new_pool;
141 ctx->code->str_pool_size *= 2;
144 new_str = jsstr_alloc_len(str, len);
148 ctx->code->str_pool[ctx->code->str_cnt++] = new_str;
152 static jsstr_t *compiler_alloc_string(compiler_ctx_t *ctx, const WCHAR *str)
154 return compiler_alloc_string_len(ctx, str, strlenW(str));
157 static BOOL ensure_bstr_slot(compiler_ctx_t *ctx)
159 if(!ctx->code->bstr_pool_size) {
160 ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
161 if(!ctx->code->bstr_pool)
163 ctx->code->bstr_pool_size = 8;
164 }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
167 new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
171 ctx->code->bstr_pool = new_pool;
172 ctx->code->bstr_pool_size *= 2;
178 static BSTR compiler_alloc_bstr(compiler_ctx_t *ctx, const WCHAR *str)
180 if(!ensure_bstr_slot(ctx))
183 ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
184 if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
187 return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
190 static BSTR compiler_alloc_bstr_len(compiler_ctx_t *ctx, const WCHAR *str, size_t len)
192 if(!ensure_bstr_slot(ctx))
195 ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocStringLen(str, len);
196 if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
199 return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
202 static unsigned push_instr(compiler_ctx_t *ctx, jsop_t op)
204 assert(ctx->code_size >= ctx->code_off);
206 if(ctx->code_size == ctx->code_off) {
209 new_instrs = heap_realloc(ctx->code->instrs, ctx->code_size*2*sizeof(instr_t));
213 ctx->code->instrs = new_instrs;
217 ctx->code->instrs[ctx->code_off].op = op;
218 return ctx->code_off++;
221 static inline instr_t *instr_ptr(compiler_ctx_t *ctx, unsigned off)
223 assert(off < ctx->code_off);
224 return ctx->code->instrs + off;
227 static HRESULT push_instr_int(compiler_ctx_t *ctx, jsop_t op, LONG arg)
231 instr = push_instr(ctx, op);
233 return E_OUTOFMEMORY;
235 instr_ptr(ctx, instr)->u.arg->lng = arg;
239 static HRESULT push_instr_str(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
244 str = compiler_alloc_string(ctx, arg);
246 return E_OUTOFMEMORY;
248 instr = push_instr(ctx, op);
250 return E_OUTOFMEMORY;
252 instr_ptr(ctx, instr)->u.arg->str = str;
256 static HRESULT push_instr_bstr(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
261 str = compiler_alloc_bstr(ctx, arg);
263 return E_OUTOFMEMORY;
265 instr = push_instr(ctx, op);
267 return E_OUTOFMEMORY;
269 instr_ptr(ctx, instr)->u.arg->bstr = str;
273 static HRESULT push_instr_bstr_uint(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg1, unsigned arg2)
278 str = compiler_alloc_bstr(ctx, arg1);
280 return E_OUTOFMEMORY;
282 instr = push_instr(ctx, op);
284 return E_OUTOFMEMORY;
286 instr_ptr(ctx, instr)->u.arg[0].bstr = str;
287 instr_ptr(ctx, instr)->u.arg[1].uint = arg2;
291 static HRESULT push_instr_uint_str(compiler_ctx_t *ctx, jsop_t op, unsigned arg1, const WCHAR *arg2)
296 str = compiler_alloc_string(ctx, arg2);
298 return E_OUTOFMEMORY;
300 instr = push_instr(ctx, op);
302 return E_OUTOFMEMORY;
304 instr_ptr(ctx, instr)->u.arg[0].uint = arg1;
305 instr_ptr(ctx, instr)->u.arg[1].str = str;
309 static HRESULT push_instr_double(compiler_ctx_t *ctx, jsop_t op, double arg)
313 instr = push_instr(ctx, op);
315 return E_OUTOFMEMORY;
317 instr_ptr(ctx, instr)->u.dbl = arg;
321 static inline void set_arg_uint(compiler_ctx_t *ctx, unsigned instr, unsigned arg)
323 instr_ptr(ctx, instr)->u.arg->uint = arg;
326 static HRESULT push_instr_uint(compiler_ctx_t *ctx, jsop_t op, unsigned arg)
330 instr = push_instr(ctx, op);
332 return E_OUTOFMEMORY;
334 set_arg_uint(ctx, instr, arg);
338 static HRESULT compile_binary_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
342 hres = compile_expression(ctx, expr->expression1, TRUE);
346 hres = compile_expression(ctx, expr->expression2, TRUE);
350 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
353 static HRESULT compile_unary_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op)
357 hres = compile_expression(ctx, expr->expression, TRUE);
361 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
364 /* ECMA-262 3rd Edition 11.2.1 */
365 static HRESULT compile_member_expression(compiler_ctx_t *ctx, member_expression_t *expr)
369 hres = compile_expression(ctx, expr->expression, TRUE);
373 return push_instr_bstr(ctx, OP_member, expr->identifier);
376 #define LABEL_FLAG 0x80000000
378 static unsigned alloc_label(compiler_ctx_t *ctx)
380 if(!ctx->labels_size) {
381 ctx->labels = heap_alloc(8 * sizeof(*ctx->labels));
384 ctx->labels_size = 8;
385 }else if(ctx->labels_size == ctx->labels_cnt) {
386 unsigned *new_labels;
388 new_labels = heap_realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
392 ctx->labels = new_labels;
393 ctx->labels_size *= 2;
396 return ctx->labels_cnt++ | LABEL_FLAG;
399 static void label_set_addr(compiler_ctx_t *ctx, unsigned label)
401 assert(label & LABEL_FLAG);
402 ctx->labels[label & ~LABEL_FLAG] = ctx->code_off;
405 static inline BOOL is_memberid_expr(expression_type_t type)
407 return type == EXPR_IDENT || type == EXPR_MEMBER || type == EXPR_ARRAY;
410 static HRESULT compile_memberid_expression(compiler_ctx_t *ctx, expression_t *expr, unsigned flags)
416 identifier_expression_t *ident_expr = (identifier_expression_t*)expr;
418 hres = push_instr_bstr_uint(ctx, OP_identid, ident_expr->identifier, flags);
422 binary_expression_t *array_expr = (binary_expression_t*)expr;
424 hres = compile_expression(ctx, array_expr->expression1, TRUE);
428 hres = compile_expression(ctx, array_expr->expression2, TRUE);
432 hres = push_instr_uint(ctx, OP_memberid, flags);
436 member_expression_t *member_expr = (member_expression_t*)expr;
438 hres = compile_expression(ctx, member_expr->expression, TRUE);
442 /* FIXME: Potential optimization */
443 hres = push_instr_str(ctx, OP_str, member_expr->identifier);
447 hres = push_instr_uint(ctx, OP_memberid, flags);
457 static HRESULT compile_increment_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op, int n)
461 if(!is_memberid_expr(expr->expression->type)) {
462 hres = compile_expression(ctx, expr->expression, TRUE);
466 return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
469 hres = compile_memberid_expression(ctx, expr->expression, fdexNameEnsure);
473 return push_instr_int(ctx, op, n);
476 /* ECMA-262 3rd Edition 11.14 */
477 static HRESULT compile_comma_expression(compiler_ctx_t *ctx, binary_expression_t *expr, BOOL emit_ret)
481 hres = compile_expression(ctx, expr->expression1, FALSE);
485 return compile_expression(ctx, expr->expression2, emit_ret);
488 /* ECMA-262 3rd Edition 11.11 */
489 static HRESULT compile_logical_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
494 hres = compile_expression(ctx, expr->expression1, TRUE);
498 instr = push_instr(ctx, op);
500 return E_OUTOFMEMORY;
502 hres = compile_expression(ctx, expr->expression2, TRUE);
506 set_arg_uint(ctx, instr, ctx->code_off);
510 /* ECMA-262 3rd Edition 11.12 */
511 static HRESULT compile_conditional_expression(compiler_ctx_t *ctx, conditional_expression_t *expr)
513 unsigned jmp_false, jmp_end;
516 hres = compile_expression(ctx, expr->expression, TRUE);
520 jmp_false = push_instr(ctx, OP_cnd_z);
522 return E_OUTOFMEMORY;
524 hres = compile_expression(ctx, expr->true_expression, TRUE);
528 jmp_end = push_instr(ctx, OP_jmp);
530 return E_OUTOFMEMORY;
532 set_arg_uint(ctx, jmp_false, ctx->code_off);
533 hres = push_instr_uint(ctx, OP_pop, 1);
537 hres = compile_expression(ctx, expr->false_expression, TRUE);
541 set_arg_uint(ctx, jmp_end, ctx->code_off);
545 static HRESULT compile_new_expression(compiler_ctx_t *ctx, call_expression_t *expr)
547 unsigned arg_cnt = 0;
551 hres = compile_expression(ctx, expr->expression, TRUE);
555 for(arg = expr->argument_list; arg; arg = arg->next) {
556 hres = compile_expression(ctx, arg->expr, TRUE);
562 return push_instr_uint(ctx, OP_new, arg_cnt);
565 static HRESULT compile_call_expression(compiler_ctx_t *ctx, call_expression_t *expr, BOOL emit_ret)
567 unsigned arg_cnt = 0;
573 if(is_memberid_expr(expr->expression->type)) {
575 hres = compile_memberid_expression(ctx, expr->expression, 0);
578 hres = compile_expression(ctx, expr->expression, TRUE);
584 for(arg = expr->argument_list; arg; arg = arg->next) {
585 hres = compile_expression(ctx, arg->expr, TRUE);
591 instr = push_instr(ctx, op);
593 return E_OUTOFMEMORY;
595 instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
596 instr_ptr(ctx, instr)->u.arg[1].lng = emit_ret;
600 static HRESULT compile_delete_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
604 switch(expr->expression->type) {
606 binary_expression_t *array_expr = (binary_expression_t*)expr->expression;
608 hres = compile_expression(ctx, array_expr->expression1, TRUE);
612 hres = compile_expression(ctx, array_expr->expression2, TRUE);
616 if(!push_instr(ctx, OP_delete))
617 return E_OUTOFMEMORY;
621 member_expression_t *member_expr = (member_expression_t*)expr->expression;
623 hres = compile_expression(ctx, member_expr->expression, TRUE);
627 /* FIXME: Potential optimization */
628 hres = push_instr_str(ctx, OP_str, member_expr->identifier);
632 if(!push_instr(ctx, OP_delete))
633 return E_OUTOFMEMORY;
637 return push_instr_bstr(ctx, OP_delete_ident, ((identifier_expression_t*)expr->expression)->identifier);
639 const WCHAR fixmeW[] = {'F','I','X','M','E',0};
641 WARN("invalid delete, unimplemented exception message\n");
643 hres = compile_expression(ctx, expr->expression, TRUE);
647 return push_instr_uint_str(ctx, OP_throw_type, JS_E_INVALID_DELETE, fixmeW);
654 static HRESULT compile_assign_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
656 BOOL use_throw_path = FALSE;
657 unsigned arg_cnt = 0;
660 if(expr->expression1->type == EXPR_CALL) {
661 call_expression_t *call_expr = (call_expression_t*)expr->expression1;
665 FIXME("op %d not supported on parametrized assign expressions\n", op);
669 if(is_memberid_expr(call_expr->expression->type) && call_expr->argument_list) {
670 hres = compile_memberid_expression(ctx, call_expr->expression, fdexNameEnsure);
674 for(arg = call_expr->argument_list; arg; arg = arg->next) {
675 hres = compile_expression(ctx, arg->expr, TRUE);
681 use_throw_path = TRUE;
683 }else if(is_memberid_expr(expr->expression1->type)) {
684 hres = compile_memberid_expression(ctx, expr->expression1, fdexNameEnsure);
688 use_throw_path = TRUE;
692 /* Illegal assignment: evaluate and throw */
693 hres = compile_expression(ctx, expr->expression1, TRUE);
697 hres = compile_expression(ctx, expr->expression2, TRUE);
701 if(op != OP_LAST && !push_instr(ctx, op))
702 return E_OUTOFMEMORY;
704 return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
707 if(op != OP_LAST && !push_instr(ctx, OP_refval))
708 return E_OUTOFMEMORY;
710 hres = compile_expression(ctx, expr->expression2, TRUE);
714 if(op != OP_LAST && !push_instr(ctx, op))
715 return E_OUTOFMEMORY;
718 return push_instr_uint(ctx, OP_assign_call, arg_cnt);
720 if(!push_instr(ctx, OP_assign))
721 return E_OUTOFMEMORY;
726 static HRESULT compile_typeof_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
731 if(is_memberid_expr(expr->expression->type)) {
732 if(expr->expression->type == EXPR_IDENT)
733 return push_instr_bstr(ctx, OP_typeofident, ((identifier_expression_t*)expr->expression)->identifier);
736 hres = compile_memberid_expression(ctx, expr->expression, 0);
739 hres = compile_expression(ctx, expr->expression, TRUE);
744 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
747 static HRESULT compile_literal(compiler_ctx_t *ctx, literal_t *literal)
749 switch(literal->type) {
751 return push_instr_int(ctx, OP_bool, literal->u.bval);
753 return push_instr_double(ctx, OP_double, literal->u.dval);
755 return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
757 return push_instr_str(ctx, OP_str, literal->u.wstr);
762 str = compiler_alloc_string_len(ctx, literal->u.regexp.str, literal->u.regexp.str_len);
764 return E_OUTOFMEMORY;
766 instr = push_instr(ctx, OP_regexp);
768 return E_OUTOFMEMORY;
770 instr_ptr(ctx, instr)->u.arg[0].str = str;
771 instr_ptr(ctx, instr)->u.arg[1].uint = literal->u.regexp.flags;
780 static HRESULT literal_as_bstr(compiler_ctx_t *ctx, literal_t *literal, BSTR *str)
782 switch(literal->type) {
784 *str = compiler_alloc_bstr(ctx, literal->u.wstr);
790 hres = double_to_string(literal->u.dval, &jsstr);
794 *str = SysAllocStringLen(jsstr->str, jsstr_length(jsstr));
795 jsstr_release(jsstr);
802 return *str ? S_OK : E_OUTOFMEMORY;
805 static HRESULT compile_array_literal(compiler_ctx_t *ctx, array_literal_expression_t *expr)
807 unsigned i, elem_cnt = expr->length;
808 array_element_t *iter;
811 for(iter = expr->element_list; iter; iter = iter->next) {
812 elem_cnt += iter->elision+1;
814 for(i=0; i < iter->elision; i++) {
815 if(!push_instr(ctx, OP_undefined))
816 return E_OUTOFMEMORY;
819 hres = compile_expression(ctx, iter->expr, TRUE);
824 for(i=0; i < expr->length; i++) {
825 if(!push_instr(ctx, OP_undefined))
826 return E_OUTOFMEMORY;
829 return push_instr_uint(ctx, OP_carray, elem_cnt);
832 static HRESULT compile_object_literal(compiler_ctx_t *ctx, property_value_expression_t *expr)
839 if(!push_instr(ctx, OP_new_obj))
840 return E_OUTOFMEMORY;
842 for(iter = expr->property_list; iter; iter = iter->next) {
843 hres = literal_as_bstr(ctx, iter->name, &name);
847 hres = compile_expression(ctx, iter->value, TRUE);
851 instr = push_instr(ctx, OP_obj_prop);
853 return E_OUTOFMEMORY;
855 instr_ptr(ctx, instr)->u.arg->bstr = name;
861 static HRESULT compile_function_expression(compiler_ctx_t *ctx, function_expression_t *expr)
863 ctx->func_tail = ctx->func_tail ? (ctx->func_tail->next = expr) : (ctx->func_head = expr);
865 /* FIXME: not exactly right */
866 if(expr->identifier) {
867 ctx->func->func_cnt++;
868 return push_instr_bstr(ctx, OP_ident, expr->identifier);
871 return push_instr_uint(ctx, OP_func, ctx->func->func_cnt++);
874 static HRESULT compile_expression(compiler_ctx_t *ctx, expression_t *expr, BOOL emit_ret)
880 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
883 hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_z);
886 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_array);
889 hres = compile_array_literal(ctx, (array_literal_expression_t*)expr);
892 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_LAST);
895 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_add);
898 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_and);
901 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_sub);
904 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mul);
907 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_div);
910 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mod);
913 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_or);
915 case EXPR_ASSIGNLSHIFT:
916 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_lshift);
918 case EXPR_ASSIGNRSHIFT:
919 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift);
921 case EXPR_ASSIGNRRSHIFT:
922 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
925 hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_xor);
928 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
931 hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_bneg);
934 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
937 return compile_call_expression(ctx, (call_expression_t*)expr, emit_ret);
939 return compile_comma_expression(ctx, (binary_expression_t*)expr, emit_ret);
941 hres = compile_conditional_expression(ctx, (conditional_expression_t*)expr);
944 hres = compile_delete_expression(ctx, (unary_expression_t*)expr);
947 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
950 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq);
953 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq2);
956 hres = compile_function_expression(ctx, (function_expression_t*)expr);
959 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
962 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
965 hres = push_instr_bstr(ctx, OP_ident, ((identifier_expression_t*)expr)->identifier);
968 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_in);
970 case EXPR_INSTANCEOF:
971 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_instanceof);
974 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
977 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
980 hres = compile_literal(ctx, ((literal_expression_t*)expr)->literal);
983 hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
986 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lshift);
989 hres = compile_member_expression(ctx, (member_expression_t*)expr);
992 hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_minus);
995 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
998 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
1001 hres = compile_new_expression(ctx, (call_expression_t*)expr);
1004 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq);
1007 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq2);
1010 hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_nz);
1013 hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_tonum);
1016 hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, -1);
1019 hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, 1);
1022 hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, -1);
1025 hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, 1);
1028 hres = compile_object_literal(ctx, (property_value_expression_t*)expr);
1031 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift);
1034 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
1037 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
1040 return !emit_ret || push_instr(ctx, OP_this) ? S_OK : E_OUTOFMEMORY;
1042 hres = compile_typeof_expression(ctx, (unary_expression_t*)expr);
1045 hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_void);
1048 hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
1057 return emit_ret ? S_OK : push_instr_uint(ctx, OP_pop, 1);
1060 static inline BOOL is_loop_statement(statement_type_t type)
1062 return type == STAT_FOR || type == STAT_FORIN || type == STAT_WHILE;
1065 /* ECMA-262 3rd Edition 12.1 */
1066 static HRESULT compile_block_statement(compiler_ctx_t *ctx, statement_t *iter)
1071 hres = compile_statement(ctx, NULL, iter);
1081 /* ECMA-262 3rd Edition 12.2 */
1082 static HRESULT compile_variable_list(compiler_ctx_t *ctx, variable_declaration_t *list)
1084 variable_declaration_t *iter;
1087 assert(list != NULL);
1090 ctx->var_tail->global_next = list;
1092 ctx->var_head = list;
1094 for(iter = list; iter; iter = iter->next) {
1095 ctx->func->var_cnt++;
1096 iter->global_next = iter->next;
1098 ctx->var_tail = iter;
1103 hres = compile_expression(ctx, iter->expr, TRUE);
1107 hres = push_instr_bstr(ctx, OP_var_set, iter->identifier);
1115 /* ECMA-262 3rd Edition 12.2 */
1116 static HRESULT compile_var_statement(compiler_ctx_t *ctx, var_statement_t *stat)
1118 return compile_variable_list(ctx, stat->variable_list);
1121 /* ECMA-262 3rd Edition 12.4 */
1122 static HRESULT compile_expression_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1126 hres = compile_expression(ctx, stat->expr, ctx->from_eval);
1130 return !ctx->from_eval || push_instr(ctx, OP_setret) ? S_OK : E_OUTOFMEMORY;
1133 /* ECMA-262 3rd Edition 12.5 */
1134 static HRESULT compile_if_statement(compiler_ctx_t *ctx, if_statement_t *stat)
1139 hres = compile_expression(ctx, stat->expr, TRUE);
1143 jmp_else = push_instr(ctx, OP_jmp_z);
1145 return E_OUTOFMEMORY;
1147 hres = compile_statement(ctx, NULL, stat->if_stat);
1151 if(stat->else_stat) {
1154 jmp_end = push_instr(ctx, OP_jmp);
1156 return E_OUTOFMEMORY;
1158 set_arg_uint(ctx, jmp_else, ctx->code_off);
1160 hres = compile_statement(ctx, NULL, stat->else_stat);
1164 set_arg_uint(ctx, jmp_end, ctx->code_off);
1166 set_arg_uint(ctx, jmp_else, ctx->code_off);
1172 /* ECMA-262 3rd Edition 12.6.2 */
1173 static HRESULT compile_while_statement(compiler_ctx_t *ctx, while_statement_t *stat)
1175 statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1179 stat_ctx.break_label = alloc_label(ctx);
1180 if(!stat_ctx.break_label)
1181 return E_OUTOFMEMORY;
1183 stat_ctx.continue_label = alloc_label(ctx);
1184 if(!stat_ctx.continue_label)
1185 return E_OUTOFMEMORY;
1187 jmp_off = ctx->code_off;
1189 if(!stat->do_while) {
1190 label_set_addr(ctx, stat_ctx.continue_label);
1191 hres = compile_expression(ctx, stat->expr, TRUE);
1195 hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1200 hres = compile_statement(ctx, &stat_ctx, stat->statement);
1204 if(stat->do_while) {
1205 label_set_addr(ctx, stat_ctx.continue_label);
1206 hres = compile_expression(ctx, stat->expr, TRUE);
1210 hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1215 hres = push_instr_uint(ctx, OP_jmp, jmp_off);
1219 label_set_addr(ctx, stat_ctx.break_label);
1223 /* ECMA-262 3rd Edition 12.6.3 */
1224 static HRESULT compile_for_statement(compiler_ctx_t *ctx, for_statement_t *stat)
1226 statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1230 if(stat->variable_list) {
1231 hres = compile_variable_list(ctx, stat->variable_list);
1234 }else if(stat->begin_expr) {
1235 hres = compile_expression(ctx, stat->begin_expr, FALSE);
1240 stat_ctx.break_label = alloc_label(ctx);
1241 if(!stat_ctx.break_label)
1242 return E_OUTOFMEMORY;
1244 stat_ctx.continue_label = alloc_label(ctx);
1245 if(!stat_ctx.continue_label)
1246 return E_OUTOFMEMORY;
1248 expr_off = ctx->code_off;
1251 hres = compile_expression(ctx, stat->expr, TRUE);
1255 hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1260 hres = compile_statement(ctx, &stat_ctx, stat->statement);
1264 label_set_addr(ctx, stat_ctx.continue_label);
1266 if(stat->end_expr) {
1267 hres = compile_expression(ctx, stat->end_expr, FALSE);
1272 hres = push_instr_uint(ctx, OP_jmp, expr_off);
1276 label_set_addr(ctx, stat_ctx.break_label);
1280 /* ECMA-262 3rd Edition 12.6.4 */
1281 static HRESULT compile_forin_statement(compiler_ctx_t *ctx, forin_statement_t *stat)
1283 statement_ctx_t stat_ctx = {4, FALSE, FALSE};
1286 if(stat->variable) {
1287 hres = compile_variable_list(ctx, stat->variable);
1292 stat_ctx.break_label = alloc_label(ctx);
1293 if(!stat_ctx.break_label)
1294 return E_OUTOFMEMORY;
1296 stat_ctx.continue_label = alloc_label(ctx);
1297 if(!stat_ctx.continue_label)
1298 return E_OUTOFMEMORY;
1300 hres = compile_expression(ctx, stat->in_expr, TRUE);
1304 if(stat->variable) {
1305 hres = push_instr_bstr_uint(ctx, OP_identid, stat->variable->identifier, fdexNameEnsure);
1308 }else if(is_memberid_expr(stat->expr->type)) {
1309 hres = compile_memberid_expression(ctx, stat->expr, fdexNameEnsure);
1313 hres = push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
1317 /* FIXME: compile statement anyways when we depend on compiler to check errors */
1321 hres = push_instr_int(ctx, OP_int, DISPID_STARTENUM);
1325 label_set_addr(ctx, stat_ctx.continue_label);
1326 hres = push_instr_uint(ctx, OP_forin, stat_ctx.break_label);
1328 return E_OUTOFMEMORY;
1330 hres = compile_statement(ctx, &stat_ctx, stat->statement);
1334 hres = push_instr_uint(ctx, OP_jmp, stat_ctx.continue_label);
1338 label_set_addr(ctx, stat_ctx.break_label);
1342 static HRESULT pop_to_stat(compiler_ctx_t *ctx, BOOL var_stack, BOOL scope_stack, statement_ctx_t *stat_ctx)
1344 unsigned stack_pop = 0;
1345 statement_ctx_t *iter;
1347 for(iter = ctx->stat_ctx; iter != stat_ctx; iter = iter->next) {
1349 if(iter->using_scope && !push_instr(ctx, OP_pop_scope))
1350 return E_OUTOFMEMORY;
1351 if(iter->using_except && !push_instr(ctx, OP_pop_except))
1352 return E_OUTOFMEMORY;
1354 stack_pop += iter->stack_use;
1357 if(var_stack && stack_pop) {
1360 hres = push_instr_uint(ctx, OP_pop, stack_pop);
1368 /* ECMA-262 3rd Edition 12.7 */
1369 static HRESULT compile_continue_statement(compiler_ctx_t *ctx, branch_statement_t *stat)
1371 statement_ctx_t *pop_ctx;
1374 if(stat->identifier) {
1375 statement_t *label_stat;
1376 statement_ctx_t *iter;
1380 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1381 if(iter->continue_label)
1383 if(iter->labelled_stat && !strcmpW(iter->labelled_stat->identifier, stat->identifier))
1388 WARN("Label not found\n");
1389 return JS_E_LABEL_NOT_FOUND;
1392 /* Labelled continue are allowed only on loops */
1393 for(label_stat = iter->labelled_stat->statement;
1394 label_stat->type == STAT_LABEL;
1395 label_stat = ((labelled_statement_t*)label_stat)->statement);
1396 if(!is_loop_statement(label_stat->type)) {
1397 WARN("Label is not a loop\n");
1398 return JS_E_INVALID_CONTINUE;
1401 assert(pop_ctx != NULL);
1403 for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1404 if(pop_ctx->continue_label)
1409 WARN("continue outside loop\n");
1410 return JS_E_INVALID_CONTINUE;
1414 hres = pop_to_stat(ctx, TRUE, TRUE, pop_ctx);
1418 return push_instr_uint(ctx, OP_jmp, pop_ctx->continue_label);
1421 /* ECMA-262 3rd Edition 12.8 */
1422 static HRESULT compile_break_statement(compiler_ctx_t *ctx, branch_statement_t *stat)
1424 statement_ctx_t *pop_ctx;
1427 if(stat->identifier) {
1428 for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1429 if(pop_ctx->labelled_stat && !strcmpW(pop_ctx->labelled_stat->identifier, stat->identifier)) {
1430 assert(pop_ctx->break_label);
1436 WARN("Label not found\n");
1437 return JS_E_LABEL_NOT_FOUND;
1440 for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1441 if(pop_ctx->break_label && !pop_ctx->labelled_stat)
1446 WARN("Break outside loop\n");
1447 return JS_E_INVALID_BREAK;
1451 hres = pop_to_stat(ctx, TRUE, TRUE, pop_ctx->next);
1455 return push_instr_uint(ctx, OP_jmp, pop_ctx->break_label);
1458 /* ECMA-262 3rd Edition 12.9 */
1459 static HRESULT compile_return_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1463 if(ctx->from_eval) {
1464 WARN("misplaced return statement\n");
1465 return JS_E_MISPLACED_RETURN;
1468 hres = pop_to_stat(ctx, TRUE, FALSE, NULL);
1473 hres = compile_expression(ctx, stat->expr, TRUE);
1476 if(!push_instr(ctx, OP_setret))
1477 return E_OUTOFMEMORY;
1480 hres = pop_to_stat(ctx, FALSE, TRUE, NULL);
1484 return push_instr(ctx, OP_ret) ? S_OK : E_OUTOFMEMORY;
1487 /* ECMA-262 3rd Edition 12.10 */
1488 static HRESULT compile_with_statement(compiler_ctx_t *ctx, with_statement_t *stat)
1490 statement_ctx_t stat_ctx = {0, TRUE, FALSE};
1493 hres = compile_expression(ctx, stat->expr, TRUE);
1497 if(!push_instr(ctx, OP_push_scope))
1498 return E_OUTOFMEMORY;
1500 hres = compile_statement(ctx, &stat_ctx, stat->statement);
1504 if(!push_instr(ctx, OP_pop_scope))
1505 return E_OUTOFMEMORY;
1510 /* ECMA-262 3rd Edition 12.10 */
1511 static HRESULT compile_labelled_statement(compiler_ctx_t *ctx, labelled_statement_t *stat)
1513 statement_ctx_t stat_ctx = {0, FALSE, FALSE, 0, 0, stat}, *iter;
1516 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1517 if(iter->labelled_stat && !strcmpW(iter->labelled_stat->identifier, stat->identifier)) {
1518 WARN("Label %s redefined\n", debugstr_w(stat->identifier));
1519 return JS_E_LABEL_REDEFINED;
1523 /* Labelled breaks are allowed for any labelled statements, not only loops (violating spec) */
1524 stat_ctx.break_label = alloc_label(ctx);
1525 if(!stat_ctx.break_label)
1526 return E_OUTOFMEMORY;
1528 hres = compile_statement(ctx, &stat_ctx, stat->statement);
1532 label_set_addr(ctx, stat_ctx.break_label);
1536 /* ECMA-262 3rd Edition 12.13 */
1537 static HRESULT compile_switch_statement(compiler_ctx_t *ctx, switch_statement_t *stat)
1539 statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1540 unsigned case_cnt = 0, *case_jmps, i, default_jmp;
1541 BOOL have_default = FALSE;
1542 statement_t *stat_iter;
1543 case_clausule_t *iter;
1546 hres = compile_expression(ctx, stat->expr, TRUE);
1550 stat_ctx.break_label = alloc_label(ctx);
1551 if(!stat_ctx.break_label)
1552 return E_OUTOFMEMORY;
1554 for(iter = stat->case_list; iter; iter = iter->next) {
1559 case_jmps = heap_alloc(case_cnt * sizeof(*case_jmps));
1561 return E_OUTOFMEMORY;
1564 for(iter = stat->case_list; iter; iter = iter->next) {
1566 have_default = TRUE;
1570 hres = compile_expression(ctx, iter->expr, TRUE);
1574 case_jmps[i] = push_instr(ctx, OP_case);
1576 hres = E_OUTOFMEMORY;
1582 if(SUCCEEDED(hres)) {
1583 hres = push_instr_uint(ctx, OP_pop, 1);
1584 if(SUCCEEDED(hres)) {
1585 default_jmp = push_instr(ctx, OP_jmp);
1587 hres = E_OUTOFMEMORY;
1592 heap_free(case_jmps);
1597 for(iter = stat->case_list; iter; iter = iter->next) {
1598 while(iter->next && iter->next->stat == iter->stat) {
1599 set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);
1603 set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);
1605 for(stat_iter = iter->stat; stat_iter && (!iter->next || iter->next->stat != stat_iter);
1606 stat_iter = stat_iter->next) {
1607 hres = compile_statement(ctx, &stat_ctx, stat_iter);
1615 heap_free(case_jmps);
1618 assert(i == case_cnt);
1621 hres = push_instr_uint(ctx, OP_jmp, stat_ctx.break_label);
1624 set_arg_uint(ctx, default_jmp, ctx->code_off);
1627 label_set_addr(ctx, stat_ctx.break_label);
1631 /* ECMA-262 3rd Edition 12.13 */
1632 static HRESULT compile_throw_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1636 hres = compile_expression(ctx, stat->expr, TRUE);
1640 return push_instr(ctx, OP_throw) ? S_OK : E_OUTOFMEMORY;
1643 /* ECMA-262 3rd Edition 12.14 */
1644 static HRESULT compile_try_statement(compiler_ctx_t *ctx, try_statement_t *stat)
1646 statement_ctx_t try_ctx = {0, FALSE, TRUE}, catch_ctx = {0, TRUE, FALSE};
1647 statement_ctx_t finally_ctx = {2, FALSE, FALSE};
1648 unsigned push_except;
1652 push_except = push_instr(ctx, OP_push_except);
1654 return E_OUTOFMEMORY;
1656 if(stat->catch_block) {
1657 ident = compiler_alloc_bstr(ctx, stat->catch_block->identifier);
1659 return E_OUTOFMEMORY;
1664 instr_ptr(ctx, push_except)->u.arg[1].bstr = ident;
1666 if(!stat->catch_block)
1667 try_ctx.stack_use = 2;
1669 hres = compile_statement(ctx, &try_ctx, stat->try_statement);
1673 if(!push_instr(ctx, OP_pop_except))
1674 return E_OUTOFMEMORY;
1676 if(stat->catch_block) {
1677 unsigned jmp_finally;
1679 jmp_finally = push_instr(ctx, OP_jmp);
1681 return E_OUTOFMEMORY;
1683 instr_ptr(ctx, push_except)->u.arg[0].uint = ctx->code_off;
1685 hres = compile_statement(ctx, &catch_ctx, stat->catch_block->statement);
1689 if(!push_instr(ctx, OP_pop_scope))
1690 return E_OUTOFMEMORY;
1692 set_arg_uint(ctx, jmp_finally, ctx->code_off);
1694 set_arg_uint(ctx, push_except, ctx->code_off);
1697 if(stat->finally_statement) {
1698 hres = compile_statement(ctx, stat->catch_block ? NULL : &finally_ctx, stat->finally_statement);
1702 if(!stat->catch_block && !push_instr(ctx, OP_end_finally))
1703 return E_OUTOFMEMORY;
1709 static HRESULT compile_statement(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
1714 stat_ctx->next = ctx->stat_ctx;
1715 ctx->stat_ctx = stat_ctx;
1718 switch(stat->type) {
1720 hres = compile_block_statement(ctx, ((block_statement_t*)stat)->stat_list);
1723 hres = compile_break_statement(ctx, (branch_statement_t*)stat);
1726 hres = compile_continue_statement(ctx, (branch_statement_t*)stat);
1733 hres = compile_expression_statement(ctx, (expression_statement_t*)stat);
1736 hres = compile_for_statement(ctx, (for_statement_t*)stat);
1739 hres = compile_forin_statement(ctx, (forin_statement_t*)stat);
1742 hres = compile_if_statement(ctx, (if_statement_t*)stat);
1745 hres = compile_labelled_statement(ctx, (labelled_statement_t*)stat);
1748 hres = compile_return_statement(ctx, (expression_statement_t*)stat);
1751 hres = compile_switch_statement(ctx, (switch_statement_t*)stat);
1754 hres = compile_throw_statement(ctx, (expression_statement_t*)stat);
1757 hres = compile_try_statement(ctx, (try_statement_t*)stat);
1760 hres = compile_var_statement(ctx, (var_statement_t*)stat);
1763 hres = compile_while_statement(ctx, (while_statement_t*)stat);
1766 hres = compile_with_statement(ctx, (with_statement_t*)stat);
1774 assert(ctx->stat_ctx == stat_ctx);
1775 ctx->stat_ctx = stat_ctx->next;
1781 static void resolve_labels(compiler_ctx_t *ctx, unsigned off)
1785 for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->code_off; instr++) {
1786 if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->u.arg->uint & LABEL_FLAG)) {
1787 assert((instr->u.arg->uint & ~LABEL_FLAG) < ctx->labels_cnt);
1788 instr->u.arg->uint = ctx->labels[instr->u.arg->uint & ~LABEL_FLAG];
1790 assert(instr_info[instr->op].arg2_type != ARG_ADDR);
1793 ctx->labels_cnt = 0;
1796 void release_bytecode(bytecode_t *code)
1803 for(i=0; i < code->bstr_cnt; i++)
1804 SysFreeString(code->bstr_pool[i]);
1805 for(i=0; i < code->str_cnt; i++)
1806 jsstr_release(code->str_pool[i]);
1808 heap_free(code->source);
1809 jsheap_free(&code->heap);
1810 heap_free(code->bstr_pool);
1811 heap_free(code->str_pool);
1812 heap_free(code->instrs);
1816 static HRESULT init_code(compiler_ctx_t *compiler, const WCHAR *source)
1818 compiler->code = heap_alloc_zero(sizeof(bytecode_t));
1820 return E_OUTOFMEMORY;
1822 compiler->code->ref = 1;
1823 jsheap_init(&compiler->code->heap);
1825 compiler->code->source = heap_strdupW(source);
1826 if(!compiler->code->source) {
1827 release_bytecode(compiler->code);
1828 return E_OUTOFMEMORY;
1831 compiler->code->instrs = heap_alloc(64 * sizeof(instr_t));
1832 if(!compiler->code->instrs) {
1833 release_bytecode(compiler->code);
1834 return E_OUTOFMEMORY;
1837 compiler->code_size = 64;
1838 compiler->code_off = 1;
1842 static HRESULT compile_function(compiler_ctx_t *ctx, source_elements_t *source, function_expression_t *func_expr,
1843 BOOL from_eval, function_code_t *func)
1845 variable_declaration_t *var_iter;
1846 function_expression_t *iter;
1852 ctx->var_head = ctx->var_tail = NULL;
1853 ctx->func_head = ctx->func_tail = NULL;
1854 ctx->from_eval = from_eval;
1856 off = ctx->code_off;
1858 hres = compile_block_statement(ctx, source->statement);
1862 resolve_labels(ctx, off);
1864 if(!push_instr(ctx, OP_ret))
1865 return E_OUTOFMEMORY;
1867 if(TRACE_ON(jscript_disas))
1868 dump_code(ctx, off);
1870 func->instr_off = off;
1872 if(func_expr && func_expr->identifier) {
1873 func->name = compiler_alloc_bstr(ctx, func_expr->identifier);
1875 return E_OUTOFMEMORY;
1879 parameter_t *param_iter;
1881 func->source = func_expr->src_str;
1882 func->source_len = func_expr->src_len;
1884 for(param_iter = func_expr->parameter_list; param_iter; param_iter = param_iter->next)
1887 func->params = compiler_alloc(ctx->code, func->param_cnt * sizeof(*func->params));
1889 return E_OUTOFMEMORY;
1891 for(param_iter = func_expr->parameter_list, i=0; param_iter; param_iter = param_iter->next, i++) {
1892 func->params[i] = compiler_alloc_bstr(ctx, param_iter->identifier);
1893 if(!func->params[i])
1894 return E_OUTOFMEMORY;
1898 func->variables = compiler_alloc(ctx->code, func->var_cnt * sizeof(*func->variables));
1899 if(!func->variables)
1900 return E_OUTOFMEMORY;
1902 for(var_iter = ctx->var_head, i=0; var_iter; var_iter = var_iter->global_next, i++) {
1903 func->variables[i] = compiler_alloc_bstr(ctx, var_iter->identifier);
1904 if(!func->variables[i])
1905 return E_OUTOFMEMORY;
1908 assert(i == func->var_cnt);
1910 func->funcs = compiler_alloc(ctx->code, func->func_cnt * sizeof(*func->funcs));
1912 return E_OUTOFMEMORY;
1913 memset(func->funcs, 0, func->func_cnt * sizeof(*func->funcs));
1915 for(iter = ctx->func_head, i=0; iter; iter = iter->next, i++) {
1916 hres = compile_function(ctx, iter->source_elements, iter, FALSE, func->funcs+i);
1921 assert(i == func->func_cnt);
1926 static HRESULT parse_arguments(compiler_ctx_t *ctx, const WCHAR *args, BSTR *arg_array, unsigned *args_size)
1928 const WCHAR *ptr = args, *ptr2;
1929 unsigned arg_cnt = 0;
1931 while(isspaceW(*ptr))
1940 if(!isalphaW(*ptr) && *ptr != '_') {
1941 FIXME("expected alpha or '_': %s\n", debugstr_w(ptr));
1946 while(isalnumW(*ptr) || *ptr == '_')
1949 if(*ptr && *ptr != ',' && !isspaceW(*ptr)) {
1950 FIXME("unexpected har %s\n", debugstr_w(ptr));
1955 arg_array[arg_cnt] = compiler_alloc_bstr_len(ctx, ptr2, ptr-ptr2);
1956 if(!arg_array[arg_cnt])
1957 return E_OUTOFMEMORY;
1961 while(isspaceW(*ptr))
1966 FIXME("expected ',': %s\n", debugstr_w(ptr));
1971 while(isspaceW(*ptr))
1976 *args_size = arg_cnt;
1980 static HRESULT compile_arguments(compiler_ctx_t *ctx, const WCHAR *args)
1984 hres = parse_arguments(ctx, args, NULL, &ctx->code->global_code.param_cnt);
1988 ctx->code->global_code.params = compiler_alloc(ctx->code,
1989 ctx->code->global_code.param_cnt * sizeof(*ctx->code->global_code.params));
1990 if(!ctx->code->global_code.params)
1991 return E_OUTOFMEMORY;
1993 return parse_arguments(ctx, args, ctx->code->global_code.params, NULL);
1996 HRESULT compile_script(script_ctx_t *ctx, const WCHAR *code, const WCHAR *args, const WCHAR *delimiter,
1997 BOOL from_eval, BOOL use_decode, bytecode_t **ret)
1999 compiler_ctx_t compiler = {0};
2002 hres = init_code(&compiler, code);
2007 hres = compile_arguments(&compiler, args);
2013 hres = decode_source(compiler.code->source);
2015 WARN("Decoding failed\n");
2020 hres = script_parse(ctx, compiler.code->source, delimiter, from_eval, &compiler.parser);
2022 release_bytecode(compiler.code);
2026 hres = compile_function(&compiler, compiler.parser->source, NULL, from_eval, &compiler.code->global_code);
2027 parser_release(compiler.parser);
2029 release_bytecode(compiler.code);
2033 *ret = compiler.code;