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
23 #include "parser.tab.h"
25 #include "wine/debug.h"
27 WINE_DEFAULT_DEBUG_CHANNEL(vbscript
);
28 WINE_DECLARE_DEBUG_CHANNEL(vbscript_disas
);
41 unsigned while_end_label
;
42 unsigned sub_end_label
;
43 unsigned func_end_label
;
44 unsigned prop_end_label
;
46 dim_decl_t
*dim_decls
;
47 dynamic_var_t
*global_vars
;
51 function_decl_t
*func_decls
;
53 class_desc_t
*classes
;
56 static HRESULT
compile_expression(compile_ctx_t
*,expression_t
*);
57 static HRESULT
compile_statement(compile_ctx_t
*,statement_t
*);
61 instr_arg_type_t arg1_type
;
62 instr_arg_type_t arg2_type
;
64 #define X(n,a,b,c) {#n,b,c},
69 static void dump_instr_arg(instr_arg_type_t type
, instr_arg_t
*arg
)
74 TRACE_(vbscript_disas
)("\t%s", debugstr_w(arg
->str
));
77 TRACE_(vbscript_disas
)("\t%d", arg
->uint
);
81 TRACE_(vbscript_disas
)("\t%u", arg
->uint
);
84 TRACE_(vbscript_disas
)("\t%lf", *arg
->dbl
);
93 static void dump_code(compile_ctx_t
*ctx
)
97 for(instr
= ctx
->code
->instrs
; instr
< ctx
->code
->instrs
+ctx
->instr_cnt
; instr
++) {
98 TRACE_(vbscript_disas
)("%d:\t%s", (int)(instr
-ctx
->code
->instrs
), instr_info
[instr
->op
].op_str
);
99 dump_instr_arg(instr_info
[instr
->op
].arg1_type
, &instr
->arg1
);
100 dump_instr_arg(instr_info
[instr
->op
].arg2_type
, &instr
->arg2
);
101 TRACE_(vbscript_disas
)("\n");
105 static inline void *compiler_alloc(vbscode_t
*vbscode
, size_t size
)
107 return vbsheap_alloc(&vbscode
->heap
, size
);
110 static WCHAR
*compiler_alloc_string(vbscode_t
*vbscode
, const WCHAR
*str
)
115 size
= (strlenW(str
)+1)*sizeof(WCHAR
);
116 ret
= compiler_alloc(vbscode
, size
);
118 memcpy(ret
, str
, size
);
122 static inline instr_t
*instr_ptr(compile_ctx_t
*ctx
, unsigned id
)
124 assert(id
< ctx
->instr_cnt
);
125 return ctx
->code
->instrs
+ id
;
128 static unsigned push_instr(compile_ctx_t
*ctx
, vbsop_t op
)
130 assert(ctx
->instr_size
&& ctx
->instr_size
>= ctx
->instr_cnt
);
132 if(ctx
->instr_size
== ctx
->instr_cnt
) {
135 new_instr
= heap_realloc(ctx
->code
->instrs
, ctx
->instr_size
*2*sizeof(instr_t
));
139 ctx
->code
->instrs
= new_instr
;
140 ctx
->instr_size
*= 2;
143 ctx
->code
->instrs
[ctx
->instr_cnt
].op
= op
;
144 return ctx
->instr_cnt
++;
147 static HRESULT
push_instr_int(compile_ctx_t
*ctx
, vbsop_t op
, LONG arg
)
151 ret
= push_instr(ctx
, op
);
153 return E_OUTOFMEMORY
;
155 instr_ptr(ctx
, ret
)->arg1
.lng
= arg
;
159 static HRESULT
push_instr_addr(compile_ctx_t
*ctx
, vbsop_t op
, unsigned arg
)
163 ret
= push_instr(ctx
, op
);
165 return E_OUTOFMEMORY
;
167 instr_ptr(ctx
, ret
)->arg1
.uint
= arg
;
171 static HRESULT
push_instr_str(compile_ctx_t
*ctx
, vbsop_t op
, const WCHAR
*arg
)
176 str
= compiler_alloc_string(ctx
->code
, arg
);
178 return E_OUTOFMEMORY
;
180 instr
= push_instr(ctx
, op
);
182 return E_OUTOFMEMORY
;
184 instr_ptr(ctx
, instr
)->arg1
.str
= str
;
188 static HRESULT
push_instr_double(compile_ctx_t
*ctx
, vbsop_t op
, double arg
)
193 d
= compiler_alloc(ctx
->code
, sizeof(double));
195 return E_OUTOFMEMORY
;
197 instr
= push_instr(ctx
, op
);
199 return E_OUTOFMEMORY
;
202 instr_ptr(ctx
, instr
)->arg1
.dbl
= d
;
206 static BSTR
alloc_bstr_arg(compile_ctx_t
*ctx
, const WCHAR
*str
)
208 if(!ctx
->code
->bstr_pool_size
) {
209 ctx
->code
->bstr_pool
= heap_alloc(8 * sizeof(BSTR
));
210 if(!ctx
->code
->bstr_pool
)
212 ctx
->code
->bstr_pool_size
= 8;
213 }else if(ctx
->code
->bstr_pool_size
== ctx
->code
->bstr_cnt
) {
216 new_pool
= heap_realloc(ctx
->code
->bstr_pool
, ctx
->code
->bstr_pool_size
*2*sizeof(BSTR
));
220 ctx
->code
->bstr_pool
= new_pool
;
221 ctx
->code
->bstr_pool_size
*= 2;
224 ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
] = SysAllocString(str
);
225 if(!ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
])
228 return ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
++];
231 static HRESULT
push_instr_bstr(compile_ctx_t
*ctx
, vbsop_t op
, const WCHAR
*arg
)
236 bstr
= alloc_bstr_arg(ctx
, arg
);
238 return E_OUTOFMEMORY
;
240 instr
= push_instr(ctx
, op
);
242 return E_OUTOFMEMORY
;
244 instr_ptr(ctx
, instr
)->arg1
.bstr
= bstr
;
248 static HRESULT
push_instr_bstr_uint(compile_ctx_t
*ctx
, vbsop_t op
, const WCHAR
*arg1
, unsigned arg2
)
253 bstr
= alloc_bstr_arg(ctx
, arg1
);
255 return E_OUTOFMEMORY
;
257 instr
= push_instr(ctx
, op
);
259 return E_OUTOFMEMORY
;
261 instr_ptr(ctx
, instr
)->arg1
.bstr
= bstr
;
262 instr_ptr(ctx
, instr
)->arg2
.uint
= arg2
;
266 #define LABEL_FLAG 0x80000000
268 static unsigned alloc_label(compile_ctx_t
*ctx
)
270 if(!ctx
->labels_size
) {
271 ctx
->labels
= heap_alloc(8 * sizeof(*ctx
->labels
));
274 ctx
->labels_size
= 8;
275 }else if(ctx
->labels_size
== ctx
->labels_cnt
) {
276 unsigned *new_labels
;
278 new_labels
= heap_realloc(ctx
->labels
, 2*ctx
->labels_size
*sizeof(*ctx
->labels
));
282 ctx
->labels
= new_labels
;
283 ctx
->labels_size
*= 2;
286 return ctx
->labels_cnt
++ | LABEL_FLAG
;
289 static inline void label_set_addr(compile_ctx_t
*ctx
, unsigned label
)
291 assert(label
& LABEL_FLAG
);
292 ctx
->labels
[label
& ~LABEL_FLAG
] = ctx
->instr_cnt
;
295 static HRESULT
compile_args(compile_ctx_t
*ctx
, expression_t
*args
, unsigned *ret
)
297 unsigned arg_cnt
= 0;
301 hres
= compile_expression(ctx
, args
);
313 static HRESULT
compile_member_expression(compile_ctx_t
*ctx
, member_expression_t
*expr
, BOOL ret_val
)
315 unsigned arg_cnt
= 0;
318 hres
= compile_args(ctx
, expr
->args
, &arg_cnt
);
323 hres
= compile_expression(ctx
, expr
->obj_expr
);
327 hres
= push_instr_bstr_uint(ctx
, ret_val
? OP_mcall
: OP_mcallv
, expr
->identifier
, arg_cnt
);
329 hres
= push_instr_bstr_uint(ctx
, ret_val
? OP_icall
: OP_icallv
, expr
->identifier
, arg_cnt
);
335 static HRESULT
compile_unary_expression(compile_ctx_t
*ctx
, unary_expression_t
*expr
, vbsop_t op
)
339 hres
= compile_expression(ctx
, expr
->subexpr
);
343 return push_instr(ctx
, op
) == -1 ? E_OUTOFMEMORY
: S_OK
;
346 static HRESULT
compile_binary_expression(compile_ctx_t
*ctx
, binary_expression_t
*expr
, vbsop_t op
)
350 hres
= compile_expression(ctx
, expr
->left
);
354 hres
= compile_expression(ctx
, expr
->right
);
358 return push_instr(ctx
, op
) == -1 ? E_OUTOFMEMORY
: S_OK
;
361 static HRESULT
compile_expression(compile_ctx_t
*ctx
, expression_t
*expr
)
365 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_add
);
367 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_and
);
369 return push_instr_int(ctx
, OP_bool
, ((bool_expression_t
*)expr
)->value
);
371 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_concat
);
373 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_div
);
375 return push_instr_double(ctx
, OP_double
, ((double_expression_t
*)expr
)->value
);
377 return push_instr(ctx
, OP_empty
) != -1 ? S_OK
: E_OUTOFMEMORY
;
379 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_equal
);
381 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_eqv
);
383 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_exp
);
385 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_idiv
);
387 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_imp
);
389 return compile_member_expression(ctx
, (member_expression_t
*)expr
, TRUE
);
391 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_mod
);
393 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_mul
);
395 return compile_unary_expression(ctx
, (unary_expression_t
*)expr
, OP_neg
);
397 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_nequal
);
399 return push_instr_str(ctx
, OP_new
, ((string_expression_t
*)expr
)->value
);
401 return compile_unary_expression(ctx
, (unary_expression_t
*)expr
, OP_not
);
403 return push_instr(ctx
, OP_nothing
) != -1 ? S_OK
: E_OUTOFMEMORY
;
405 return push_instr(ctx
, OP_null
) != -1 ? S_OK
: E_OUTOFMEMORY
;
407 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_or
);
409 return push_instr_str(ctx
, OP_string
, ((string_expression_t
*)expr
)->value
);
411 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_sub
);
413 return push_instr_int(ctx
, OP_short
, ((int_expression_t
*)expr
)->value
);
415 return push_instr_int(ctx
, OP_long
, ((int_expression_t
*)expr
)->value
);
417 return compile_binary_expression(ctx
, (binary_expression_t
*)expr
, OP_xor
);
419 FIXME("Unimplemented expression type %d\n", expr
->type
);
426 static HRESULT
compile_if_statement(compile_ctx_t
*ctx
, if_statement_t
*stat
)
428 unsigned cnd_jmp
, endif_label
= -1;
429 elseif_decl_t
*elseif_decl
;
432 hres
= compile_expression(ctx
, stat
->expr
);
436 cnd_jmp
= push_instr(ctx
, OP_jmp_false
);
438 return E_OUTOFMEMORY
;
440 hres
= compile_statement(ctx
, stat
->if_stat
);
444 if(stat
->else_stat
|| stat
->elseifs
) {
445 endif_label
= alloc_label(ctx
);
446 if(endif_label
== -1)
447 return E_OUTOFMEMORY
;
449 hres
= push_instr_addr(ctx
, OP_jmp
, endif_label
);
454 for(elseif_decl
= stat
->elseifs
; elseif_decl
; elseif_decl
= elseif_decl
->next
) {
455 instr_ptr(ctx
, cnd_jmp
)->arg1
.uint
= ctx
->instr_cnt
;
457 hres
= compile_expression(ctx
, elseif_decl
->expr
);
461 cnd_jmp
= push_instr(ctx
, OP_jmp_false
);
463 return E_OUTOFMEMORY
;
465 hres
= compile_statement(ctx
, elseif_decl
->stat
);
469 hres
= push_instr_addr(ctx
, OP_jmp
, endif_label
);
474 instr_ptr(ctx
, cnd_jmp
)->arg1
.uint
= ctx
->instr_cnt
;
476 if(stat
->else_stat
) {
477 hres
= compile_statement(ctx
, stat
->else_stat
);
482 if(endif_label
!= -1)
483 label_set_addr(ctx
, endif_label
);
487 static HRESULT
compile_while_statement(compile_ctx_t
*ctx
, while_statement_t
*stat
)
489 unsigned start_addr
, prev_label
;
493 start_addr
= ctx
->instr_cnt
;
495 hres
= compile_expression(ctx
, stat
->expr
);
499 jmp_end
= push_instr(ctx
, stat
->stat
.type
== STAT_UNTIL
? OP_jmp_true
: OP_jmp_false
);
501 return E_OUTOFMEMORY
;
503 if(stat
->stat
.type
!= STAT_WHILE
) {
504 prev_label
= ctx
->while_end_label
;
505 if((ctx
->while_end_label
= alloc_label(ctx
)) == -1)
506 return E_OUTOFMEMORY
;
509 hres
= compile_statement(ctx
, stat
->body
);
513 hres
= push_instr_addr(ctx
, OP_jmp
, start_addr
);
517 instr_ptr(ctx
, jmp_end
)->arg1
.uint
= ctx
->instr_cnt
;
519 if(stat
->stat
.type
!= STAT_WHILE
) {
520 label_set_addr(ctx
, ctx
->while_end_label
);
521 ctx
->while_end_label
= prev_label
;
527 static HRESULT
compile_dowhile_statement(compile_ctx_t
*ctx
, while_statement_t
*stat
)
529 unsigned start_addr
, prev_label
;
532 start_addr
= ctx
->instr_cnt
;
534 prev_label
= ctx
->while_end_label
;
535 if((ctx
->while_end_label
= alloc_label(ctx
)) == -1)
536 return E_OUTOFMEMORY
;
538 hres
= compile_statement(ctx
, stat
->body
);
542 hres
= compile_expression(ctx
, stat
->expr
);
546 hres
= push_instr_addr(ctx
, stat
->stat
.type
== STAT_DOUNTIL
? OP_jmp_false
: OP_jmp_true
, start_addr
);
550 label_set_addr(ctx
, ctx
->while_end_label
);
551 ctx
->while_end_label
= prev_label
;
555 static HRESULT
compile_assign_statement(compile_ctx_t
*ctx
, assign_statement_t
*stat
, BOOL is_set
)
559 hres
= compile_expression(ctx
, stat
->value_expr
);
563 if(stat
->member_expr
->args
) {
564 FIXME("arguments support not implemented\n");
568 if(stat
->member_expr
->obj_expr
) {
569 hres
= compile_expression(ctx
, stat
->member_expr
->obj_expr
);
573 hres
= push_instr_bstr(ctx
, is_set
? OP_set_member
: OP_assign_member
, stat
->member_expr
->identifier
);
575 hres
= push_instr_bstr(ctx
, is_set
? OP_set_ident
: OP_assign_ident
, stat
->member_expr
->identifier
);
581 static BOOL
lookup_dim_decls(compile_ctx_t
*ctx
, const WCHAR
*name
)
583 dim_decl_t
*dim_decl
;
585 for(dim_decl
= ctx
->dim_decls
; dim_decl
; dim_decl
= dim_decl
->next
) {
586 if(!strcmpiW(dim_decl
->name
, name
))
593 static BOOL
lookup_args_name(compile_ctx_t
*ctx
, const WCHAR
*name
)
597 for(i
= 0; i
< ctx
->func
->arg_cnt
; i
++) {
598 if(!strcmpiW(ctx
->func
->args
[i
].name
, name
))
605 static HRESULT
compile_dim_statement(compile_ctx_t
*ctx
, dim_statement_t
*stat
)
607 dim_decl_t
*dim_decl
= stat
->dim_decls
;
610 if(lookup_dim_decls(ctx
, dim_decl
->name
) || lookup_args_name(ctx
, dim_decl
->name
)) {
611 FIXME("dim %s name redefined\n", debugstr_w(dim_decl
->name
));
617 dim_decl
= dim_decl
->next
;
620 dim_decl
->next
= ctx
->dim_decls
;
621 ctx
->dim_decls
= stat
->dim_decls
;
622 ctx
->func
->var_cnt
++;
626 static HRESULT
compile_function_statement(compile_ctx_t
*ctx
, function_statement_t
*stat
)
628 if(ctx
->func
!= &ctx
->code
->global_code
) {
629 FIXME("Function is not in the global code\n");
633 stat
->func_decl
->next
= ctx
->func_decls
;
634 ctx
->func_decls
= stat
->func_decl
;
638 static HRESULT
compile_exitdo_statement(compile_ctx_t
*ctx
)
640 if(ctx
->while_end_label
== -1) {
641 FIXME("Exit Do outside Do Loop\n");
645 return push_instr_addr(ctx
, OP_jmp
, ctx
->while_end_label
);
648 static HRESULT
compile_exitsub_statement(compile_ctx_t
*ctx
)
650 if(ctx
->sub_end_label
== -1) {
651 FIXME("Exit Sub outside Sub?\n");
655 return push_instr_addr(ctx
, OP_jmp
, ctx
->sub_end_label
);
658 static HRESULT
compile_exitfunc_statement(compile_ctx_t
*ctx
)
660 if(ctx
->func_end_label
== -1) {
661 FIXME("Exit Function outside Function?\n");
665 return push_instr_addr(ctx
, OP_jmp
, ctx
->func_end_label
);
668 static HRESULT
compile_exitprop_statement(compile_ctx_t
*ctx
)
670 if(ctx
->prop_end_label
== -1) {
671 FIXME("Exit Property outside Property?\n");
675 return push_instr_addr(ctx
, OP_jmp
, ctx
->prop_end_label
);
678 static HRESULT
compile_statement(compile_ctx_t
*ctx
, statement_t
*stat
)
685 hres
= compile_assign_statement(ctx
, (assign_statement_t
*)stat
, FALSE
);
688 hres
= compile_member_expression(ctx
, ((call_statement_t
*)stat
)->expr
, FALSE
);
691 hres
= compile_dim_statement(ctx
, (dim_statement_t
*)stat
);
695 hres
= compile_dowhile_statement(ctx
, (while_statement_t
*)stat
);
698 hres
= compile_exitdo_statement(ctx
);
701 hres
= compile_exitfunc_statement(ctx
);
704 hres
= compile_exitprop_statement(ctx
);
707 hres
= compile_exitsub_statement(ctx
);
710 hres
= compile_function_statement(ctx
, (function_statement_t
*)stat
);
713 hres
= compile_if_statement(ctx
, (if_statement_t
*)stat
);
716 hres
= compile_assign_statement(ctx
, (assign_statement_t
*)stat
, TRUE
);
719 hres
= push_instr(ctx
, OP_stop
) == -1 ? E_OUTOFMEMORY
: S_OK
;
724 hres
= compile_while_statement(ctx
, (while_statement_t
*)stat
);
727 FIXME("Unimplemented statement type %d\n", stat
->type
);
739 static void resolve_labels(compile_ctx_t
*ctx
, unsigned off
)
743 for(instr
= ctx
->code
->instrs
+off
; instr
< ctx
->code
->instrs
+ctx
->instr_cnt
; instr
++) {
744 if(instr_info
[instr
->op
].arg1_type
== ARG_ADDR
&& (instr
->arg1
.uint
& LABEL_FLAG
)) {
745 assert((instr
->arg1
.uint
& ~LABEL_FLAG
) < ctx
->labels_cnt
);
746 instr
->arg1
.uint
= ctx
->labels
[instr
->arg1
.uint
& ~LABEL_FLAG
];
748 assert(instr_info
[instr
->op
].arg2_type
!= ARG_ADDR
);
754 static HRESULT
compile_func(compile_ctx_t
*ctx
, statement_t
*stat
, function_t
*func
)
758 func
->code_off
= ctx
->instr_cnt
;
760 ctx
->while_end_label
= -1;
761 ctx
->sub_end_label
= -1;
762 ctx
->func_end_label
= -1;
763 ctx
->prop_end_label
= -1;
767 ctx
->func_end_label
= alloc_label(ctx
);
768 if(ctx
->func_end_label
== -1)
769 return E_OUTOFMEMORY
; /* FIXME ! */
772 ctx
->sub_end_label
= alloc_label(ctx
);
773 if(ctx
->sub_end_label
== -1)
774 return E_OUTOFMEMORY
;
780 ctx
->prop_end_label
= alloc_label(ctx
);
781 if(ctx
->prop_end_label
== -1)
782 return E_OUTOFMEMORY
;
789 ctx
->dim_decls
= NULL
;
790 hres
= compile_statement(ctx
, stat
);
795 assert(ctx
->while_end_label
== -1);
797 if(ctx
->sub_end_label
!= -1)
798 label_set_addr(ctx
, ctx
->sub_end_label
);
799 if(ctx
->func_end_label
!= -1)
800 label_set_addr(ctx
, ctx
->func_end_label
);
801 if(ctx
->prop_end_label
!= -1)
802 label_set_addr(ctx
, ctx
->prop_end_label
);
804 if(push_instr(ctx
, OP_ret
) == -1)
805 return E_OUTOFMEMORY
;
807 resolve_labels(ctx
, func
->code_off
);
810 dim_decl_t
*dim_decl
;
812 if(func
->type
== FUNC_GLOBAL
) {
813 dynamic_var_t
*new_var
;
817 for(dim_decl
= ctx
->dim_decls
; dim_decl
; dim_decl
= dim_decl
->next
) {
818 new_var
= compiler_alloc(ctx
->code
, sizeof(*new_var
));
820 return E_OUTOFMEMORY
;
822 new_var
->name
= compiler_alloc_string(ctx
->code
, dim_decl
->name
);
824 return E_OUTOFMEMORY
;
826 V_VT(&new_var
->v
) = VT_EMPTY
;
828 new_var
->next
= ctx
->global_vars
;
829 ctx
->global_vars
= new_var
;
834 func
->vars
= compiler_alloc(ctx
->code
, func
->var_cnt
* sizeof(var_desc_t
));
836 return E_OUTOFMEMORY
;
838 for(dim_decl
= ctx
->dim_decls
, i
=0; dim_decl
; dim_decl
= dim_decl
->next
, i
++) {
839 func
->vars
[i
].name
= compiler_alloc_string(ctx
->code
, dim_decl
->name
);
840 if(!func
->vars
[i
].name
)
841 return E_OUTOFMEMORY
;
844 assert(i
== func
->var_cnt
);
851 static BOOL
lookup_funcs_name(compile_ctx_t
*ctx
, const WCHAR
*name
)
855 for(iter
= ctx
->funcs
; iter
; iter
= iter
->next
) {
856 if(!strcmpiW(iter
->name
, name
))
863 static HRESULT
create_function(compile_ctx_t
*ctx
, function_decl_t
*decl
, function_t
**ret
)
868 if(lookup_dim_decls(ctx
, decl
->name
) || lookup_funcs_name(ctx
, decl
->name
)) {
869 FIXME("%s: redefinition\n", debugstr_w(decl
->name
));
873 func
= compiler_alloc(ctx
->code
, sizeof(*func
));
875 return E_OUTOFMEMORY
;
877 func
->name
= compiler_alloc_string(ctx
->code
, decl
->name
);
879 return E_OUTOFMEMORY
;
883 func
->code_ctx
= ctx
->code
;
884 func
->type
= decl
->type
;
885 func
->is_public
= decl
->is_public
;
892 for(arg
= decl
->args
; arg
; arg
= arg
->next
)
895 func
->args
= compiler_alloc(ctx
->code
, func
->arg_cnt
* sizeof(arg_desc_t
));
897 return E_OUTOFMEMORY
;
899 for(i
= 0, arg
= decl
->args
; arg
; arg
= arg
->next
, i
++) {
900 func
->args
[i
].name
= compiler_alloc_string(ctx
->code
, arg
->name
);
901 if(!func
->args
[i
].name
)
902 return E_OUTOFMEMORY
;
903 func
->args
[i
].by_ref
= arg
->by_ref
;
909 hres
= compile_func(ctx
, decl
->body
, func
);
917 static BOOL
lookup_class_name(compile_ctx_t
*ctx
, const WCHAR
*name
)
921 for(iter
= ctx
->classes
; iter
; iter
= iter
->next
) {
922 if(!strcmpiW(iter
->name
, name
))
929 static HRESULT
create_class_funcprop(compile_ctx_t
*ctx
, function_decl_t
*func_decl
, vbdisp_funcprop_desc_t
*desc
)
931 vbdisp_invoke_type_t invoke_type
;
932 function_decl_t
*funcprop_decl
;
935 desc
->name
= compiler_alloc_string(ctx
->code
, func_decl
->name
);
937 return E_OUTOFMEMORY
;
939 for(funcprop_decl
= func_decl
; funcprop_decl
; funcprop_decl
= funcprop_decl
->next_prop_func
) {
940 switch(funcprop_decl
->type
) {
945 invoke_type
= VBDISP_CALLGET
;
948 invoke_type
= VBDISP_LET
;
951 invoke_type
= VBDISP_SET
;
957 assert(!desc
->entries
[invoke_type
]);
959 if(funcprop_decl
->is_public
)
960 desc
->is_public
= TRUE
;
962 hres
= create_function(ctx
, funcprop_decl
, desc
->entries
+invoke_type
);
970 static BOOL
lookup_class_funcs(class_desc_t
*class_desc
, const WCHAR
*name
)
974 for(i
=0; i
< class_desc
->func_cnt
; i
++) {
975 if(class_desc
->funcs
[i
].name
&& !strcmpiW(class_desc
->funcs
[i
].name
, name
))
982 static HRESULT
compile_class(compile_ctx_t
*ctx
, class_decl_t
*class_decl
)
984 function_decl_t
*func_decl
, *func_prop_decl
;
985 class_prop_decl_t
*prop_decl
;
986 class_desc_t
*class_desc
;
990 static const WCHAR class_initializeW
[] = {'c','l','a','s','s','_','i','n','i','t','i','a','l','i','z','e',0};
991 static const WCHAR class_terminateW
[] = {'c','l','a','s','s','_','t','e','r','m','i','n','a','t','e',0};
993 if(lookup_dim_decls(ctx
, class_decl
->name
) || lookup_funcs_name(ctx
, class_decl
->name
)
994 || lookup_class_name(ctx
, class_decl
->name
)) {
995 FIXME("%s: redefinition\n", debugstr_w(class_decl
->name
));
999 class_desc
= compiler_alloc(ctx
->code
, sizeof(*class_desc
));
1001 return E_OUTOFMEMORY
;
1003 class_desc
->name
= compiler_alloc_string(ctx
->code
, class_decl
->name
);
1004 if(!class_desc
->name
)
1005 return E_OUTOFMEMORY
;
1007 class_desc
->func_cnt
= 1; /* always allocate slot for default getter */
1008 class_desc
->prop_cnt
= 0;
1009 class_desc
->class_initialize_id
= 0;
1010 class_desc
->class_terminate_id
= 0;
1012 for(func_decl
= class_decl
->funcs
; func_decl
; func_decl
= func_decl
->next
) {
1013 for(func_prop_decl
= func_decl
; func_prop_decl
; func_prop_decl
= func_prop_decl
->next_prop_func
) {
1014 if(func_prop_decl
->type
== FUNC_DEFGET
)
1018 class_desc
->func_cnt
++;
1021 class_desc
->funcs
= compiler_alloc(ctx
->code
, class_desc
->func_cnt
*sizeof(*class_desc
->funcs
));
1022 if(!class_desc
->funcs
)
1023 return E_OUTOFMEMORY
;
1024 memset(class_desc
->funcs
, 0, class_desc
->func_cnt
*sizeof(*class_desc
->funcs
));
1026 for(func_decl
= class_decl
->funcs
, i
=1; func_decl
; func_decl
= func_decl
->next
, i
++) {
1027 for(func_prop_decl
= func_decl
; func_prop_decl
; func_prop_decl
= func_prop_decl
->next_prop_func
) {
1028 if(func_prop_decl
->type
== FUNC_DEFGET
) {
1034 if(!strcmpiW(class_initializeW
, func_decl
->name
)) {
1035 if(func_decl
->type
!= FUNC_SUB
) {
1036 FIXME("class initializer is not sub\n");
1040 class_desc
->class_initialize_id
= i
;
1041 }else if(!strcmpiW(class_terminateW
, func_decl
->name
)) {
1042 if(func_decl
->type
!= FUNC_SUB
) {
1043 FIXME("class terminator is not sub\n");
1047 class_desc
->class_terminate_id
= i
;
1050 hres
= create_class_funcprop(ctx
, func_decl
, class_desc
->funcs
+ (func_prop_decl
? 0 : i
));
1055 for(prop_decl
= class_decl
->props
; prop_decl
; prop_decl
= prop_decl
->next
)
1056 class_desc
->prop_cnt
++;
1058 class_desc
->props
= compiler_alloc(ctx
->code
, class_desc
->prop_cnt
*sizeof(*class_desc
->props
));
1059 if(!class_desc
->props
)
1060 return E_OUTOFMEMORY
;
1062 for(prop_decl
= class_decl
->props
, i
=0; prop_decl
; prop_decl
= prop_decl
->next
, i
++) {
1063 if(lookup_class_funcs(class_desc
, prop_decl
->name
)) {
1064 FIXME("Property %s redefined\n", debugstr_w(prop_decl
->name
));
1068 class_desc
->props
[i
].name
= compiler_alloc_string(ctx
->code
, prop_decl
->name
);
1069 if(!class_desc
->props
[i
].name
)
1070 return E_OUTOFMEMORY
;
1072 class_desc
->props
[i
].is_public
= prop_decl
->is_public
;
1075 class_desc
->next
= ctx
->classes
;
1076 ctx
->classes
= class_desc
;
1080 static BOOL
lookup_script_identifier(script_ctx_t
*script
, const WCHAR
*identifier
)
1082 class_desc_t
*class;
1086 for(var
= script
->global_vars
; var
; var
= var
->next
) {
1087 if(!strcmpiW(var
->name
, identifier
))
1091 for(func
= script
->global_funcs
; func
; func
= func
->next
) {
1092 if(!strcmpiW(func
->name
, identifier
))
1096 for(class = script
->classes
; class; class = class->next
) {
1097 if(!strcmpiW(class->name
, identifier
))
1104 static HRESULT
check_script_collisions(compile_ctx_t
*ctx
, script_ctx_t
*script
)
1106 class_desc_t
*class;
1110 for(var
= ctx
->global_vars
; var
; var
= var
->next
) {
1111 if(lookup_script_identifier(script
, var
->name
)) {
1112 FIXME("%s: redefined\n", debugstr_w(var
->name
));
1117 for(func
= ctx
->funcs
; func
; func
= func
->next
) {
1118 if(lookup_script_identifier(script
, func
->name
)) {
1119 FIXME("%s: redefined\n", debugstr_w(func
->name
));
1124 for(class = ctx
->classes
; class; class = class->next
) {
1125 if(lookup_script_identifier(script
, class->name
)) {
1126 FIXME("%s: redefined\n", debugstr_w(class->name
));
1134 void release_vbscode(vbscode_t
*code
)
1138 list_remove(&code
->entry
);
1140 for(i
=0; i
< code
->bstr_cnt
; i
++)
1141 SysFreeString(code
->bstr_pool
[i
]);
1143 vbsheap_free(&code
->heap
);
1145 heap_free(code
->bstr_pool
);
1146 heap_free(code
->source
);
1147 heap_free(code
->instrs
);
1151 static vbscode_t
*alloc_vbscode(compile_ctx_t
*ctx
, const WCHAR
*source
)
1155 ret
= heap_alloc(sizeof(*ret
));
1159 ret
->source
= heap_strdupW(source
);
1165 ret
->instrs
= heap_alloc(32*sizeof(instr_t
));
1167 release_vbscode(ret
);
1172 ctx
->instr_size
= 32;
1173 vbsheap_init(&ret
->heap
);
1175 ret
->option_explicit
= ctx
->parser
.option_explicit
;
1177 ret
->bstr_pool
= NULL
;
1178 ret
->bstr_pool_size
= 0;
1180 ret
->global_executed
= FALSE
;
1182 ret
->global_code
.type
= FUNC_GLOBAL
;
1183 ret
->global_code
.name
= NULL
;
1184 ret
->global_code
.code_ctx
= ret
;
1185 ret
->global_code
.vars
= NULL
;
1186 ret
->global_code
.var_cnt
= 0;
1187 ret
->global_code
.arg_cnt
= 0;
1188 ret
->global_code
.args
= NULL
;
1190 list_init(&ret
->entry
);
1194 static void release_compiler(compile_ctx_t
*ctx
)
1196 parser_release(&ctx
->parser
);
1197 heap_free(ctx
->labels
);
1199 release_vbscode(ctx
->code
);
1202 HRESULT
compile_script(script_ctx_t
*script
, const WCHAR
*src
, vbscode_t
**ret
)
1204 function_t
*new_func
;
1205 function_decl_t
*func_decl
;
1206 class_decl_t
*class_decl
;
1211 hres
= parse_script(&ctx
.parser
, src
);
1215 code
= ctx
.code
= alloc_vbscode(&ctx
, src
);
1217 return E_OUTOFMEMORY
;
1220 ctx
.func_decls
= NULL
;
1221 ctx
.global_vars
= NULL
;
1222 ctx
.dim_decls
= NULL
;
1225 ctx
.labels_cnt
= ctx
.labels_size
= 0;
1227 hres
= compile_func(&ctx
, ctx
.parser
.stats
, &ctx
.code
->global_code
);
1229 release_compiler(&ctx
);
1233 for(func_decl
= ctx
.func_decls
; func_decl
; func_decl
= func_decl
->next
) {
1234 hres
= create_function(&ctx
, func_decl
, &new_func
);
1236 release_compiler(&ctx
);
1240 new_func
->next
= ctx
.funcs
;
1241 ctx
.funcs
= new_func
;
1244 for(class_decl
= ctx
.parser
.class_decls
; class_decl
; class_decl
= class_decl
->next
) {
1245 hres
= compile_class(&ctx
, class_decl
);
1247 release_compiler(&ctx
);
1252 hres
= check_script_collisions(&ctx
, script
);
1254 release_compiler(&ctx
);
1258 if(ctx
.global_vars
) {
1261 for(var
= ctx
.global_vars
; var
->next
; var
= var
->next
);
1263 var
->next
= script
->global_vars
;
1264 script
->global_vars
= ctx
.global_vars
;
1268 for(new_func
= ctx
.funcs
; new_func
->next
; new_func
= new_func
->next
);
1270 new_func
->next
= script
->global_funcs
;
1271 script
->global_funcs
= ctx
.funcs
;
1275 class_desc_t
*class = ctx
.classes
;
1278 class->ctx
= script
;
1281 class = class->next
;
1284 class->next
= script
->classes
;
1285 script
->classes
= ctx
.classes
;
1288 if(TRACE_ON(vbscript_disas
))
1292 release_compiler(&ctx
);
1294 list_add_tail(&script
->code_list
, &code
->entry
);