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, BOOL ret_val)
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, ret_val ? OP_icall : 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_binary_expression(compile_ctx_t *ctx, binary_expression_t *expr, vbsop_t op)
183 hres = compile_expression(ctx, expr->left);
187 hres = compile_expression(ctx, expr->right);
191 return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
194 static HRESULT compile_expression(compile_ctx_t *ctx, expression_t *expr)
198 return push_instr_int(ctx, OP_bool, ((bool_expression_t*)expr)->value);
200 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_equal);
202 return compile_member_expression(ctx, (member_expression_t*)expr, TRUE);
204 return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_not);
206 return push_instr_str(ctx, OP_string, ((string_expression_t*)expr)->value);
208 FIXME("Unimplemented expression type %d\n", expr->type);
215 static HRESULT compile_statement(compile_ctx_t *ctx, statement_t *stat)
222 hres = compile_member_expression(ctx, ((call_statement_t*)stat)->expr, FALSE);
225 FIXME("Unimplemented statement type %d\n", stat->type);
237 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
241 func->code_off = ctx->instr_cnt;
243 hres = compile_statement(ctx, stat);
247 if(push_instr(ctx, OP_ret) == -1)
248 return E_OUTOFMEMORY;
253 void release_vbscode(vbscode_t *code)
257 list_remove(&code->entry);
259 for(i=0; i < code->bstr_cnt; i++)
260 SysFreeString(code->bstr_pool[i]);
262 heap_free(code->bstr_pool);
263 heap_free(code->source);
264 heap_free(code->instrs);
268 static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source)
272 ret = heap_alloc(sizeof(*ret));
276 ret->source = heap_strdupW(source);
282 ret->instrs = heap_alloc(32*sizeof(instr_t));
284 release_vbscode(ret);
289 ctx->instr_size = 32;
291 ret->option_explicit = ctx->parser.option_explicit;
293 ret->bstr_pool = NULL;
294 ret->bstr_pool_size = 0;
297 ret->global_code.code_ctx = ret;
299 list_init(&ret->entry);
303 HRESULT compile_script(script_ctx_t *script, const WCHAR *src, vbscode_t **ret)
308 hres = parse_script(&ctx.parser, src);
312 ctx.code = alloc_vbscode(&ctx, src);
314 return E_OUTOFMEMORY;
316 hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->global_code);
318 release_vbscode(ctx.code);
322 list_add_tail(&script->code_list, &ctx.code->entry);