?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove unused NONAMELESS defines.
[wine.git] / dlls / vbscript / compile.c
blobf86ecfded913e0e59cc7d23074527b6d6e2658f0
1 /*
2 * Copyright 2011 Jacek Caban for CodeWeavers
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #include <assert.h>
20
21 #include "vbscript.h"
22 #include "parse.h"
23 #include "parser.tab.h"
24
25 #include "wine/debug.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
28 WINE_DECLARE_DEBUG_CHANNEL(vbscript_disas);
29
30 typedef struct _statement_ctx_t {
31 unsigned stack_use;
32
33 unsigned while_end_label;
34 unsigned for_end_label;
35 unsigned with_stack_offset;
36
37 struct _statement_ctx_t *next;
38 } statement_ctx_t;
39
40 typedef struct {
41 parser_ctx_t parser;
42
43 unsigned instr_cnt;
44 unsigned instr_size;
45 vbscode_t *code;
46
47 unsigned loc;
48 statement_ctx_t *stat_ctx;
49
50 unsigned *labels;
51 unsigned labels_size;
52 unsigned labels_cnt;
53
54 unsigned sub_end_label;
55 unsigned func_end_label;
56 unsigned prop_end_label;
57
58 dim_decl_t *dim_decls;
59 dim_decl_t *dim_decls_tail;
60
61 const_decl_t *const_decls;
62 const_decl_t *global_consts;
63
64 function_t *func;
65 function_decl_t *func_decls;
66 } compile_ctx_t;
67
68 static HRESULT compile_expression(compile_ctx_t*,expression_t*);
69 static HRESULT compile_statement(compile_ctx_t*,statement_ctx_t*,statement_t*);
70
71 static const struct {
72 const char *op_str;
73 instr_arg_type_t arg1_type;
74 instr_arg_type_t arg2_type;
75 } instr_info[] = {
76 #define X(n,a,b,c) {#n,b,c},
77 OP_LIST
78 #undef X
79 };
80
81 static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg)
82 {
83 switch(type) {
84 case ARG_STR:
85 case ARG_BSTR:
86 TRACE_(vbscript_disas)("\t%s", debugstr_w(arg->str));
87 break;
88 case ARG_INT:
89 TRACE_(vbscript_disas)("\t%d", arg->uint);
90 break;
91 case ARG_UINT:
92 case ARG_ADDR:
93 TRACE_(vbscript_disas)("\t%u", arg->uint);
94 break;
95 case ARG_DATE:
96 case ARG_DOUBLE:
97 TRACE_(vbscript_disas)("\t%lf", *arg->dbl);
98 break;
99 case ARG_NONE:
100 break;
101 DEFAULT_UNREACHABLE;
102 }
103 }
104
105 static void dump_code(compile_ctx_t *ctx)
106 {
107 instr_t *instr;
108
109 for(instr = ctx->code->instrs+1; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
110 assert(instr->op < OP_LAST);
111 TRACE_(vbscript_disas)("%d:\t%s", (int)(instr-ctx->code->instrs), instr_info[instr->op].op_str);
112 dump_instr_arg(instr_info[instr->op].arg1_type, &instr->arg1);
113 dump_instr_arg(instr_info[instr->op].arg2_type, &instr->arg2);
114 TRACE_(vbscript_disas)("\n");
115 }
116 }
117
118 static inline void *compiler_alloc(vbscode_t *vbscode, size_t size)
119 {
120 return heap_pool_alloc(&vbscode->heap, size);
121 }
122
123 static inline void *compiler_alloc_zero(vbscode_t *vbscode, size_t size)
124 {
125 void *ret;
126
127 ret = heap_pool_alloc(&vbscode->heap, size);
128 if(ret)
129 memset(ret, 0, size);
130 return ret;
131 }
132
133 static WCHAR *compiler_alloc_string(vbscode_t *vbscode, const WCHAR *str)
134 {
135 size_t size;
136 WCHAR *ret;
137
138 size = (lstrlenW(str)+1)*sizeof(WCHAR);
139 ret = compiler_alloc(vbscode, size);
140 if(ret)
141 memcpy(ret, str, size);
142 return ret;
143 }
144
145 static inline instr_t *instr_ptr(compile_ctx_t *ctx, unsigned id)
146 {
147 assert(id < ctx->instr_cnt);
148 return ctx->code->instrs + id;
149 }
150
151 static unsigned push_instr(compile_ctx_t *ctx, vbsop_t op)
152 {
153 assert(ctx->instr_size && ctx->instr_size >= ctx->instr_cnt);
154
155 if(ctx->instr_size == ctx->instr_cnt) {
156 instr_t *new_instr;
157
158 new_instr = realloc(ctx->code->instrs, ctx->instr_size*2*sizeof(instr_t));
159 if(!new_instr)
160 return 0;
161
162 ctx->code->instrs = new_instr;
163 ctx->instr_size *= 2;
164 }
165
166 ctx->code->instrs[ctx->instr_cnt].op = op;
167 ctx->code->instrs[ctx->instr_cnt].loc = ctx->loc;
168 return ctx->instr_cnt++;
169 }
170
171 static HRESULT push_instr_int(compile_ctx_t *ctx, vbsop_t op, LONG arg)
172 {
173 unsigned ret;
174
175 ret = push_instr(ctx, op);
176 if(!ret)
177 return E_OUTOFMEMORY;
178
179 instr_ptr(ctx, ret)->arg1.lng = arg;
180 return S_OK;
181 }
182
183 static HRESULT push_instr_uint(compile_ctx_t *ctx, vbsop_t op, unsigned arg)
184 {
185 unsigned ret;
186
187 ret = push_instr(ctx, op);
188 if(!ret)
189 return E_OUTOFMEMORY;
190
191 instr_ptr(ctx, ret)->arg1.uint = arg;
192 return S_OK;
193 }
194
195 static HRESULT push_instr_addr(compile_ctx_t *ctx, vbsop_t op, unsigned arg)
196 {
197 unsigned ret;
198
199 ret = push_instr(ctx, op);
200 if(!ret)
201 return E_OUTOFMEMORY;
202
203 instr_ptr(ctx, ret)->arg1.uint = arg;
204 return S_OK;
205 }
206
207 static HRESULT push_instr_str(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg)
208 {
209 unsigned instr;
210 WCHAR *str;
211
212 str = compiler_alloc_string(ctx->code, arg);
213 if(!str)
214 return E_OUTOFMEMORY;
215
216 instr = push_instr(ctx, op);
217 if(!instr)
218 return E_OUTOFMEMORY;
219
220 instr_ptr(ctx, instr)->arg1.str = str;
221 return S_OK;
222 }
223
224 static HRESULT push_instr_double(compile_ctx_t *ctx, vbsop_t op, double arg)
225 {
226 unsigned instr;
227 double *d;
228
229 d = compiler_alloc(ctx->code, sizeof(double));
230 if(!d)
231 return E_OUTOFMEMORY;
232
233 instr = push_instr(ctx, op);
234 if(!instr)
235 return E_OUTOFMEMORY;
236
237 *d = arg;
238 instr_ptr(ctx, instr)->arg1.dbl = d;
239 return S_OK;
240 }
241
242 static HRESULT push_instr_date(compile_ctx_t *ctx, vbsop_t op, DATE arg)
243 {
244 unsigned instr;
245 DATE *d;
246
247 d = compiler_alloc(ctx->code, sizeof(DATE));
248 if(!d)
249 return E_OUTOFMEMORY;
250
251 instr = push_instr(ctx, op);
252 if(!instr)
253 return E_OUTOFMEMORY;
254
255 *d = arg;
256 instr_ptr(ctx, instr)->arg1.date = d;
257 return S_OK;
258 }
259
260 static BSTR alloc_bstr_arg(compile_ctx_t *ctx, const WCHAR *str)
261 {
262 if(!ctx->code->bstr_pool_size) {
263 ctx->code->bstr_pool = malloc(8 * sizeof(BSTR));
264 if(!ctx->code->bstr_pool)
265 return NULL;
266 ctx->code->bstr_pool_size = 8;
267 }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
268 BSTR *new_pool;
269
270 new_pool = realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
271 if(!new_pool)
272 return NULL;
273
274 ctx->code->bstr_pool = new_pool;
275 ctx->code->bstr_pool_size *= 2;
276 }
277
278 ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
279 if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
280 return NULL;
281
282 return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
283 }
284
285 static HRESULT push_instr_bstr(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg)
286 {
287 unsigned instr;
288 BSTR bstr;
289
290 bstr = alloc_bstr_arg(ctx, arg);
291 if(!bstr)
292 return E_OUTOFMEMORY;
293
294 instr = push_instr(ctx, op);
295 if(!instr)
296 return E_OUTOFMEMORY;
297
298 instr_ptr(ctx, instr)->arg1.bstr = bstr;
299 return S_OK;
300 }
301
302 static HRESULT push_instr_bstr_uint(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg1, unsigned arg2)
303 {
304 unsigned instr;
305 BSTR bstr;
306
307 bstr = alloc_bstr_arg(ctx, arg1);
308 if(!bstr)
309 return E_OUTOFMEMORY;
310
311 instr = push_instr(ctx, op);
312 if(!instr)
313 return E_OUTOFMEMORY;
314
315 instr_ptr(ctx, instr)->arg1.bstr = bstr;
316 instr_ptr(ctx, instr)->arg2.uint = arg2;
317 return S_OK;
318 }
319
320 static HRESULT push_instr_uint_bstr(compile_ctx_t *ctx, vbsop_t op, unsigned arg1, const WCHAR *arg2)
321 {
322 unsigned instr;
323 BSTR bstr;
324
325 bstr = alloc_bstr_arg(ctx, arg2);
326 if(!bstr)
327 return E_OUTOFMEMORY;
328
329 instr = push_instr(ctx, op);
330 if(!instr)
331 return E_OUTOFMEMORY;
332
333 instr_ptr(ctx, instr)->arg1.uint = arg1;
334 instr_ptr(ctx, instr)->arg2.bstr = bstr;
335 return S_OK;
336 }
337
338 #define LABEL_FLAG 0x80000000
339
340 static unsigned alloc_label(compile_ctx_t *ctx)
341 {
342 if(!ctx->labels_size) {
343 ctx->labels = malloc(8 * sizeof(*ctx->labels));
344 if(!ctx->labels)
345 return 0;
346 ctx->labels_size = 8;
347 }else if(ctx->labels_size == ctx->labels_cnt) {
348 unsigned *new_labels;
349
350 new_labels = realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
351 if(!new_labels)
352 return 0;
353
354 ctx->labels = new_labels;
355 ctx->labels_size *= 2;
356 }
357
358 return ctx->labels_cnt++ | LABEL_FLAG;
359 }
360
361 static inline void label_set_addr(compile_ctx_t *ctx, unsigned label)
362 {
363 assert(label & LABEL_FLAG);
364 ctx->labels[label & ~LABEL_FLAG] = ctx->instr_cnt;
365 }
366
367 static inline unsigned stack_offset(compile_ctx_t *ctx)
368 {
369 statement_ctx_t *iter;
370 unsigned ret = 0;
371
372 for(iter = ctx->stat_ctx; iter; iter = iter->next)
373 ret += iter->stack_use;
374
375 return ret;
376 }
377
378 static BOOL emit_catch_jmp(compile_ctx_t *ctx, unsigned stack_off, unsigned code_off)
379 {
380 unsigned code;
381
382 code = push_instr(ctx, OP_catch);
383 if(!code)
384 return FALSE;
385
386 instr_ptr(ctx, code)->arg1.uint = code_off;
387 instr_ptr(ctx, code)->arg2.uint = stack_off + stack_offset(ctx);
388 return TRUE;
389 }
390
391 static inline BOOL emit_catch(compile_ctx_t *ctx, unsigned off)
392 {
393 return emit_catch_jmp(ctx, off, ctx->instr_cnt);
394 }
395
396 static HRESULT compile_error(script_ctx_t *ctx, compile_ctx_t *compiler, HRESULT error)
397 {
398 if(error == SCRIPT_E_REPORTED)
399 return error;
400
401 clear_ei(&ctx->ei);
402 ctx->ei.scode = error;
403 ctx->ei.bstrSource = get_vbscript_string(VBS_COMPILE_ERROR);
404 map_vbs_exception(&ctx->ei);
405 return report_script_error(ctx, compiler->code, compiler->loc);
406 }
407
408 static expression_t *lookup_const_decls(compile_ctx_t *ctx, const WCHAR *name, BOOL lookup_global)
409 {
410 const_decl_t *decl;
411
412 for(decl = ctx->const_decls; decl; decl = decl->next) {
413 if(!wcsicmp(decl->name, name))
414 return decl->value_expr;
415 }
416
417 if(!lookup_global)
418 return NULL;
419
420 for(decl = ctx->global_consts; decl; decl = decl->next) {
421 if(!wcsicmp(decl->name, name))
422 return decl->value_expr;
423 }
424
425 return NULL;
426 }
427
428 static HRESULT compile_args(compile_ctx_t *ctx, expression_t *args, unsigned *ret)
429 {
430 unsigned arg_cnt = 0;
431 HRESULT hres;
432
433 while(args) {
434 hres = compile_expression(ctx, args);
435 if(FAILED(hres))
436 return hres;
437
438 if(args->type == EXPR_BRACKETS && !push_instr(ctx, OP_deref))
439 return E_OUTOFMEMORY;
440
441 arg_cnt++;
442 args = args->next;
443 }
444
445 *ret = arg_cnt;
446 return S_OK;
447 }
448
449 static HRESULT compile_member_call_expression(compile_ctx_t *ctx, member_expression_t *expr,
450 unsigned arg_cnt, BOOL ret_val)
451 {
452 HRESULT hres;
453
454 if(ret_val && !arg_cnt) {
455 expression_t *const_expr;
456
457 const_expr = lookup_const_decls(ctx, expr->identifier, TRUE);
458 if(const_expr)
459 return compile_expression(ctx, const_expr);
460 }
461
462 if(expr->obj_expr) {
463 hres = compile_expression(ctx, expr->obj_expr);
464 if(FAILED(hres))
465 return hres;
466
467 hres = push_instr_bstr_uint(ctx, ret_val ? OP_mcall : OP_mcallv, expr->identifier, arg_cnt);
468 }else {
469 hres = push_instr_bstr_uint(ctx, ret_val ? OP_icall : OP_icallv, expr->identifier, arg_cnt);
470 }
471
472 return hres;
473 }
474
475 static HRESULT compile_member_expression(compile_ctx_t *ctx, member_expression_t *expr)
476 {
477 expression_t *const_expr;
478
479 if (expr->obj_expr) /* FIXME: we should probably have a dedicated opcode as well */
480 return compile_member_call_expression(ctx, expr, 0, TRUE);
481
482 const_expr = lookup_const_decls(ctx, expr->identifier, TRUE);
483 if(const_expr)
484 return compile_expression(ctx, const_expr);
485
486 return push_instr_bstr(ctx, OP_ident, expr->identifier);
487 }
488
489 static HRESULT compile_call_expression(compile_ctx_t *ctx, call_expression_t *expr, BOOL ret_val)
490 {
491 unsigned arg_cnt = 0;
492 expression_t *call;
493 HRESULT hres;
494
495 hres = compile_args(ctx, expr->args, &arg_cnt);
496 if(FAILED(hres))
497 return hres;
498
499 for(call = expr->call_expr; call->type == EXPR_BRACKETS; call = ((unary_expression_t*)call)->subexpr);
500
501 if(call->type == EXPR_MEMBER)
502 return compile_member_call_expression(ctx, (member_expression_t*)call, arg_cnt, ret_val);
503
504 hres = compile_expression(ctx, call);
505 if(FAILED(hres))
506 return hres;
507
508 return push_instr_uint(ctx, ret_val ? OP_vcall : OP_vcallv, arg_cnt);
509 }
510
511 static HRESULT compile_dot_expression(compile_ctx_t *ctx)
512 {
513 statement_ctx_t *stat_ctx;
514
515 for(stat_ctx = ctx->stat_ctx; stat_ctx; stat_ctx = stat_ctx->next) {
516 if(!stat_ctx->with_stack_offset)
517 continue;
518
519 return push_instr_uint(ctx, OP_stack, stat_ctx->with_stack_offset - 1);
520 }
521
522 WARN("dot expression outside with statement\n");
523 return push_instr_uint(ctx, OP_stack, ~0);
524 }
525
526 static HRESULT compile_unary_expression(compile_ctx_t *ctx, unary_expression_t *expr, vbsop_t op)
527 {
528 HRESULT hres;
529
530 hres = compile_expression(ctx, expr->subexpr);
531 if(FAILED(hres))
532 return hres;
533
534 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
535 }
536
537 static HRESULT compile_binary_expression(compile_ctx_t *ctx, binary_expression_t *expr, vbsop_t op)
538 {
539 HRESULT hres;
540
541 hres = compile_expression(ctx, expr->left);
542 if(FAILED(hres))
543 return hres;
544
545 hres = compile_expression(ctx, expr->right);
546 if(FAILED(hres))
547 return hres;
548
549 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
550 }
551
552 static HRESULT compile_expression(compile_ctx_t *ctx, expression_t *expr)
553 {
554 switch(expr->type) {
555 case EXPR_ADD:
556 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
557 case EXPR_AND:
558 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
559 case EXPR_BOOL:
560 return push_instr_int(ctx, OP_bool, ((bool_expression_t*)expr)->value);
561 case EXPR_BRACKETS:
562 return compile_expression(ctx, ((unary_expression_t*)expr)->subexpr);
563 case EXPR_CALL:
564 return compile_call_expression(ctx, (call_expression_t*)expr, TRUE);
565 case EXPR_CONCAT:
566 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_concat);
567 case EXPR_DATE:
568 return push_instr_date(ctx, OP_date, ((date_expression_t*)expr)->value);
569 case EXPR_DIV:
570 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
571 case EXPR_DOT:
572 return compile_dot_expression(ctx);
573 case EXPR_DOUBLE:
574 return push_instr_double(ctx, OP_double, ((double_expression_t*)expr)->value);
575 case EXPR_EMPTY:
576 return push_instr(ctx, OP_empty) ? S_OK : E_OUTOFMEMORY;
577 case EXPR_EQUAL:
578 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_equal);
579 case EXPR_EQV:
580 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eqv);
581 case EXPR_EXP:
582 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_exp);
583 case EXPR_GT:
584 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
585 case EXPR_GTEQ:
586 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
587 case EXPR_IDIV:
588 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_idiv);
589 case EXPR_IS:
590 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_is);
591 case EXPR_IMP:
592 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_imp);
593 case EXPR_LT:
594 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
595 case EXPR_LTEQ:
596 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
597 case EXPR_ME:
598 return push_instr(ctx, OP_me) ? S_OK : E_OUTOFMEMORY;
599 case EXPR_MEMBER:
600 return compile_member_expression(ctx, (member_expression_t*)expr);
601 case EXPR_MOD:
602 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
603 case EXPR_MUL:
604 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
605 case EXPR_NEG:
606 return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
607 case EXPR_NEQUAL:
608 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_nequal);
609 case EXPR_NEW:
610 return push_instr_str(ctx, OP_new, ((string_expression_t*)expr)->value);
611 case EXPR_NOARG:
612 return push_instr_int(ctx, OP_hres, DISP_E_PARAMNOTFOUND);
613 case EXPR_NOT:
614 return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_not);
615 case EXPR_NOTHING:
616 return push_instr(ctx, OP_nothing) ? S_OK : E_OUTOFMEMORY;
617 case EXPR_NULL:
618 return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
619 case EXPR_OR:
620 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
621 case EXPR_STRING:
622 return push_instr_str(ctx, OP_string, ((string_expression_t*)expr)->value);
623 case EXPR_SUB:
624 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
625 case EXPR_INT:
626 return push_instr_int(ctx, OP_int, ((int_expression_t*)expr)->value);
627 case EXPR_XOR:
628 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
629 default:
630 FIXME("Unimplemented expression type %d\n", expr->type);
631 return E_NOTIMPL;
632 }
633
634 return S_OK;
635 }
636
637 static HRESULT compile_if_statement(compile_ctx_t *ctx, if_statement_t *stat)
638 {
639 unsigned cnd_jmp, endif_label = 0;
640 elseif_decl_t *elseif_decl;
641 HRESULT hres;
642
643 hres = compile_expression(ctx, stat->expr);
644 if(FAILED(hres))
645 return hres;
646
647 cnd_jmp = push_instr(ctx, OP_jmp_false);
648 if(!cnd_jmp)
649 return E_OUTOFMEMORY;
650
651 if(!emit_catch(ctx, 0))
652 return E_OUTOFMEMORY;
653
654 hres = compile_statement(ctx, NULL, stat->if_stat);
655 if(FAILED(hres))
656 return hres;
657
658 if(stat->else_stat || stat->elseifs) {
659 endif_label = alloc_label(ctx);
660 if(!endif_label)
661 return E_OUTOFMEMORY;
662
663 hres = push_instr_addr(ctx, OP_jmp, endif_label);
664 if(FAILED(hres))
665 return hres;
666 }
667
668 for(elseif_decl = stat->elseifs; elseif_decl; elseif_decl = elseif_decl->next) {
669 instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
670
671 ctx->loc = elseif_decl->loc;
672
673 hres = compile_expression(ctx, elseif_decl->expr);
674 if(FAILED(hres))
675 return hres;
676
677 cnd_jmp = push_instr(ctx, OP_jmp_false);
678 if(!cnd_jmp)
679 return E_OUTOFMEMORY;
680
681 if(!emit_catch(ctx, 0))
682 return E_OUTOFMEMORY;
683
684 hres = compile_statement(ctx, NULL, elseif_decl->stat);
685 if(FAILED(hres))
686 return hres;
687
688 hres = push_instr_addr(ctx, OP_jmp, endif_label);
689 if(FAILED(hres))
690 return hres;
691 }
692
693 instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
694
695 if(stat->else_stat) {
696 hres = compile_statement(ctx, NULL, stat->else_stat);
697 if(FAILED(hres))
698 return hres;
699 }
700
701 if(endif_label)
702 label_set_addr(ctx, endif_label);
703 return S_OK;
704 }
705
706 static HRESULT compile_while_statement(compile_ctx_t *ctx, while_statement_t *stat)
707 {
708 statement_ctx_t stat_ctx = {0}, *loop_ctx;
709 unsigned start_addr;
710 unsigned jmp_end;
711 HRESULT hres;
712
713 start_addr = ctx->instr_cnt;
714
715 hres = compile_expression(ctx, stat->expr);
716 if(FAILED(hres))
717 return hres;
718
719 jmp_end = push_instr(ctx, stat->stat.type == STAT_UNTIL ? OP_jmp_true : OP_jmp_false);
720 if(!jmp_end)
721 return E_OUTOFMEMORY;
722
723 if(!emit_catch(ctx, 0))
724 return E_OUTOFMEMORY;
725
726 if(stat->stat.type == STAT_WHILE) {
727 loop_ctx = NULL;
728 }else {
729 if(!(stat_ctx.while_end_label = alloc_label(ctx)))
730 return E_OUTOFMEMORY;
731 loop_ctx = &stat_ctx;
732 }
733
734 hres = compile_statement(ctx, loop_ctx, stat->body);
735 if(FAILED(hres))
736 return hres;
737
738 hres = push_instr_addr(ctx, OP_jmp, start_addr);
739 if(FAILED(hres))
740 return hres;
741
742 instr_ptr(ctx, jmp_end)->arg1.uint = ctx->instr_cnt;
743
744 if(loop_ctx)
745 label_set_addr(ctx, stat_ctx.while_end_label);
746
747 return S_OK;
748 }
749
750 static HRESULT compile_dowhile_statement(compile_ctx_t *ctx, while_statement_t *stat)
751 {
752 statement_ctx_t loop_ctx = {0};
753 unsigned start_addr;
754 vbsop_t jmp_op;
755 HRESULT hres;
756
757 start_addr = ctx->instr_cnt;
758
759 if(!(loop_ctx.while_end_label = alloc_label(ctx)))
760 return E_OUTOFMEMORY;
761
762 hres = compile_statement(ctx, &loop_ctx, stat->body);
763 if(FAILED(hres))
764 return hres;
765
766 ctx->loc = stat->stat.loc;
767 if(stat->expr) {
768 hres = compile_expression(ctx, stat->expr);
769 if(FAILED(hres))
770 return hres;
771
772 jmp_op = stat->stat.type == STAT_DOUNTIL ? OP_jmp_false : OP_jmp_true;
773 }else {
774 jmp_op = OP_jmp;
775 }
776
777 hres = push_instr_addr(ctx, jmp_op, start_addr);
778 if(FAILED(hres))
779 return hres;
780
781 label_set_addr(ctx, loop_ctx.while_end_label);
782
783 if(!emit_catch(ctx, 0))
784 return E_OUTOFMEMORY;
785
786 return S_OK;
787 }
788
789 static HRESULT compile_foreach_statement(compile_ctx_t *ctx, foreach_statement_t *stat)
790 {
791 statement_ctx_t loop_ctx = {1};
792 unsigned loop_start;
793 HRESULT hres;
794
795 /* Preserve a place on the stack in case we throw before having proper enum collection. */
796 if(!push_instr(ctx, OP_empty))
797 return E_OUTOFMEMORY;
798
799 hres = compile_expression(ctx, stat->group_expr);
800 if(FAILED(hres))
801 return hres;
802
803 if(!push_instr(ctx, OP_newenum))
804 return E_OUTOFMEMORY;
805
806 if(!(loop_ctx.for_end_label = alloc_label(ctx)))
807 return E_OUTOFMEMORY;
808
809 hres = push_instr_uint_bstr(ctx, OP_enumnext, loop_ctx.for_end_label, stat->identifier);
810 if(FAILED(hres))
811 return hres;
812
813 if(!emit_catch(ctx, 1))
814 return E_OUTOFMEMORY;
815
816 loop_start = ctx->instr_cnt;
817 hres = compile_statement(ctx, &loop_ctx, stat->body);
818 if(FAILED(hres))
819 return hres;
820
821 /* We need a separated enumnext here, because we need to jump out of the loop on exception. */
822 ctx->loc = stat->stat.loc;
823 hres = push_instr_uint_bstr(ctx, OP_enumnext, loop_ctx.for_end_label, stat->identifier);
824 if(FAILED(hres))
825 return hres;
826
827 hres = push_instr_addr(ctx, OP_jmp, loop_start);
828 if(FAILED(hres))
829 return hres;
830
831 label_set_addr(ctx, loop_ctx.for_end_label);
832
833 if(!emit_catch(ctx, 0))
834 return E_OUTOFMEMORY;
835
836 return S_OK;
837 }
838
839 static HRESULT compile_forto_statement(compile_ctx_t *ctx, forto_statement_t *stat)
840 {
841 statement_ctx_t loop_ctx = {2};
842 unsigned step_instr, instr;
843 BSTR identifier;
844 HRESULT hres;
845
846 identifier = alloc_bstr_arg(ctx, stat->identifier);
847 if(!identifier)
848 return E_OUTOFMEMORY;
849
850 hres = compile_expression(ctx, stat->from_expr);
851 if(FAILED(hres))
852 return hres;
853
854 /* FIXME: Assign should happen after both expressions evaluation. */
855 instr = push_instr(ctx, OP_assign_ident);
856 if(!instr)
857 return E_OUTOFMEMORY;
858 instr_ptr(ctx, instr)->arg1.bstr = identifier;
859 instr_ptr(ctx, instr)->arg2.uint = 0;
860
861 hres = compile_expression(ctx, stat->to_expr);
862 if(FAILED(hres))
863 return hres;
864
865 if(!push_instr(ctx, OP_val))
866 return E_OUTOFMEMORY;
867
868 if(stat->step_expr) {
869 hres = compile_expression(ctx, stat->step_expr);
870 if(FAILED(hres))
871 return hres;
872
873 if(!push_instr(ctx, OP_val))
874 return E_OUTOFMEMORY;
875 }else {
876 hres = push_instr_int(ctx, OP_int, 1);
877 if(FAILED(hres))
878 return hres;
879 }
880
881 loop_ctx.for_end_label = alloc_label(ctx);
882 if(!loop_ctx.for_end_label)
883 return E_OUTOFMEMORY;
884
885 step_instr = push_instr(ctx, OP_step);
886 if(!step_instr)
887 return E_OUTOFMEMORY;
888 instr_ptr(ctx, step_instr)->arg2.bstr = identifier;
889 instr_ptr(ctx, step_instr)->arg1.uint = loop_ctx.for_end_label;
890
891 if(!emit_catch(ctx, 2))
892 return E_OUTOFMEMORY;
893
894 hres = compile_statement(ctx, &loop_ctx, stat->body);
895 if(FAILED(hres))
896 return hres;
897
898 /* FIXME: Error handling can't be done compatible with native using OP_incc here. */
899 instr = push_instr(ctx, OP_incc);
900 if(!instr)
901 return E_OUTOFMEMORY;
902 instr_ptr(ctx, instr)->arg1.bstr = identifier;
903
904 hres = push_instr_addr(ctx, OP_jmp, step_instr);
905 if(FAILED(hres))
906 return hres;
907
908 hres = push_instr_uint(ctx, OP_pop, 2);
909 if(FAILED(hres))
910 return hres;
911
912 label_set_addr(ctx, loop_ctx.for_end_label);
913
914 /* FIXME: reconsider after OP_incc fixup. */
915 if(!emit_catch(ctx, 0))
916 return E_OUTOFMEMORY;
917
918 return S_OK;
919 }
920
921 static HRESULT compile_with_statement(compile_ctx_t *ctx, with_statement_t *stat)
922 {
923 statement_ctx_t with_ctx = { 1 };
924 HRESULT hres;
925
926 hres = compile_expression(ctx, stat->expr);
927 if(FAILED(hres))
928 return hres;
929
930 if(!emit_catch(ctx, 1))
931 return E_OUTOFMEMORY;
932
933 with_ctx.with_stack_offset = stack_offset(ctx) + 1;
934 hres = compile_statement(ctx, &with_ctx, stat->body);
935 if(FAILED(hres))
936 return hres;
937
938 return push_instr_uint(ctx, OP_pop, 1);
939 }
940
941 static HRESULT compile_select_statement(compile_ctx_t *ctx, select_statement_t *stat)
942 {
943 unsigned end_label, case_cnt = 0, *case_labels = NULL, i;
944 case_clausule_t *case_iter;
945 expression_t *expr_iter;
946 HRESULT hres;
947
948 hres = compile_expression(ctx, stat->expr);
949 if(FAILED(hres))
950 return hres;
951
952 if(!push_instr(ctx, OP_val))
953 return E_OUTOFMEMORY;
954
955 end_label = alloc_label(ctx);
956 if(!end_label)
957 return E_OUTOFMEMORY;
958
959 if(!emit_catch_jmp(ctx, 0, end_label))
960 return E_OUTOFMEMORY;
961
962 for(case_iter = stat->case_clausules; case_iter; case_iter = case_iter->next)
963 case_cnt++;
964
965 if(case_cnt) {
966 case_labels = malloc(case_cnt*sizeof(*case_labels));
967 if(!case_labels)
968 return E_OUTOFMEMORY;
969 }
970
971 for(case_iter = stat->case_clausules, i=0; case_iter; case_iter = case_iter->next, i++) {
972 case_labels[i] = alloc_label(ctx);
973 if(!case_labels[i]) {
974 hres = E_OUTOFMEMORY;
975 break;
976 }
977
978 if(!case_iter->expr)
979 break;
980
981 for(expr_iter = case_iter->expr; expr_iter; expr_iter = expr_iter->next) {
982 hres = compile_expression(ctx, expr_iter);
983 if(FAILED(hres))
984 break;
985
986 hres = push_instr_addr(ctx, OP_case, case_labels[i]);
987 if(FAILED(hres))
988 break;
989
990 if(!emit_catch_jmp(ctx, 0, case_labels[i])) {
991 hres = E_OUTOFMEMORY;
992 break;
993 }
994 }
995 }
996
997 if(FAILED(hres)) {
998 free(case_labels);
999 return hres;
1000 }
1001
1002 hres = push_instr_uint(ctx, OP_pop, 1);
1003 if(FAILED(hres)) {
1004 free(case_labels);
1005 return hres;
1006 }
1007
1008 hres = push_instr_addr(ctx, OP_jmp, case_iter ? case_labels[i] : end_label);
1009 if(FAILED(hres)) {
1010 free(case_labels);
1011 return hres;
1012 }
1013
1014 for(case_iter = stat->case_clausules, i=0; case_iter; case_iter = case_iter->next, i++) {
1015 label_set_addr(ctx, case_labels[i]);
1016 hres = compile_statement(ctx, NULL, case_iter->stat);
1017 if(FAILED(hres))
1018 break;
1019
1020 if(!case_iter->next)
1021 break;
1022
1023 hres = push_instr_addr(ctx, OP_jmp, end_label);
1024 if(FAILED(hres))
1025 break;
1026 }
1027
1028 free(case_labels);
1029 if(FAILED(hres))
1030 return hres;
1031
1032 label_set_addr(ctx, end_label);
1033 return S_OK;
1034 }
1035
1036 static HRESULT compile_assignment(compile_ctx_t *ctx, expression_t *left, expression_t *value_expr, BOOL is_set)
1037 {
1038 call_expression_t *call_expr = NULL;
1039 member_expression_t *member_expr;
1040 unsigned args_cnt = 0;
1041 vbsop_t op;
1042 HRESULT hres;
1043
1044 switch(left->type) {
1045 case EXPR_MEMBER:
1046 member_expr = (member_expression_t*)left;
1047 break;
1048 case EXPR_CALL:
1049 call_expr = (call_expression_t*)left;
1050 assert(call_expr->call_expr->type == EXPR_MEMBER);
1051 member_expr = (member_expression_t*)call_expr->call_expr;
1052 break;
1053 default:
1054 assert(0);
1055 return E_FAIL;
1056 }
1057
1058 if(member_expr->obj_expr) {
1059 hres = compile_expression(ctx, member_expr->obj_expr);
1060 if(FAILED(hres))
1061 return hres;
1062
1063 op = is_set ? OP_set_member : OP_assign_member;
1064 }else {
1065 op = is_set ? OP_set_ident : OP_assign_ident;
1066 }
1067
1068 hres = compile_expression(ctx, value_expr);
1069 if(FAILED(hres))
1070 return hres;
1071
1072 if(call_expr) {
1073 hres = compile_args(ctx, call_expr->args, &args_cnt);
1074 if(FAILED(hres))
1075 return hres;
1076 }
1077
1078 hres = push_instr_bstr_uint(ctx, op, member_expr->identifier, args_cnt);
1079 if(FAILED(hres))
1080 return hres;
1081
1082 if(!emit_catch(ctx, 0))
1083 return E_OUTOFMEMORY;
1084
1085 return S_OK;
1086 }
1087
1088 static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *stat, BOOL is_set)
1089 {
1090 return compile_assignment(ctx, stat->left_expr, stat->value_expr, is_set);
1091 }
1092
1093 static HRESULT compile_call_statement(compile_ctx_t *ctx, call_statement_t *stat)
1094 {
1095 HRESULT hres;
1096
1097 hres = compile_call_expression(ctx, stat->expr, FALSE);
1098 if(FAILED(hres))
1099 return hres;
1100
1101 if(!emit_catch(ctx, 0))
1102 return E_OUTOFMEMORY;
1103
1104 return S_OK;
1105 }
1106
1107 static BOOL lookup_dim_decls(compile_ctx_t *ctx, const WCHAR *name)
1108 {
1109 dim_decl_t *dim_decl;
1110
1111 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
1112 if(!wcsicmp(dim_decl->name, name))
1113 return TRUE;
1114 }
1115
1116 return FALSE;
1117 }
1118
1119 static BOOL lookup_args_name(compile_ctx_t *ctx, const WCHAR *name)
1120 {
1121 unsigned i;
1122
1123 for(i = 0; i < ctx->func->arg_cnt; i++) {
1124 if(!wcsicmp(ctx->func->args[i].name, name))
1125 return TRUE;
1126 }
1127
1128 return FALSE;
1129 }
1130
1131 static HRESULT compile_dim_statement(compile_ctx_t *ctx, dim_statement_t *stat)
1132 {
1133 dim_decl_t *dim_decl = stat->dim_decls;
1134
1135 while(1) {
1136 if(lookup_dim_decls(ctx, dim_decl->name) || lookup_args_name(ctx, dim_decl->name)
1137 || lookup_const_decls(ctx, dim_decl->name, FALSE)) {
1138 FIXME("dim %s name redefined\n", debugstr_w(dim_decl->name));
1139 return E_FAIL;
1140 }
1141
1142 ctx->func->var_cnt++;
1143
1144 if(dim_decl->is_array) {
1145 HRESULT hres = push_instr_bstr_uint(ctx, OP_dim, dim_decl->name, ctx->func->array_cnt++);
1146 if(FAILED(hres))
1147 return hres;
1148
1149 if(!emit_catch(ctx, 0))
1150 return E_OUTOFMEMORY;
1151 }
1152
1153 if(!dim_decl->next)
1154 break;
1155 dim_decl = dim_decl->next;
1156 }
1157
1158 if(ctx->dim_decls_tail)
1159 ctx->dim_decls_tail->next = stat->dim_decls;
1160 else
1161 ctx->dim_decls = stat->dim_decls;
1162 ctx->dim_decls_tail = dim_decl;
1163 return S_OK;
1164 }
1165
1166 static HRESULT compile_redim_statement(compile_ctx_t *ctx, redim_statement_t *stat)
1167 {
1168 redim_decl_t *decl = stat->redim_decls;
1169 unsigned arg_cnt;
1170 HRESULT hres;
1171
1172 while(1) {
1173 hres = compile_args(ctx, decl->dims, &arg_cnt);
1174 if(FAILED(hres))
1175 return hres;
1176
1177 hres = push_instr_bstr_uint(ctx, stat->preserve ? OP_redim_preserve : OP_redim, decl->identifier, arg_cnt);
1178 if(FAILED(hres))
1179 return hres;
1180
1181 if(!emit_catch(ctx, 0))
1182 return E_OUTOFMEMORY;
1183
1184 if(!decl->next)
1185 break;
1186 decl = decl->next;
1187 }
1188
1189 return S_OK;
1190 }
1191
1192 static HRESULT compile_const_statement(compile_ctx_t *ctx, const_statement_t *stat)
1193 {
1194 const_decl_t *decl, *next_decl = stat->decls;
1195
1196 do {
1197 decl = next_decl;
1198
1199 if(lookup_const_decls(ctx, decl->name, FALSE) || lookup_args_name(ctx, decl->name)
1200 || lookup_dim_decls(ctx, decl->name)) {
1201 FIXME("%s redefined\n", debugstr_w(decl->name));
1202 return E_FAIL;
1203 }
1204
1205 if(ctx->func->type == FUNC_GLOBAL) {
1206 HRESULT hres;
1207
1208 hres = compile_expression(ctx, decl->value_expr);
1209 if(FAILED(hres))
1210 return hres;
1211
1212 hres = push_instr_bstr(ctx, OP_const, decl->name);
1213 if(FAILED(hres))
1214 return hres;
1215
1216 if(!emit_catch(ctx, 0))
1217 return E_OUTOFMEMORY;
1218 }
1219
1220 next_decl = decl->next;
1221 decl->next = ctx->const_decls;
1222 ctx->const_decls = decl;
1223 } while(next_decl);
1224
1225 return S_OK;
1226 }
1227
1228 static HRESULT compile_function_statement(compile_ctx_t *ctx, function_statement_t *stat)
1229 {
1230 if(ctx->func != &ctx->code->main_code) {
1231 FIXME("Function is not in the global code\n");
1232 return E_FAIL;
1233 }
1234
1235 stat->func_decl->next = ctx->func_decls;
1236 ctx->func_decls = stat->func_decl;
1237 return S_OK;
1238 }
1239
1240 static HRESULT compile_exitdo_statement(compile_ctx_t *ctx)
1241 {
1242 statement_ctx_t *iter;
1243 unsigned pop_cnt = 0;
1244
1245 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1246 pop_cnt += iter->stack_use;
1247 if(iter->while_end_label)
1248 break;
1249 }
1250 if(!iter) {
1251 FIXME("Exit Do outside Do Loop\n");
1252 return E_FAIL;
1253 }
1254
1255 if(pop_cnt) {
1256 HRESULT hres;
1257
1258 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1259 if(FAILED(hres))
1260 return hres;
1261 }
1262
1263 return push_instr_addr(ctx, OP_jmp, iter->while_end_label);
1264 }
1265
1266 static HRESULT compile_exitfor_statement(compile_ctx_t *ctx)
1267 {
1268 statement_ctx_t *iter;
1269 unsigned pop_cnt = 0;
1270
1271 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1272 pop_cnt += iter->stack_use;
1273 if(iter->for_end_label)
1274 break;
1275 }
1276 if(!iter) {
1277 FIXME("Exit For outside For loop\n");
1278 return E_FAIL;
1279 }
1280
1281 if(pop_cnt) {
1282 HRESULT hres;
1283
1284 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1285 if(FAILED(hres))
1286 return hres;
1287 }
1288
1289 return push_instr_addr(ctx, OP_jmp, iter->for_end_label);
1290 }
1291
1292 static HRESULT exit_label(compile_ctx_t *ctx, unsigned jmp_label)
1293 {
1294 unsigned pop_cnt = stack_offset(ctx);
1295
1296 if(pop_cnt) {
1297 HRESULT hres;
1298
1299 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1300 if(FAILED(hres))
1301 return hres;
1302 }
1303
1304 return push_instr_addr(ctx, OP_jmp, jmp_label);
1305 }
1306
1307 static HRESULT compile_exitsub_statement(compile_ctx_t *ctx)
1308 {
1309 if(!ctx->sub_end_label) {
1310 FIXME("Exit Sub outside Sub?\n");
1311 return E_FAIL;
1312 }
1313
1314 return exit_label(ctx, ctx->sub_end_label);
1315 }
1316
1317 static HRESULT compile_exitfunc_statement(compile_ctx_t *ctx)
1318 {
1319 if(!ctx->func_end_label) {
1320 FIXME("Exit Function outside Function?\n");
1321 return E_FAIL;
1322 }
1323
1324 return exit_label(ctx, ctx->func_end_label);
1325 }
1326
1327 static HRESULT compile_exitprop_statement(compile_ctx_t *ctx)
1328 {
1329 if(!ctx->prop_end_label) {
1330 FIXME("Exit Property outside Property?\n");
1331 return E_FAIL;
1332 }
1333
1334 return exit_label(ctx, ctx->prop_end_label);
1335 }
1336
1337 static HRESULT compile_onerror_statement(compile_ctx_t *ctx, onerror_statement_t *stat)
1338 {
1339 return push_instr_int(ctx, OP_errmode, stat->resume_next);
1340 }
1341
1342 static HRESULT compile_retval_statement(compile_ctx_t *ctx, retval_statement_t *stat)
1343 {
1344 HRESULT hres;
1345
1346 hres = compile_expression(ctx, stat->expr);
1347 if(FAILED(hres))
1348 return hres;
1349
1350 hres = push_instr(ctx, OP_retval);
1351 if(FAILED(hres))
1352 return hres;
1353
1354 return S_OK;
1355 }
1356
1357 static HRESULT compile_statement(compile_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
1358 {
1359 HRESULT hres;
1360
1361 if(stat_ctx) {
1362 stat_ctx->next = ctx->stat_ctx;
1363 ctx->stat_ctx = stat_ctx;
1364 }
1365
1366 while(stat) {
1367 ctx->loc = stat->loc;
1368
1369 switch(stat->type) {
1370 case STAT_ASSIGN:
1371 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, FALSE);
1372 break;
1373 case STAT_CALL:
1374 hres = compile_call_statement(ctx, (call_statement_t*)stat);
1375 break;
1376 case STAT_CONST:
1377 hres = compile_const_statement(ctx, (const_statement_t*)stat);
1378 break;
1379 case STAT_DIM:
1380 hres = compile_dim_statement(ctx, (dim_statement_t*)stat);
1381 break;
1382 case STAT_DOWHILE:
1383 case STAT_DOUNTIL:
1384 hres = compile_dowhile_statement(ctx, (while_statement_t*)stat);
1385 break;
1386 case STAT_EXITDO:
1387 hres = compile_exitdo_statement(ctx);
1388 break;
1389 case STAT_EXITFOR:
1390 hres = compile_exitfor_statement(ctx);
1391 break;
1392 case STAT_EXITFUNC:
1393 hres = compile_exitfunc_statement(ctx);
1394 break;
1395 case STAT_EXITPROP:
1396 hres = compile_exitprop_statement(ctx);
1397 break;
1398 case STAT_EXITSUB:
1399 hres = compile_exitsub_statement(ctx);
1400 break;
1401 case STAT_FOREACH:
1402 hres = compile_foreach_statement(ctx, (foreach_statement_t*)stat);
1403 break;
1404 case STAT_FORTO:
1405 hres = compile_forto_statement(ctx, (forto_statement_t*)stat);
1406 break;
1407 case STAT_FUNC:
1408 hres = compile_function_statement(ctx, (function_statement_t*)stat);
1409 break;
1410 case STAT_IF:
1411 hres = compile_if_statement(ctx, (if_statement_t*)stat);
1412 break;
1413 case STAT_ONERROR:
1414 hres = compile_onerror_statement(ctx, (onerror_statement_t*)stat);
1415 break;
1416 case STAT_REDIM:
1417 hres = compile_redim_statement(ctx, (redim_statement_t*)stat);
1418 break;
1419 case STAT_SELECT:
1420 hres = compile_select_statement(ctx, (select_statement_t*)stat);
1421 break;
1422 case STAT_SET:
1423 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, TRUE);
1424 break;
1425 case STAT_STOP:
1426 hres = push_instr(ctx, OP_stop) ? S_OK : E_OUTOFMEMORY;
1427 break;
1428 case STAT_UNTIL:
1429 case STAT_WHILE:
1430 case STAT_WHILELOOP:
1431 hres = compile_while_statement(ctx, (while_statement_t*)stat);
1432 break;
1433 case STAT_WITH:
1434 hres = compile_with_statement(ctx, (with_statement_t*)stat);
1435 break;
1436 case STAT_RETVAL:
1437 hres = compile_retval_statement(ctx, (retval_statement_t*)stat);
1438 break;
1439 default:
1440 FIXME("Unimplemented statement type %d\n", stat->type);
1441 hres = E_NOTIMPL;
1442 }
1443
1444 if(FAILED(hres))
1445 return hres;
1446 stat = stat->next;
1447 }
1448
1449 if(stat_ctx) {
1450 assert(ctx->stat_ctx == stat_ctx);
1451 ctx->stat_ctx = stat_ctx->next;
1452 }
1453
1454 return S_OK;
1455 }
1456
1457 static void resolve_labels(compile_ctx_t *ctx, unsigned off)
1458 {
1459 instr_t *instr;
1460
1461 for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
1462 if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->arg1.uint & LABEL_FLAG)) {
1463 assert((instr->arg1.uint & ~LABEL_FLAG) < ctx->labels_cnt);
1464 instr->arg1.uint = ctx->labels[instr->arg1.uint & ~LABEL_FLAG];
1465 }
1466 assert(instr_info[instr->op].arg2_type != ARG_ADDR);
1467 }
1468
1469 ctx->labels_cnt = 0;
1470 }
1471
1472 static HRESULT fill_array_desc(compile_ctx_t *ctx, dim_decl_t *dim_decl, array_desc_t *array_desc)
1473 {
1474 unsigned dim_cnt = 0, i;
1475 dim_list_t *iter;
1476
1477 for(iter = dim_decl->dims; iter; iter = iter->next)
1478 dim_cnt++;
1479
1480 array_desc->bounds = compiler_alloc(ctx->code, dim_cnt * sizeof(SAFEARRAYBOUND));
1481 if(!array_desc->bounds)
1482 return E_OUTOFMEMORY;
1483
1484 array_desc->dim_cnt = dim_cnt;
1485
1486 for(iter = dim_decl->dims, i=0; iter; iter = iter->next, i++) {
1487 array_desc->bounds[i].cElements = iter->val+1;
1488 array_desc->bounds[i].lLbound = 0;
1489 }
1490
1491 return S_OK;
1492 }
1493
1494 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
1495 {
1496 HRESULT hres;
1497
1498 func->code_off = ctx->instr_cnt;
1499
1500 ctx->sub_end_label = 0;
1501 ctx->func_end_label = 0;
1502 ctx->prop_end_label = 0;
1503
1504 switch(func->type) {
1505 case FUNC_FUNCTION:
1506 ctx->func_end_label = alloc_label(ctx);
1507 if(!ctx->func_end_label)
1508 return E_OUTOFMEMORY;
1509 break;
1510 case FUNC_SUB:
1511 ctx->sub_end_label = alloc_label(ctx);
1512 if(!ctx->sub_end_label)
1513 return E_OUTOFMEMORY;
1514 break;
1515 case FUNC_PROPGET:
1516 case FUNC_PROPLET:
1517 case FUNC_PROPSET:
1518 ctx->prop_end_label = alloc_label(ctx);
1519 if(!ctx->prop_end_label)
1520 return E_OUTOFMEMORY;
1521 break;
1522 case FUNC_GLOBAL:
1523 break;
1524 }
1525
1526 ctx->func = func;
1527 ctx->dim_decls = ctx->dim_decls_tail = NULL;
1528 ctx->const_decls = NULL;
1529 hres = compile_statement(ctx, NULL, stat);
1530 ctx->func = NULL;
1531 if(FAILED(hres))
1532 return hres;
1533
1534 if(ctx->sub_end_label)
1535 label_set_addr(ctx, ctx->sub_end_label);
1536 if(ctx->func_end_label)
1537 label_set_addr(ctx, ctx->func_end_label);
1538 if(ctx->prop_end_label)
1539 label_set_addr(ctx, ctx->prop_end_label);
1540
1541 if(!push_instr(ctx, OP_ret))
1542 return E_OUTOFMEMORY;
1543
1544 resolve_labels(ctx, func->code_off);
1545
1546 if(func->var_cnt) {
1547 dim_decl_t *dim_decl;
1548 unsigned i;
1549
1550 func->vars = compiler_alloc(ctx->code, func->var_cnt * sizeof(var_desc_t));
1551 if(!func->vars)
1552 return E_OUTOFMEMORY;
1553
1554 for(dim_decl = ctx->dim_decls, i=0; dim_decl; dim_decl = dim_decl->next, i++) {
1555 func->vars[i].name = compiler_alloc_string(ctx->code, dim_decl->name);
1556 if(!func->vars[i].name)
1557 return E_OUTOFMEMORY;
1558 }
1559
1560 assert(i == func->var_cnt);
1561 }
1562
1563 if(func->array_cnt) {
1564 unsigned array_id = 0;
1565 dim_decl_t *dim_decl;
1566
1567 func->array_descs = compiler_alloc(ctx->code, func->array_cnt * sizeof(array_desc_t));
1568 if(!func->array_descs)
1569 return E_OUTOFMEMORY;
1570
1571 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
1572 if(dim_decl->is_array) {
1573 hres = fill_array_desc(ctx, dim_decl, func->array_descs + array_id++);
1574 if(FAILED(hres))
1575 return hres;
1576 }
1577 }
1578
1579 assert(array_id == func->array_cnt);
1580 }
1581
1582 return S_OK;
1583 }
1584
1585 static BOOL lookup_funcs_name(compile_ctx_t *ctx, const WCHAR *name)
1586 {
1587 function_t *iter;
1588
1589 for(iter = ctx->code->funcs; iter; iter = iter->next) {
1590 if(!wcsicmp(iter->name, name))
1591 return TRUE;
1592 }
1593
1594 return FALSE;
1595 }
1596
1597 static HRESULT create_function(compile_ctx_t *ctx, function_decl_t *decl, function_t **ret)
1598 {
1599 function_t *func;
1600 HRESULT hres;
1601
1602 if(lookup_dim_decls(ctx, decl->name) || lookup_const_decls(ctx, decl->name, FALSE)) {
1603 FIXME("%s: redefinition\n", debugstr_w(decl->name));
1604 return E_FAIL;
1605 }
1606
1607 func = compiler_alloc(ctx->code, sizeof(*func));
1608 if(!func)
1609 return E_OUTOFMEMORY;
1610
1611 func->name = compiler_alloc_string(ctx->code, decl->name);
1612 if(!func->name)
1613 return E_OUTOFMEMORY;
1614
1615 func->vars = NULL;
1616 func->var_cnt = 0;
1617 func->array_cnt = 0;
1618 func->code_ctx = ctx->code;
1619 func->type = decl->type;
1620 func->is_public = decl->is_public;
1621
1622 func->arg_cnt = 0;
1623 if(decl->args) {
1624 arg_decl_t *arg;
1625 unsigned i;
1626
1627 for(arg = decl->args; arg; arg = arg->next)
1628 func->arg_cnt++;
1629
1630 func->args = compiler_alloc(ctx->code, func->arg_cnt * sizeof(arg_desc_t));
1631 if(!func->args)
1632 return E_OUTOFMEMORY;
1633
1634 for(i = 0, arg = decl->args; arg; arg = arg->next, i++) {
1635 func->args[i].name = compiler_alloc_string(ctx->code, arg->name);
1636 if(!func->args[i].name)
1637 return E_OUTOFMEMORY;
1638 func->args[i].by_ref = arg->by_ref;
1639 }
1640 }else {
1641 func->args = NULL;
1642 }
1643
1644 hres = compile_func(ctx, decl->body, func);
1645 if(FAILED(hres))
1646 return hres;
1647
1648 *ret = func;
1649 return S_OK;
1650 }
1651
1652 static BOOL lookup_class_name(compile_ctx_t *ctx, const WCHAR *name)
1653 {
1654 class_desc_t *iter;
1655
1656 for(iter = ctx->code->classes; iter; iter = iter->next) {
1657 if(!wcsicmp(iter->name, name))
1658 return TRUE;
1659 }
1660
1661 return FALSE;
1662 }
1663
1664 static HRESULT create_class_funcprop(compile_ctx_t *ctx, function_decl_t *func_decl, vbdisp_funcprop_desc_t *desc)
1665 {
1666 vbdisp_invoke_type_t invoke_type;
1667 function_decl_t *funcprop_decl;
1668 HRESULT hres;
1669
1670 desc->name = compiler_alloc_string(ctx->code, func_decl->name);
1671 if(!desc->name)
1672 return E_OUTOFMEMORY;
1673
1674 for(funcprop_decl = func_decl; funcprop_decl; funcprop_decl = funcprop_decl->next_prop_func) {
1675 switch(funcprop_decl->type) {
1676 case FUNC_FUNCTION:
1677 case FUNC_SUB:
1678 case FUNC_PROPGET:
1679 invoke_type = VBDISP_CALLGET;
1680 break;
1681 case FUNC_PROPLET:
1682 invoke_type = VBDISP_LET;
1683 break;
1684 case FUNC_PROPSET:
1685 invoke_type = VBDISP_SET;
1686 break;
1687 DEFAULT_UNREACHABLE;
1688 }
1689
1690 assert(!desc->entries[invoke_type]);
1691
1692 if(funcprop_decl->is_public)
1693 desc->is_public = TRUE;
1694
1695 hres = create_function(ctx, funcprop_decl, desc->entries+invoke_type);
1696 if(FAILED(hres))
1697 return hres;
1698 }
1699
1700 return S_OK;
1701 }
1702
1703 static BOOL lookup_class_funcs(class_desc_t *class_desc, const WCHAR *name)
1704 {
1705 unsigned i;
1706
1707 for(i=0; i < class_desc->func_cnt; i++) {
1708 if(class_desc->funcs[i].name && !wcsicmp(class_desc->funcs[i].name, name))
1709 return TRUE;
1710 }
1711
1712 return FALSE;
1713 }
1714
1715 static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
1716 {
1717 function_decl_t *func_decl, *func_prop_decl;
1718 BOOL is_default, have_default = FALSE;
1719 class_desc_t *class_desc;
1720 dim_decl_t *prop_decl;
1721 unsigned i;
1722 HRESULT hres;
1723
1724 if(lookup_dim_decls(ctx, class_decl->name) || lookup_funcs_name(ctx, class_decl->name)
1725 || lookup_const_decls(ctx, class_decl->name, FALSE) || lookup_class_name(ctx, class_decl->name)) {
1726 FIXME("%s: redefinition\n", debugstr_w(class_decl->name));
1727 return E_FAIL;
1728 }
1729
1730 class_desc = compiler_alloc_zero(ctx->code, sizeof(*class_desc));
1731 if(!class_desc)
1732 return E_OUTOFMEMORY;
1733
1734 class_desc->name = compiler_alloc_string(ctx->code, class_decl->name);
1735 if(!class_desc->name)
1736 return E_OUTOFMEMORY;
1737
1738 class_desc->func_cnt = 1; /* always allocate slot for default getter or method */
1739
1740 for(func_decl = class_decl->funcs; func_decl; func_decl = func_decl->next) {
1741 is_default = FALSE;
1742 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1743 if(func_prop_decl->is_default) {
1744 if(have_default) {
1745 FIXME("multiple default getters or methods\n");
1746 return E_FAIL;
1747 }
1748 is_default = have_default = TRUE;
1749 break;
1750 }
1751 }
1752 if(!is_default)
1753 class_desc->func_cnt++;
1754 }
1755
1756 class_desc->funcs = compiler_alloc(ctx->code, class_desc->func_cnt*sizeof(*class_desc->funcs));
1757 if(!class_desc->funcs)
1758 return E_OUTOFMEMORY;
1759 memset(class_desc->funcs, 0, class_desc->func_cnt*sizeof(*class_desc->funcs));
1760
1761 for(func_decl = class_decl->funcs, i=1; func_decl; func_decl = func_decl->next, i++) {
1762 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1763 if(func_prop_decl->is_default) {
1764 i--;
1765 break;
1766 }
1767 }
1768
1769 if(!wcsicmp(L"class_initialize", func_decl->name)) {
1770 if(func_decl->type != FUNC_SUB) {
1771 FIXME("class initializer is not sub\n");
1772 return E_FAIL;
1773 }
1774
1775 class_desc->class_initialize_id = i;
1776 }else if(!wcsicmp(L"class_terminate", func_decl->name)) {
1777 if(func_decl->type != FUNC_SUB) {
1778 FIXME("class terminator is not sub\n");
1779 return E_FAIL;
1780 }
1781
1782 class_desc->class_terminate_id = i;
1783 }
1784
1785 hres = create_class_funcprop(ctx, func_decl, class_desc->funcs + (func_prop_decl ? 0 : i));
1786 if(FAILED(hres))
1787 return hres;
1788 }
1789
1790 for(prop_decl = class_decl->props; prop_decl; prop_decl = prop_decl->next)
1791 class_desc->prop_cnt++;
1792
1793 class_desc->props = compiler_alloc(ctx->code, class_desc->prop_cnt*sizeof(*class_desc->props));
1794 if(!class_desc->props)
1795 return E_OUTOFMEMORY;
1796
1797 for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next, i++) {
1798 if(lookup_class_funcs(class_desc, prop_decl->name)) {
1799 FIXME("Property %s redefined\n", debugstr_w(prop_decl->name));
1800 return E_FAIL;
1801 }
1802
1803 class_desc->props[i].name = compiler_alloc_string(ctx->code, prop_decl->name);
1804 if(!class_desc->props[i].name)
1805 return E_OUTOFMEMORY;
1806
1807 class_desc->props[i].is_public = prop_decl->is_public;
1808 class_desc->props[i].is_array = prop_decl->is_array;
1809
1810 if(prop_decl->is_array)
1811 class_desc->array_cnt++;
1812 }
1813
1814 if(class_desc->array_cnt) {
1815 class_desc->array_descs = compiler_alloc(ctx->code, class_desc->array_cnt*sizeof(*class_desc->array_descs));
1816 if(!class_desc->array_descs)
1817 return E_OUTOFMEMORY;
1818
1819 for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next) {
1820 if(prop_decl->is_array) {
1821 hres = fill_array_desc(ctx, prop_decl, class_desc->array_descs + i++);
1822 if(FAILED(hres))
1823 return hres;
1824 }
1825 }
1826 }
1827
1828 class_desc->next = ctx->code->classes;
1829 ctx->code->classes = class_desc;
1830 return S_OK;
1831 }
1832
1833 static BOOL lookup_script_identifier(compile_ctx_t *ctx, script_ctx_t *script, const WCHAR *identifier)
1834 {
1835 ScriptDisp *contexts[] = {
1836 ctx->code->named_item ? ctx->code->named_item->script_obj : NULL,
1837 script->script_obj
1838 };
1839 class_desc_t *class;
1840 vbscode_t *code;
1841 unsigned c, i;
1842
1843 for(c = 0; c < ARRAY_SIZE(contexts); c++) {
1844 if(!contexts[c]) continue;
1845
1846 for(i = 0; i < contexts[c]->global_vars_cnt; i++) {
1847 if(!wcsicmp(contexts[c]->global_vars[i]->name, identifier))
1848 return TRUE;
1849 }
1850
1851 for(i = 0; i < contexts[c]->global_funcs_cnt; i++) {
1852 if(!wcsicmp(contexts[c]->global_funcs[i]->name, identifier))
1853 return TRUE;
1854 }
1855
1856 for(class = contexts[c]->classes; class; class = class->next) {
1857 if(!wcsicmp(class->name, identifier))
1858 return TRUE;
1859 }
1860 }
1861
1862 LIST_FOR_EACH_ENTRY(code, &script->code_list, vbscode_t, entry) {
1863 unsigned var_cnt = code->main_code.var_cnt;
1864 var_desc_t *vars = code->main_code.vars;
1865 function_t *func;
1866
1867 if(!code->pending_exec || (code->named_item && code->named_item != ctx->code->named_item))
1868 continue;
1869
1870 for(i = 0; i < var_cnt; i++) {
1871 if(!wcsicmp(vars[i].name, identifier))
1872 return TRUE;
1873 }
1874
1875 for(func = code->funcs; func; func = func->next) {
1876 if(!wcsicmp(func->name, identifier))
1877 return TRUE;
1878 }
1879
1880 for(class = code->classes; class; class = class->next) {
1881 if(!wcsicmp(class->name, identifier))
1882 return TRUE;
1883 }
1884 }
1885
1886 return FALSE;
1887 }
1888
1889 static HRESULT check_script_collisions(compile_ctx_t *ctx, script_ctx_t *script)
1890 {
1891 unsigned i, var_cnt = ctx->code->main_code.var_cnt;
1892 var_desc_t *vars = ctx->code->main_code.vars;
1893 class_desc_t *class;
1894
1895 for(i = 0; i < var_cnt; i++) {
1896 if(lookup_script_identifier(ctx, script, vars[i].name)) {
1897 FIXME("%s: redefined\n", debugstr_w(vars[i].name));
1898 return E_FAIL;
1899 }
1900 }
1901
1902 for(class = ctx->code->classes; class; class = class->next) {
1903 if(lookup_script_identifier(ctx, script, class->name)) {
1904 FIXME("%s: redefined\n", debugstr_w(class->name));
1905 return E_FAIL;
1906 }
1907 }
1908
1909 return S_OK;
1910 }
1911
1912 void release_vbscode(vbscode_t *code)
1913 {
1914 unsigned i;
1915
1916 if(--code->ref)
1917 return;
1918
1919 for(i=0; i < code->bstr_cnt; i++)
1920 SysFreeString(code->bstr_pool[i]);
1921
1922 if(code->named_item)
1923 release_named_item(code->named_item);
1924 heap_pool_free(&code->heap);
1925
1926 free(code->bstr_pool);
1927 free(code->source);
1928 free(code->instrs);
1929 free(code);
1930 }
1931
1932 static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source, DWORD_PTR cookie, unsigned start_line)
1933 {
1934 vbscode_t *ret;
1935 size_t len;
1936
1937 len = source ? lstrlenW(source) : 0;
1938 if(len > INT32_MAX)
1939 return NULL;
1940
1941 ret = calloc(1, sizeof(*ret));
1942 if(!ret)
1943 return NULL;
1944
1945 ret->source = malloc((len + 1) * sizeof(WCHAR));
1946 if(!ret->source) {
1947 free(ret);
1948 return NULL;
1949 }
1950 if(len)
1951 memcpy(ret->source, source, len * sizeof(WCHAR));
1952 ret->source[len] = 0;
1953
1954 ret->ref = 1;
1955 ret->cookie = cookie;
1956 ret->start_line = start_line;
1957
1958 ret->instrs = malloc(32*sizeof(instr_t));
1959 if(!ret->instrs) {
1960 release_vbscode(ret);
1961 return NULL;
1962 }
1963
1964 ctx->instr_cnt = 1;
1965 ctx->instr_size = 32;
1966 heap_pool_init(&ret->heap);
1967
1968 ret->main_code.type = FUNC_GLOBAL;
1969 ret->main_code.code_ctx = ret;
1970
1971 list_init(&ret->entry);
1972 return ret;
1973 }
1974
1975 static void release_compiler(compile_ctx_t *ctx)
1976 {
1977 parser_release(&ctx->parser);
1978 free(ctx->labels);
1979 if(ctx->code)
1980 release_vbscode(ctx->code);
1981 }
1982
1983 HRESULT compile_script(script_ctx_t *script, const WCHAR *src, const WCHAR *item_name, const WCHAR *delimiter,
1984 DWORD_PTR cookie, unsigned start_line, DWORD flags, vbscode_t **ret)
1985 {
1986 function_decl_t *func_decl;
1987 named_item_t *item = NULL;
1988 class_decl_t *class_decl;
1989 function_t *new_func;
1990 compile_ctx_t ctx;
1991 vbscode_t *code;
1992 HRESULT hres;
1993
1994 if(item_name) {
1995 item = lookup_named_item(script, item_name, 0);
1996 if(!item) {
1997 WARN("Unknown context %s\n", debugstr_w(item_name));
1998 return E_INVALIDARG;
1999 }
2000 if(!item->script_obj) item = NULL;
2001 }
2002
2003 memset(&ctx, 0, sizeof(ctx));
2004 code = ctx.code = alloc_vbscode(&ctx, src, cookie, start_line);
2005 if(!ctx.code)
2006 return E_OUTOFMEMORY;
2007 if(item) {
2008 code->named_item = item;
2009 item->ref++;
2010 }
2011
2012 ctx.parser.lcid = script->lcid;
2013 hres = parse_script(&ctx.parser, code->source, delimiter, flags);
2014 if(FAILED(hres)) {
2015 if(ctx.parser.error_loc != -1)
2016 ctx.loc = ctx.parser.error_loc;
2017 hres = compile_error(script, &ctx, hres);
2018 release_vbscode(code);
2019 return hres;
2020 }
2021
2022 hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->main_code);
2023 if(FAILED(hres)) {
2024 hres = compile_error(script, &ctx, hres);
2025 release_compiler(&ctx);
2026 return hres;
2027 }
2028
2029 code->option_explicit = ctx.parser.option_explicit;
2030 ctx.global_consts = ctx.const_decls;
2031 code->option_explicit = ctx.parser.option_explicit;
2032
2033
2034 for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
2035 hres = create_function(&ctx, func_decl, &new_func);
2036 if(FAILED(hres)) {
2037 hres = compile_error(script, &ctx, hres);
2038 release_compiler(&ctx);
2039 return hres;
2040 }
2041
2042 new_func->next = ctx.code->funcs;
2043 ctx.code->funcs = new_func;
2044 }
2045
2046 for(class_decl = ctx.parser.class_decls; class_decl; class_decl = class_decl->next) {
2047 hres = compile_class(&ctx, class_decl);
2048 if(FAILED(hres)) {
2049 hres = compile_error(script, &ctx, hres);
2050 release_compiler(&ctx);
2051 return hres;
2052 }
2053 }
2054
2055 hres = check_script_collisions(&ctx, script);
2056 if(FAILED(hres)) {
2057 hres = compile_error(script, &ctx, hres);
2058 release_compiler(&ctx);
2059 return hres;
2060 }
2061
2062 code->is_persistent = (flags & SCRIPTTEXT_ISPERSISTENT) != 0;
2063
2064 if(TRACE_ON(vbscript_disas))
2065 dump_code(&ctx);
2066
2067 ctx.code = NULL;
2068 release_compiler(&ctx);
2069
2070 list_add_tail(&script->code_list, &code->entry);
2071 *ret = code;
2072 return S_OK;
2073 }
2074
2075 HRESULT compile_procedure(script_ctx_t *script, const WCHAR *src, const WCHAR *item_name, const WCHAR *delimiter,
2076 DWORD_PTR cookie, unsigned start_line, DWORD flags, class_desc_t **ret)
2077 {
2078 class_desc_t *desc;
2079 vbscode_t *code;
2080 HRESULT hres;
2081
2082 hres = compile_script(script, src, item_name, delimiter, cookie, start_line,
2083 flags & ~SCRIPTTEXT_ISPERSISTENT, &code);
2084 if(FAILED(hres))
2085 return hres;
2086
2087 if(!(desc = compiler_alloc_zero(code, sizeof(*desc))))
2088 return E_OUTOFMEMORY;
2089 if(!(desc->funcs = compiler_alloc_zero(code, sizeof(*desc->funcs))))
2090 return E_OUTOFMEMORY;
2091
2092 desc->ctx = script;
2093 desc->func_cnt = 1;
2094 desc->funcs->entries[VBDISP_CALLGET] = &code->main_code;
2095
2096 *ret = desc;
2097 return S_OK;
2098 }
Windows API implementation