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
);
37 static HRESULT
compile_expression(compile_ctx_t
*,expression_t
*);
39 static inline instr_t
*instr_ptr(compile_ctx_t
*ctx
, unsigned id
)
41 assert(id
< ctx
->instr_cnt
);
42 return ctx
->code
->instrs
+ id
;
45 static unsigned push_instr(compile_ctx_t
*ctx
, vbsop_t op
)
47 assert(ctx
->instr_size
&& ctx
->instr_size
>= ctx
->instr_cnt
);
49 if(ctx
->instr_size
== ctx
->instr_cnt
) {
52 new_instr
= heap_realloc(ctx
->code
->instrs
, ctx
->instr_size
*2*sizeof(instr_t
));
56 ctx
->code
->instrs
= new_instr
;
60 ctx
->code
->instrs
[ctx
->instr_cnt
].op
= op
;
61 return ctx
->instr_cnt
++;
64 static HRESULT
push_instr_int(compile_ctx_t
*ctx
, vbsop_t op
, LONG arg
)
68 ret
= push_instr(ctx
, op
);
72 instr_ptr(ctx
, ret
)->arg1
.lng
= arg
;
76 static HRESULT
push_instr_str(compile_ctx_t
*ctx
, vbsop_t op
, const WCHAR
*arg
)
80 ret
= push_instr(ctx
, op
);
84 instr_ptr(ctx
, ret
)->arg1
.str
= arg
;
88 static BSTR
alloc_bstr_arg(compile_ctx_t
*ctx
, const WCHAR
*str
)
90 if(!ctx
->code
->bstr_pool_size
) {
91 ctx
->code
->bstr_pool
= heap_alloc(8 * sizeof(BSTR
));
92 if(!ctx
->code
->bstr_pool
)
94 ctx
->code
->bstr_pool_size
= 8;
95 }else if(ctx
->code
->bstr_pool_size
== ctx
->code
->bstr_cnt
) {
98 new_pool
= heap_realloc(ctx
->code
->bstr_pool
, ctx
->code
->bstr_pool_size
*2*sizeof(BSTR
));
102 ctx
->code
->bstr_pool
= new_pool
;
103 ctx
->code
->bstr_pool_size
*= 2;
106 ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
] = SysAllocString(str
);
107 if(!ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
])
110 return ctx
->code
->bstr_pool
[ctx
->code
->bstr_cnt
++];
113 static HRESULT
push_instr_bstr_uint(compile_ctx_t
*ctx
, vbsop_t op
, const WCHAR
*arg1
, unsigned arg2
)
118 bstr
= alloc_bstr_arg(ctx
, arg1
);
120 return E_OUTOFMEMORY
;
122 instr
= push_instr(ctx
, op
);
124 return E_OUTOFMEMORY
;
126 instr_ptr(ctx
, instr
)->arg1
.bstr
= bstr
;
127 instr_ptr(ctx
, instr
)->arg2
.uint
= arg2
;
131 static HRESULT
compile_args(compile_ctx_t
*ctx
, expression_t
*args
, unsigned *ret
)
133 unsigned arg_cnt
= 0;
137 hres
= compile_expression(ctx
, args
);
149 static HRESULT
compile_member_expression(compile_ctx_t
*ctx
, member_expression_t
*expr
)
151 unsigned arg_cnt
= 0;
154 hres
= compile_args(ctx
, expr
->args
, &arg_cnt
);
159 FIXME("obj_expr not implemented\n");
162 hres
= push_instr_bstr_uint(ctx
, OP_icallv
, expr
->identifier
, arg_cnt
);
168 static HRESULT
compile_unary_expression(compile_ctx_t
*ctx
, unary_expression_t
*expr
, vbsop_t op
)
172 hres
= compile_expression(ctx
, expr
->subexpr
);
176 return push_instr(ctx
, op
) == -1 ? E_OUTOFMEMORY
: S_OK
;
179 static HRESULT
compile_expression(compile_ctx_t
*ctx
, expression_t
*expr
)
183 return push_instr_int(ctx
, OP_bool
, ((bool_expression_t
*)expr
)->value
);
185 return compile_unary_expression(ctx
, (unary_expression_t
*)expr
, OP_not
);
187 return push_instr_str(ctx
, OP_string
, ((string_expression_t
*)expr
)->value
);
189 FIXME("Unimplemented expression type %d\n", expr
->type
);
196 static HRESULT
compile_statement(compile_ctx_t
*ctx
, statement_t
*stat
)
203 hres
= compile_member_expression(ctx
, ((call_statement_t
*)stat
)->expr
);
206 FIXME("Unimplemented statement type %d\n", stat
->type
);
218 static HRESULT
compile_func(compile_ctx_t
*ctx
, statement_t
*stat
, function_t
*func
)
222 func
->code_off
= ctx
->instr_cnt
;
224 hres
= compile_statement(ctx
, stat
);
228 if(push_instr(ctx
, OP_ret
) == -1)
229 return E_OUTOFMEMORY
;
234 void release_vbscode(vbscode_t
*code
)
238 list_remove(&code
->entry
);
240 for(i
=0; i
< code
->bstr_cnt
; i
++)
241 SysFreeString(code
->bstr_pool
[i
]);
243 heap_free(code
->bstr_pool
);
244 heap_free(code
->source
);
245 heap_free(code
->instrs
);
249 static vbscode_t
*alloc_vbscode(compile_ctx_t
*ctx
, const WCHAR
*source
)
253 ret
= heap_alloc(sizeof(*ret
));
257 ret
->source
= heap_strdupW(source
);
263 ret
->instrs
= heap_alloc(32*sizeof(instr_t
));
265 release_vbscode(ret
);
270 ctx
->instr_size
= 32;
272 ret
->option_explicit
= ctx
->parser
.option_explicit
;
274 ret
->bstr_pool
= NULL
;
275 ret
->bstr_pool_size
= 0;
278 ret
->global_code
.code_ctx
= ret
;
280 list_init(&ret
->entry
);
284 HRESULT
compile_script(script_ctx_t
*script
, const WCHAR
*src
, vbscode_t
**ret
)
289 hres
= parse_script(&ctx
.parser
, src
);
293 ctx
.code
= alloc_vbscode(&ctx
, src
);
295 return E_OUTOFMEMORY
;
297 hres
= compile_func(&ctx
, ctx
.parser
.stats
, &ctx
.code
->global_code
);
299 release_vbscode(ctx
.code
);
303 list_add_tail(&script
->code_list
, &ctx
.code
->entry
);