?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dcompiler: Don't allow semantics on void functions.
[wine/multimedia.git] / dlls / vbscript / compile.c
blob7c4b0e6818484a44c5ca4c8ab04bbea13674fc9c
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
36 struct _statement_ctx_t *next;
37 } statement_ctx_t;
38
39 typedef struct {
40 parser_ctx_t parser;
41
42 unsigned instr_cnt;
43 unsigned instr_size;
44 vbscode_t *code;
45
46 statement_ctx_t *stat_ctx;
47
48 unsigned *labels;
49 unsigned labels_size;
50 unsigned labels_cnt;
51
52 unsigned sub_end_label;
53 unsigned func_end_label;
54 unsigned prop_end_label;
55
56 dim_decl_t *dim_decls;
57 dynamic_var_t *global_vars;
58
59 const_decl_t *const_decls;
60 const_decl_t *global_consts;
61
62 function_t *func;
63 function_t *funcs;
64 function_decl_t *func_decls;
65
66 class_desc_t *classes;
67 } compile_ctx_t;
68
69 static HRESULT compile_expression(compile_ctx_t*,expression_t*);
70 static HRESULT compile_statement(compile_ctx_t*,statement_ctx_t*,statement_t*);
71
72 static const struct {
73 const char *op_str;
74 instr_arg_type_t arg1_type;
75 instr_arg_type_t arg2_type;
76 } instr_info[] = {
77 #define X(n,a,b,c) {#n,b,c},
78 OP_LIST
79 #undef X
80 };
81
82 static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg)
83 {
84 switch(type) {
85 case ARG_STR:
86 case ARG_BSTR:
87 TRACE_(vbscript_disas)("\t%s", debugstr_w(arg->str));
88 break;
89 case ARG_INT:
90 TRACE_(vbscript_disas)("\t%d", arg->uint);
91 break;
92 case ARG_UINT:
93 case ARG_ADDR:
94 TRACE_(vbscript_disas)("\t%u", arg->uint);
95 break;
96 case ARG_DOUBLE:
97 TRACE_(vbscript_disas)("\t%lf", *arg->dbl);
98 break;
99 case ARG_NONE:
100 break;
101 default:
102 assert(0);
103 }
104 }
105
106 static void dump_code(compile_ctx_t *ctx)
107 {
108 instr_t *instr;
109
110 for(instr = ctx->code->instrs+1; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
111 assert(instr->op < OP_LAST);
112 TRACE_(vbscript_disas)("%d:\t%s", (int)(instr-ctx->code->instrs), instr_info[instr->op].op_str);
113 dump_instr_arg(instr_info[instr->op].arg1_type, &instr->arg1);
114 dump_instr_arg(instr_info[instr->op].arg2_type, &instr->arg2);
115 TRACE_(vbscript_disas)("\n");
116 }
117 }
118
119 static inline void *compiler_alloc(vbscode_t *vbscode, size_t size)
120 {
121 return vbsheap_alloc(&vbscode->heap, size);
122 }
123
124 static inline void *compiler_alloc_zero(vbscode_t *vbscode, size_t size)
125 {
126 void *ret;
127
128 ret = vbsheap_alloc(&vbscode->heap, size);
129 if(ret)
130 memset(ret, 0, size);
131 return ret;
132 }
133
134 static WCHAR *compiler_alloc_string(vbscode_t *vbscode, const WCHAR *str)
135 {
136 size_t size;
137 WCHAR *ret;
138
139 size = (strlenW(str)+1)*sizeof(WCHAR);
140 ret = compiler_alloc(vbscode, size);
141 if(ret)
142 memcpy(ret, str, size);
143 return ret;
144 }
145
146 static inline instr_t *instr_ptr(compile_ctx_t *ctx, unsigned id)
147 {
148 assert(id < ctx->instr_cnt);
149 return ctx->code->instrs + id;
150 }
151
152 static unsigned push_instr(compile_ctx_t *ctx, vbsop_t op)
153 {
154 assert(ctx->instr_size && ctx->instr_size >= ctx->instr_cnt);
155
156 if(ctx->instr_size == ctx->instr_cnt) {
157 instr_t *new_instr;
158
159 new_instr = heap_realloc(ctx->code->instrs, ctx->instr_size*2*sizeof(instr_t));
160 if(!new_instr)
161 return 0;
162
163 ctx->code->instrs = new_instr;
164 ctx->instr_size *= 2;
165 }
166
167 ctx->code->instrs[ctx->instr_cnt].op = op;
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 BSTR alloc_bstr_arg(compile_ctx_t *ctx, const WCHAR *str)
243 {
244 if(!ctx->code->bstr_pool_size) {
245 ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
246 if(!ctx->code->bstr_pool)
247 return NULL;
248 ctx->code->bstr_pool_size = 8;
249 }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
250 BSTR *new_pool;
251
252 new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
253 if(!new_pool)
254 return NULL;
255
256 ctx->code->bstr_pool = new_pool;
257 ctx->code->bstr_pool_size *= 2;
258 }
259
260 ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
261 if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
262 return NULL;
263
264 return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
265 }
266
267 static HRESULT push_instr_bstr(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg)
268 {
269 unsigned instr;
270 BSTR bstr;
271
272 bstr = alloc_bstr_arg(ctx, arg);
273 if(!bstr)
274 return E_OUTOFMEMORY;
275
276 instr = push_instr(ctx, op);
277 if(!instr)
278 return E_OUTOFMEMORY;
279
280 instr_ptr(ctx, instr)->arg1.bstr = bstr;
281 return S_OK;
282 }
283
284 static HRESULT push_instr_bstr_uint(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg1, unsigned arg2)
285 {
286 unsigned instr;
287 BSTR bstr;
288
289 bstr = alloc_bstr_arg(ctx, arg1);
290 if(!bstr)
291 return E_OUTOFMEMORY;
292
293 instr = push_instr(ctx, op);
294 if(!instr)
295 return E_OUTOFMEMORY;
296
297 instr_ptr(ctx, instr)->arg1.bstr = bstr;
298 instr_ptr(ctx, instr)->arg2.uint = arg2;
299 return S_OK;
300 }
301
302 static HRESULT push_instr_uint_bstr(compile_ctx_t *ctx, vbsop_t op, unsigned arg1, const WCHAR *arg2)
303 {
304 unsigned instr;
305 BSTR bstr;
306
307 bstr = alloc_bstr_arg(ctx, arg2);
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.uint = arg1;
316 instr_ptr(ctx, instr)->arg2.bstr = bstr;
317 return S_OK;
318 }
319
320 #define LABEL_FLAG 0x80000000
321
322 static unsigned alloc_label(compile_ctx_t *ctx)
323 {
324 if(!ctx->labels_size) {
325 ctx->labels = heap_alloc(8 * sizeof(*ctx->labels));
326 if(!ctx->labels)
327 return 0;
328 ctx->labels_size = 8;
329 }else if(ctx->labels_size == ctx->labels_cnt) {
330 unsigned *new_labels;
331
332 new_labels = heap_realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
333 if(!new_labels)
334 return 0;
335
336 ctx->labels = new_labels;
337 ctx->labels_size *= 2;
338 }
339
340 return ctx->labels_cnt++ | LABEL_FLAG;
341 }
342
343 static inline void label_set_addr(compile_ctx_t *ctx, unsigned label)
344 {
345 assert(label & LABEL_FLAG);
346 ctx->labels[label & ~LABEL_FLAG] = ctx->instr_cnt;
347 }
348
349 static expression_t *lookup_const_decls(compile_ctx_t *ctx, const WCHAR *name, BOOL lookup_global)
350 {
351 const_decl_t *decl;
352
353 for(decl = ctx->const_decls; decl; decl = decl->next) {
354 if(!strcmpiW(decl->name, name))
355 return decl->value_expr;
356 }
357
358 if(!lookup_global)
359 return NULL;
360
361 for(decl = ctx->global_consts; decl; decl = decl->next) {
362 if(!strcmpiW(decl->name, name))
363 return decl->value_expr;
364 }
365
366 return NULL;
367 }
368
369 static HRESULT compile_args(compile_ctx_t *ctx, expression_t *args, unsigned *ret)
370 {
371 unsigned arg_cnt = 0;
372 HRESULT hres;
373
374 while(args) {
375 hres = compile_expression(ctx, args);
376 if(FAILED(hres))
377 return hres;
378
379 arg_cnt++;
380 args = args->next;
381 }
382
383 *ret = arg_cnt;
384 return S_OK;
385 }
386
387 static HRESULT compile_member_expression(compile_ctx_t *ctx, member_expression_t *expr, BOOL ret_val)
388 {
389 unsigned arg_cnt = 0;
390 HRESULT hres;
391
392 if(ret_val && !expr->args) {
393 expression_t *const_expr;
394
395 const_expr = lookup_const_decls(ctx, expr->identifier, TRUE);
396 if(const_expr)
397 return compile_expression(ctx, const_expr);
398 }
399
400 hres = compile_args(ctx, expr->args, &arg_cnt);
401 if(FAILED(hres))
402 return hres;
403
404 if(expr->obj_expr) {
405 hres = compile_expression(ctx, expr->obj_expr);
406 if(FAILED(hres))
407 return hres;
408
409 hres = push_instr_bstr_uint(ctx, ret_val ? OP_mcall : OP_mcallv, expr->identifier, arg_cnt);
410 }else {
411 hres = push_instr_bstr_uint(ctx, ret_val ? OP_icall : OP_icallv, expr->identifier, arg_cnt);
412 }
413
414 return hres;
415 }
416
417 static HRESULT compile_unary_expression(compile_ctx_t *ctx, unary_expression_t *expr, vbsop_t op)
418 {
419 HRESULT hres;
420
421 hres = compile_expression(ctx, expr->subexpr);
422 if(FAILED(hres))
423 return hres;
424
425 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
426 }
427
428 static HRESULT compile_binary_expression(compile_ctx_t *ctx, binary_expression_t *expr, vbsop_t op)
429 {
430 HRESULT hres;
431
432 hres = compile_expression(ctx, expr->left);
433 if(FAILED(hres))
434 return hres;
435
436 hres = compile_expression(ctx, expr->right);
437 if(FAILED(hres))
438 return hres;
439
440 return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
441 }
442
443 static HRESULT compile_expression(compile_ctx_t *ctx, expression_t *expr)
444 {
445 switch(expr->type) {
446 case EXPR_ADD:
447 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
448 case EXPR_AND:
449 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
450 case EXPR_BOOL:
451 return push_instr_int(ctx, OP_bool, ((bool_expression_t*)expr)->value);
452 case EXPR_BRACKETS:
453 return compile_expression(ctx, ((unary_expression_t*)expr)->subexpr);
454 case EXPR_CONCAT:
455 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_concat);
456 case EXPR_DIV:
457 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
458 case EXPR_DOUBLE:
459 return push_instr_double(ctx, OP_double, ((double_expression_t*)expr)->value);
460 case EXPR_EMPTY:
461 return push_instr(ctx, OP_empty) ? S_OK : E_OUTOFMEMORY;
462 case EXPR_EQUAL:
463 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_equal);
464 case EXPR_EQV:
465 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eqv);
466 case EXPR_EXP:
467 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_exp);
468 case EXPR_GT:
469 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
470 case EXPR_GTEQ:
471 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
472 case EXPR_IDIV:
473 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_idiv);
474 case EXPR_IS:
475 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_is);
476 case EXPR_IMP:
477 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_imp);
478 case EXPR_LT:
479 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
480 case EXPR_LTEQ:
481 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
482 case EXPR_ME:
483 return push_instr(ctx, OP_me) ? S_OK : E_OUTOFMEMORY;
484 case EXPR_MEMBER:
485 return compile_member_expression(ctx, (member_expression_t*)expr, TRUE);
486 case EXPR_MOD:
487 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
488 case EXPR_MUL:
489 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
490 case EXPR_NEG:
491 return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
492 case EXPR_NEQUAL:
493 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_nequal);
494 case EXPR_NEW:
495 return push_instr_str(ctx, OP_new, ((string_expression_t*)expr)->value);
496 case EXPR_NOT:
497 return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_not);
498 case EXPR_NOTHING:
499 return push_instr(ctx, OP_nothing) ? S_OK : E_OUTOFMEMORY;
500 case EXPR_NULL:
501 return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
502 case EXPR_OR:
503 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
504 case EXPR_STRING:
505 return push_instr_str(ctx, OP_string, ((string_expression_t*)expr)->value);
506 case EXPR_SUB:
507 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
508 case EXPR_USHORT:
509 return push_instr_int(ctx, OP_short, ((int_expression_t*)expr)->value);
510 case EXPR_ULONG:
511 return push_instr_int(ctx, OP_long, ((int_expression_t*)expr)->value);
512 case EXPR_XOR:
513 return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
514 default:
515 FIXME("Unimplemented expression type %d\n", expr->type);
516 return E_NOTIMPL;
517 }
518
519 return S_OK;
520 }
521
522 static HRESULT compile_if_statement(compile_ctx_t *ctx, if_statement_t *stat)
523 {
524 unsigned cnd_jmp, endif_label = 0;
525 elseif_decl_t *elseif_decl;
526 HRESULT hres;
527
528 hres = compile_expression(ctx, stat->expr);
529 if(FAILED(hres))
530 return hres;
531
532 cnd_jmp = push_instr(ctx, OP_jmp_false);
533 if(!cnd_jmp)
534 return E_OUTOFMEMORY;
535
536 hres = compile_statement(ctx, NULL, stat->if_stat);
537 if(FAILED(hres))
538 return hres;
539
540 if(stat->else_stat || stat->elseifs) {
541 endif_label = alloc_label(ctx);
542 if(!endif_label)
543 return E_OUTOFMEMORY;
544
545 hres = push_instr_addr(ctx, OP_jmp, endif_label);
546 if(FAILED(hres))
547 return hres;
548 }
549
550 for(elseif_decl = stat->elseifs; elseif_decl; elseif_decl = elseif_decl->next) {
551 instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
552
553 hres = compile_expression(ctx, elseif_decl->expr);
554 if(FAILED(hres))
555 return hres;
556
557 cnd_jmp = push_instr(ctx, OP_jmp_false);
558 if(!cnd_jmp)
559 return E_OUTOFMEMORY;
560
561 hres = compile_statement(ctx, NULL, elseif_decl->stat);
562 if(FAILED(hres))
563 return hres;
564
565 hres = push_instr_addr(ctx, OP_jmp, endif_label);
566 if(FAILED(hres))
567 return hres;
568 }
569
570 instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
571
572 if(stat->else_stat) {
573 hres = compile_statement(ctx, NULL, stat->else_stat);
574 if(FAILED(hres))
575 return hres;
576 }
577
578 if(endif_label)
579 label_set_addr(ctx, endif_label);
580 return S_OK;
581 }
582
583 static HRESULT compile_while_statement(compile_ctx_t *ctx, while_statement_t *stat)
584 {
585 statement_ctx_t stat_ctx = {0}, *loop_ctx;
586 unsigned start_addr;
587 unsigned jmp_end;
588 HRESULT hres;
589
590 start_addr = ctx->instr_cnt;
591
592 hres = compile_expression(ctx, stat->expr);
593 if(FAILED(hres))
594 return hres;
595
596 jmp_end = push_instr(ctx, stat->stat.type == STAT_UNTIL ? OP_jmp_true : OP_jmp_false);
597 if(!jmp_end)
598 return E_OUTOFMEMORY;
599
600 if(stat->stat.type == STAT_WHILE) {
601 loop_ctx = NULL;
602 }else {
603 if(!(stat_ctx.while_end_label = alloc_label(ctx)))
604 return E_OUTOFMEMORY;
605 loop_ctx = &stat_ctx;
606 }
607
608 hres = compile_statement(ctx, loop_ctx, stat->body);
609 if(FAILED(hres))
610 return hres;
611
612 hres = push_instr_addr(ctx, OP_jmp, start_addr);
613 if(FAILED(hres))
614 return hres;
615
616 instr_ptr(ctx, jmp_end)->arg1.uint = ctx->instr_cnt;
617
618 if(loop_ctx)
619 label_set_addr(ctx, stat_ctx.while_end_label);
620
621 return S_OK;
622 }
623
624 static HRESULT compile_dowhile_statement(compile_ctx_t *ctx, while_statement_t *stat)
625 {
626 statement_ctx_t loop_ctx = {0};
627 unsigned start_addr;
628 HRESULT hres;
629
630 start_addr = ctx->instr_cnt;
631
632 if(!(loop_ctx.while_end_label = alloc_label(ctx)))
633 return E_OUTOFMEMORY;
634
635 hres = compile_statement(ctx, &loop_ctx, stat->body);
636 if(FAILED(hres))
637 return hres;
638
639 hres = compile_expression(ctx, stat->expr);
640 if(FAILED(hres))
641 return hres;
642
643 hres = push_instr_addr(ctx, stat->stat.type == STAT_DOUNTIL ? OP_jmp_false : OP_jmp_true, start_addr);
644 if(FAILED(hres))
645 return hres;
646
647 label_set_addr(ctx, loop_ctx.while_end_label);
648 return S_OK;
649 }
650
651 static HRESULT compile_foreach_statement(compile_ctx_t *ctx, foreach_statement_t *stat)
652 {
653 statement_ctx_t loop_ctx = {1};
654 unsigned loop_start;
655 HRESULT hres;
656
657 hres = compile_expression(ctx, stat->group_expr);
658 if(FAILED(hres))
659 return hres;
660
661 if(!push_instr(ctx, OP_newenum))
662 return E_OUTOFMEMORY;
663
664 loop_start = ctx->instr_cnt;
665 if(!(loop_ctx.for_end_label = alloc_label(ctx)))
666 return E_OUTOFMEMORY;
667
668 hres = push_instr_uint_bstr(ctx, OP_enumnext, loop_ctx.for_end_label, stat->identifier);
669 if(FAILED(hres))
670 return hres;
671
672 hres = compile_statement(ctx, &loop_ctx, stat->body);
673 if(FAILED(hres))
674 return hres;
675
676 hres = push_instr_addr(ctx, OP_jmp, loop_start);
677 if(FAILED(hres))
678 return hres;
679
680 label_set_addr(ctx, loop_ctx.for_end_label);
681 return S_OK;
682 }
683
684 static HRESULT compile_forto_statement(compile_ctx_t *ctx, forto_statement_t *stat)
685 {
686 statement_ctx_t loop_ctx = {2};
687 unsigned step_instr, instr;
688 BSTR identifier;
689 HRESULT hres;
690
691 identifier = alloc_bstr_arg(ctx, stat->identifier);
692 if(!identifier)
693 return E_OUTOFMEMORY;
694
695 hres = compile_expression(ctx, stat->from_expr);
696 if(FAILED(hres))
697 return hres;
698
699 instr = push_instr(ctx, OP_assign_ident);
700 if(!instr)
701 return E_OUTOFMEMORY;
702 instr_ptr(ctx, instr)->arg1.bstr = identifier;
703
704 hres = compile_expression(ctx, stat->to_expr);
705 if(FAILED(hres))
706 return hres;
707
708 if(!push_instr(ctx, OP_val))
709 return E_OUTOFMEMORY;
710
711 if(stat->step_expr) {
712 hres = compile_expression(ctx, stat->step_expr);
713 if(FAILED(hres))
714 return hres;
715
716 if(!push_instr(ctx, OP_val))
717 return E_OUTOFMEMORY;
718 }else {
719 hres = push_instr_int(ctx, OP_short, 1);
720 if(FAILED(hres))
721 return hres;
722 }
723
724 loop_ctx.for_end_label = alloc_label(ctx);
725 if(!loop_ctx.for_end_label)
726 return E_OUTOFMEMORY;
727
728 step_instr = push_instr(ctx, OP_step);
729 if(!step_instr)
730 return E_OUTOFMEMORY;
731 instr_ptr(ctx, step_instr)->arg2.bstr = identifier;
732 instr_ptr(ctx, step_instr)->arg1.uint = loop_ctx.for_end_label;
733
734 hres = compile_statement(ctx, &loop_ctx, stat->body);
735 if(FAILED(hres))
736 return hres;
737
738 instr = push_instr(ctx, OP_incc);
739 if(!instr)
740 return E_OUTOFMEMORY;
741 instr_ptr(ctx, instr)->arg1.bstr = identifier;
742
743 hres = push_instr_addr(ctx, OP_jmp, step_instr);
744 if(FAILED(hres))
745 return hres;
746
747 hres = push_instr_uint(ctx, OP_pop, 2);
748 if(FAILED(hres))
749 return hres;
750
751 label_set_addr(ctx, loop_ctx.for_end_label);
752 return S_OK;
753 }
754
755 static HRESULT compile_assignment(compile_ctx_t *ctx, member_expression_t *member_expr, expression_t *value_expr, BOOL is_set)
756 {
757 unsigned args_cnt;
758 vbsop_t op;
759 HRESULT hres;
760
761 if(member_expr->obj_expr) {
762 hres = compile_expression(ctx, member_expr->obj_expr);
763 if(FAILED(hres))
764 return hres;
765
766 op = is_set ? OP_set_member : OP_assign_member;
767 }else {
768 op = is_set ? OP_set_ident : OP_assign_ident;
769 }
770
771 hres = compile_expression(ctx, value_expr);
772 if(FAILED(hres))
773 return hres;
774
775 hres = compile_args(ctx, member_expr->args, &args_cnt);
776 if(FAILED(hres))
777 return hres;
778
779 return push_instr_bstr_uint(ctx, op, member_expr->identifier, args_cnt);
780 }
781
782 static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *stat, BOOL is_set)
783 {
784 return compile_assignment(ctx, stat->member_expr, stat->value_expr, is_set);
785 }
786
787 static HRESULT compile_call_statement(compile_ctx_t *ctx, call_statement_t *stat)
788 {
789 /* It's challenging for parser to distinguish parameterized assignment with one argument from call
790 * with equality expression argument, so we do it in compiler. */
791 if(!stat->is_strict && stat->expr->args && !stat->expr->args->next && stat->expr->args->type == EXPR_EQUAL) {
792 binary_expression_t *eqexpr = (binary_expression_t*)stat->expr->args;
793
794 if(eqexpr->left->type == EXPR_BRACKETS) {
795 member_expression_t new_member = *stat->expr;
796
797 WARN("converting call expr to assign expr\n");
798
799 new_member.args = ((unary_expression_t*)eqexpr->left)->subexpr;
800 return compile_assignment(ctx, &new_member, eqexpr->right, FALSE);
801 }
802 }
803
804 return compile_member_expression(ctx, stat->expr, FALSE);
805 }
806
807 static BOOL lookup_dim_decls(compile_ctx_t *ctx, const WCHAR *name)
808 {
809 dim_decl_t *dim_decl;
810
811 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
812 if(!strcmpiW(dim_decl->name, name))
813 return TRUE;
814 }
815
816 return FALSE;
817 }
818
819 static BOOL lookup_args_name(compile_ctx_t *ctx, const WCHAR *name)
820 {
821 unsigned i;
822
823 for(i = 0; i < ctx->func->arg_cnt; i++) {
824 if(!strcmpiW(ctx->func->args[i].name, name))
825 return TRUE;
826 }
827
828 return FALSE;
829 }
830
831 static HRESULT compile_dim_statement(compile_ctx_t *ctx, dim_statement_t *stat)
832 {
833 dim_decl_t *dim_decl = stat->dim_decls;
834
835 while(1) {
836 if(lookup_dim_decls(ctx, dim_decl->name) || lookup_args_name(ctx, dim_decl->name)
837 || lookup_const_decls(ctx, dim_decl->name, FALSE)) {
838 FIXME("dim %s name redefined\n", debugstr_w(dim_decl->name));
839 return E_FAIL;
840 }
841
842 ctx->func->var_cnt++;
843 if(!dim_decl->next)
844 break;
845 dim_decl = dim_decl->next;
846 }
847
848 dim_decl->next = ctx->dim_decls;
849 ctx->dim_decls = stat->dim_decls;
850 return S_OK;
851 }
852
853 static HRESULT compile_const_statement(compile_ctx_t *ctx, const_statement_t *stat)
854 {
855 const_decl_t *decl, *next_decl = stat->decls;
856
857 do {
858 decl = next_decl;
859
860 if(lookup_const_decls(ctx, decl->name, FALSE) || lookup_args_name(ctx, decl->name)
861 || lookup_dim_decls(ctx, decl->name)) {
862 FIXME("%s redefined\n", debugstr_w(decl->name));
863 return E_FAIL;
864 }
865
866 if(ctx->func->type == FUNC_GLOBAL) {
867 HRESULT hres;
868
869 hres = compile_expression(ctx, decl->value_expr);
870 if(FAILED(hres))
871 return hres;
872
873 hres = push_instr_bstr(ctx, OP_const, decl->name);
874 if(FAILED(hres))
875 return hres;
876 }
877
878 next_decl = decl->next;
879 decl->next = ctx->const_decls;
880 ctx->const_decls = decl;
881 } while(next_decl);
882
883 return S_OK;
884 }
885
886 static HRESULT compile_function_statement(compile_ctx_t *ctx, function_statement_t *stat)
887 {
888 if(ctx->func != &ctx->code->global_code) {
889 FIXME("Function is not in the global code\n");
890 return E_FAIL;
891 }
892
893 stat->func_decl->next = ctx->func_decls;
894 ctx->func_decls = stat->func_decl;
895 return S_OK;
896 }
897
898 static HRESULT compile_exitdo_statement(compile_ctx_t *ctx)
899 {
900 statement_ctx_t *iter;
901 unsigned pop_cnt = 0;
902
903 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
904 pop_cnt += iter->stack_use;
905 if(iter->while_end_label)
906 break;
907 }
908 if(!iter) {
909 FIXME("Exit Do outside Do Loop\n");
910 return E_FAIL;
911 }
912
913 if(pop_cnt) {
914 HRESULT hres;
915
916 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
917 if(FAILED(hres))
918 return hres;
919 }
920
921 return push_instr_addr(ctx, OP_jmp, iter->while_end_label);
922 }
923
924 static HRESULT compile_exitfor_statement(compile_ctx_t *ctx)
925 {
926 statement_ctx_t *iter;
927 unsigned pop_cnt = 0;
928
929 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
930 pop_cnt += iter->stack_use;
931 if(iter->for_end_label)
932 break;
933 }
934 if(!iter) {
935 FIXME("Exit For outside For loop\n");
936 return E_FAIL;
937 }
938
939 if(pop_cnt) {
940 HRESULT hres;
941
942 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
943 if(FAILED(hres))
944 return hres;
945 }
946
947 return push_instr_addr(ctx, OP_jmp, iter->for_end_label);
948 }
949
950 static HRESULT exit_label(compile_ctx_t *ctx, unsigned jmp_label)
951 {
952 statement_ctx_t *iter;
953 unsigned pop_cnt = 0;
954
955 for(iter = ctx->stat_ctx; iter; iter = iter->next)
956 pop_cnt += iter->stack_use;
957
958 if(pop_cnt) {
959 HRESULT hres;
960
961 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
962 if(FAILED(hres))
963 return hres;
964 }
965
966 return push_instr_addr(ctx, OP_jmp, jmp_label);
967 }
968
969 static HRESULT compile_exitsub_statement(compile_ctx_t *ctx)
970 {
971 if(!ctx->sub_end_label) {
972 FIXME("Exit Sub outside Sub?\n");
973 return E_FAIL;
974 }
975
976 return exit_label(ctx, ctx->sub_end_label);
977 }
978
979 static HRESULT compile_exitfunc_statement(compile_ctx_t *ctx)
980 {
981 if(!ctx->func_end_label) {
982 FIXME("Exit Function outside Function?\n");
983 return E_FAIL;
984 }
985
986 return exit_label(ctx, ctx->func_end_label);
987 }
988
989 static HRESULT compile_exitprop_statement(compile_ctx_t *ctx)
990 {
991 if(!ctx->prop_end_label) {
992 FIXME("Exit Property outside Property?\n");
993 return E_FAIL;
994 }
995
996 return exit_label(ctx, ctx->prop_end_label);
997 }
998
999 static HRESULT compile_onerror_statement(compile_ctx_t *ctx, onerror_statement_t *stat)
1000 {
1001 return push_instr_int(ctx, OP_errmode, stat->resume_next);
1002 }
1003
1004 static HRESULT compile_statement(compile_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
1005 {
1006 HRESULT hres;
1007
1008 if(stat_ctx) {
1009 stat_ctx->next = ctx->stat_ctx;
1010 ctx->stat_ctx = stat_ctx;
1011 }
1012
1013 while(stat) {
1014 switch(stat->type) {
1015 case STAT_ASSIGN:
1016 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, FALSE);
1017 break;
1018 case STAT_CALL:
1019 hres = compile_call_statement(ctx, (call_statement_t*)stat);
1020 break;
1021 case STAT_CONST:
1022 hres = compile_const_statement(ctx, (const_statement_t*)stat);
1023 break;
1024 case STAT_DIM:
1025 hres = compile_dim_statement(ctx, (dim_statement_t*)stat);
1026 break;
1027 case STAT_DOWHILE:
1028 case STAT_DOUNTIL:
1029 hres = compile_dowhile_statement(ctx, (while_statement_t*)stat);
1030 break;
1031 case STAT_EXITDO:
1032 hres = compile_exitdo_statement(ctx);
1033 break;
1034 case STAT_EXITFOR:
1035 hres = compile_exitfor_statement(ctx);
1036 break;
1037 case STAT_EXITFUNC:
1038 hres = compile_exitfunc_statement(ctx);
1039 break;
1040 case STAT_EXITPROP:
1041 hres = compile_exitprop_statement(ctx);
1042 break;
1043 case STAT_EXITSUB:
1044 hres = compile_exitsub_statement(ctx);
1045 break;
1046 case STAT_FOREACH:
1047 hres = compile_foreach_statement(ctx, (foreach_statement_t*)stat);
1048 break;
1049 case STAT_FORTO:
1050 hres = compile_forto_statement(ctx, (forto_statement_t*)stat);
1051 break;
1052 case STAT_FUNC:
1053 hres = compile_function_statement(ctx, (function_statement_t*)stat);
1054 break;
1055 case STAT_IF:
1056 hres = compile_if_statement(ctx, (if_statement_t*)stat);
1057 break;
1058 case STAT_ONERROR:
1059 hres = compile_onerror_statement(ctx, (onerror_statement_t*)stat);
1060 break;
1061 case STAT_SET:
1062 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, TRUE);
1063 break;
1064 case STAT_STOP:
1065 hres = push_instr(ctx, OP_stop) ? S_OK : E_OUTOFMEMORY;
1066 break;
1067 case STAT_UNTIL:
1068 case STAT_WHILE:
1069 case STAT_WHILELOOP:
1070 hres = compile_while_statement(ctx, (while_statement_t*)stat);
1071 break;
1072 default:
1073 FIXME("Unimplemented statement type %d\n", stat->type);
1074 hres = E_NOTIMPL;
1075 }
1076
1077 if(FAILED(hres))
1078 return hres;
1079 stat = stat->next;
1080 }
1081
1082 if(stat_ctx) {
1083 assert(ctx->stat_ctx == stat_ctx);
1084 ctx->stat_ctx = stat_ctx->next;
1085 }
1086
1087 return S_OK;
1088 }
1089
1090 static void resolve_labels(compile_ctx_t *ctx, unsigned off)
1091 {
1092 instr_t *instr;
1093
1094 for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
1095 if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->arg1.uint & LABEL_FLAG)) {
1096 assert((instr->arg1.uint & ~LABEL_FLAG) < ctx->labels_cnt);
1097 instr->arg1.uint = ctx->labels[instr->arg1.uint & ~LABEL_FLAG];
1098 }
1099 assert(instr_info[instr->op].arg2_type != ARG_ADDR);
1100 }
1101
1102 ctx->labels_cnt = 0;
1103 }
1104
1105 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
1106 {
1107 HRESULT hres;
1108
1109 func->code_off = ctx->instr_cnt;
1110
1111 ctx->sub_end_label = 0;
1112 ctx->func_end_label = 0;
1113 ctx->prop_end_label = 0;
1114
1115 switch(func->type) {
1116 case FUNC_FUNCTION:
1117 ctx->func_end_label = alloc_label(ctx);
1118 if(!ctx->func_end_label)
1119 return E_OUTOFMEMORY;
1120 break;
1121 case FUNC_SUB:
1122 ctx->sub_end_label = alloc_label(ctx);
1123 if(!ctx->sub_end_label)
1124 return E_OUTOFMEMORY;
1125 break;
1126 case FUNC_PROPGET:
1127 case FUNC_PROPLET:
1128 case FUNC_PROPSET:
1129 case FUNC_DEFGET:
1130 ctx->prop_end_label = alloc_label(ctx);
1131 if(!ctx->prop_end_label)
1132 return E_OUTOFMEMORY;
1133 break;
1134 case FUNC_GLOBAL:
1135 break;
1136 }
1137
1138 ctx->func = func;
1139 ctx->dim_decls = NULL;
1140 ctx->const_decls = NULL;
1141 hres = compile_statement(ctx, NULL, stat);
1142 ctx->func = NULL;
1143 if(FAILED(hres))
1144 return hres;
1145
1146 if(ctx->sub_end_label)
1147 label_set_addr(ctx, ctx->sub_end_label);
1148 if(ctx->func_end_label)
1149 label_set_addr(ctx, ctx->func_end_label);
1150 if(ctx->prop_end_label)
1151 label_set_addr(ctx, ctx->prop_end_label);
1152
1153 if(!push_instr(ctx, OP_ret))
1154 return E_OUTOFMEMORY;
1155
1156 resolve_labels(ctx, func->code_off);
1157
1158 if(func->var_cnt) {
1159 dim_decl_t *dim_decl;
1160
1161 if(func->type == FUNC_GLOBAL) {
1162 dynamic_var_t *new_var;
1163
1164 func->var_cnt = 0;
1165
1166 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
1167 new_var = compiler_alloc(ctx->code, sizeof(*new_var));
1168 if(!new_var)
1169 return E_OUTOFMEMORY;
1170
1171 new_var->name = compiler_alloc_string(ctx->code, dim_decl->name);
1172 if(!new_var->name)
1173 return E_OUTOFMEMORY;
1174
1175 V_VT(&new_var->v) = VT_EMPTY;
1176 new_var->is_const = FALSE;
1177
1178 new_var->next = ctx->global_vars;
1179 ctx->global_vars = new_var;
1180 }
1181 }else {
1182 unsigned i;
1183
1184 func->vars = compiler_alloc(ctx->code, func->var_cnt * sizeof(var_desc_t));
1185 if(!func->vars)
1186 return E_OUTOFMEMORY;
1187
1188 for(dim_decl = ctx->dim_decls, i=0; dim_decl; dim_decl = dim_decl->next, i++) {
1189 func->vars[i].name = compiler_alloc_string(ctx->code, dim_decl->name);
1190 if(!func->vars[i].name)
1191 return E_OUTOFMEMORY;
1192 }
1193
1194 assert(i == func->var_cnt);
1195 }
1196 }
1197
1198 return S_OK;
1199 }
1200
1201 static BOOL lookup_funcs_name(compile_ctx_t *ctx, const WCHAR *name)
1202 {
1203 function_t *iter;
1204
1205 for(iter = ctx->funcs; iter; iter = iter->next) {
1206 if(!strcmpiW(iter->name, name))
1207 return TRUE;
1208 }
1209
1210 return FALSE;
1211 }
1212
1213 static HRESULT create_function(compile_ctx_t *ctx, function_decl_t *decl, function_t **ret)
1214 {
1215 function_t *func;
1216 HRESULT hres;
1217
1218 if(lookup_dim_decls(ctx, decl->name) || lookup_funcs_name(ctx, decl->name) || lookup_const_decls(ctx, decl->name, FALSE)) {
1219 FIXME("%s: redefinition\n", debugstr_w(decl->name));
1220 return E_FAIL;
1221 }
1222
1223 func = compiler_alloc(ctx->code, sizeof(*func));
1224 if(!func)
1225 return E_OUTOFMEMORY;
1226
1227 func->name = compiler_alloc_string(ctx->code, decl->name);
1228 if(!func->name)
1229 return E_OUTOFMEMORY;
1230
1231 func->vars = NULL;
1232 func->var_cnt = 0;
1233 func->code_ctx = ctx->code;
1234 func->type = decl->type;
1235 func->is_public = decl->is_public;
1236
1237 func->arg_cnt = 0;
1238 if(decl->args) {
1239 arg_decl_t *arg;
1240 unsigned i;
1241
1242 for(arg = decl->args; arg; arg = arg->next)
1243 func->arg_cnt++;
1244
1245 func->args = compiler_alloc(ctx->code, func->arg_cnt * sizeof(arg_desc_t));
1246 if(!func->args)
1247 return E_OUTOFMEMORY;
1248
1249 for(i = 0, arg = decl->args; arg; arg = arg->next, i++) {
1250 func->args[i].name = compiler_alloc_string(ctx->code, arg->name);
1251 if(!func->args[i].name)
1252 return E_OUTOFMEMORY;
1253 func->args[i].by_ref = arg->by_ref;
1254 }
1255 }else {
1256 func->args = NULL;
1257 }
1258
1259 hres = compile_func(ctx, decl->body, func);
1260 if(FAILED(hres))
1261 return hres;
1262
1263 *ret = func;
1264 return S_OK;
1265 }
1266
1267 static BOOL lookup_class_name(compile_ctx_t *ctx, const WCHAR *name)
1268 {
1269 class_desc_t *iter;
1270
1271 for(iter = ctx->classes; iter; iter = iter->next) {
1272 if(!strcmpiW(iter->name, name))
1273 return TRUE;
1274 }
1275
1276 return FALSE;
1277 }
1278
1279 static HRESULT create_class_funcprop(compile_ctx_t *ctx, function_decl_t *func_decl, vbdisp_funcprop_desc_t *desc)
1280 {
1281 vbdisp_invoke_type_t invoke_type;
1282 function_decl_t *funcprop_decl;
1283 HRESULT hres;
1284
1285 desc->name = compiler_alloc_string(ctx->code, func_decl->name);
1286 if(!desc->name)
1287 return E_OUTOFMEMORY;
1288
1289 for(funcprop_decl = func_decl; funcprop_decl; funcprop_decl = funcprop_decl->next_prop_func) {
1290 switch(funcprop_decl->type) {
1291 case FUNC_FUNCTION:
1292 case FUNC_SUB:
1293 case FUNC_PROPGET:
1294 case FUNC_DEFGET:
1295 invoke_type = VBDISP_CALLGET;
1296 break;
1297 case FUNC_PROPLET:
1298 invoke_type = VBDISP_LET;
1299 break;
1300 case FUNC_PROPSET:
1301 invoke_type = VBDISP_SET;
1302 break;
1303 default:
1304 assert(0);
1305 }
1306
1307 assert(!desc->entries[invoke_type]);
1308
1309 if(funcprop_decl->is_public)
1310 desc->is_public = TRUE;
1311
1312 hres = create_function(ctx, funcprop_decl, desc->entries+invoke_type);
1313 if(FAILED(hres))
1314 return hres;
1315 }
1316
1317 return S_OK;
1318 }
1319
1320 static BOOL lookup_class_funcs(class_desc_t *class_desc, const WCHAR *name)
1321 {
1322 unsigned i;
1323
1324 for(i=0; i < class_desc->func_cnt; i++) {
1325 if(class_desc->funcs[i].name && !strcmpiW(class_desc->funcs[i].name, name))
1326 return TRUE;
1327 }
1328
1329 return FALSE;
1330 }
1331
1332 static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
1333 {
1334 function_decl_t *func_decl, *func_prop_decl;
1335 class_prop_decl_t *prop_decl;
1336 class_desc_t *class_desc;
1337 unsigned i;
1338 HRESULT hres;
1339
1340 static const WCHAR class_initializeW[] = {'c','l','a','s','s','_','i','n','i','t','i','a','l','i','z','e',0};
1341 static const WCHAR class_terminateW[] = {'c','l','a','s','s','_','t','e','r','m','i','n','a','t','e',0};
1342
1343 if(lookup_dim_decls(ctx, class_decl->name) || lookup_funcs_name(ctx, class_decl->name)
1344 || lookup_const_decls(ctx, class_decl->name, FALSE) || lookup_class_name(ctx, class_decl->name)) {
1345 FIXME("%s: redefinition\n", debugstr_w(class_decl->name));
1346 return E_FAIL;
1347 }
1348
1349 class_desc = compiler_alloc_zero(ctx->code, sizeof(*class_desc));
1350 if(!class_desc)
1351 return E_OUTOFMEMORY;
1352
1353 class_desc->name = compiler_alloc_string(ctx->code, class_decl->name);
1354 if(!class_desc->name)
1355 return E_OUTOFMEMORY;
1356
1357 class_desc->func_cnt = 1; /* always allocate slot for default getter */
1358
1359 for(func_decl = class_decl->funcs; func_decl; func_decl = func_decl->next) {
1360 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1361 if(func_prop_decl->type == FUNC_DEFGET)
1362 break;
1363 }
1364 if(!func_prop_decl)
1365 class_desc->func_cnt++;
1366 }
1367
1368 class_desc->funcs = compiler_alloc(ctx->code, class_desc->func_cnt*sizeof(*class_desc->funcs));
1369 if(!class_desc->funcs)
1370 return E_OUTOFMEMORY;
1371 memset(class_desc->funcs, 0, class_desc->func_cnt*sizeof(*class_desc->funcs));
1372
1373 for(func_decl = class_decl->funcs, i=1; func_decl; func_decl = func_decl->next, i++) {
1374 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1375 if(func_prop_decl->type == FUNC_DEFGET) {
1376 i--;
1377 break;
1378 }
1379 }
1380
1381 if(!strcmpiW(class_initializeW, func_decl->name)) {
1382 if(func_decl->type != FUNC_SUB) {
1383 FIXME("class initializer is not sub\n");
1384 return E_FAIL;
1385 }
1386
1387 class_desc->class_initialize_id = i;
1388 }else if(!strcmpiW(class_terminateW, func_decl->name)) {
1389 if(func_decl->type != FUNC_SUB) {
1390 FIXME("class terminator is not sub\n");
1391 return E_FAIL;
1392 }
1393
1394 class_desc->class_terminate_id = i;
1395 }
1396
1397 hres = create_class_funcprop(ctx, func_decl, class_desc->funcs + (func_prop_decl ? 0 : i));
1398 if(FAILED(hres))
1399 return hres;
1400 }
1401
1402 for(prop_decl = class_decl->props; prop_decl; prop_decl = prop_decl->next)
1403 class_desc->prop_cnt++;
1404
1405 class_desc->props = compiler_alloc(ctx->code, class_desc->prop_cnt*sizeof(*class_desc->props));
1406 if(!class_desc->props)
1407 return E_OUTOFMEMORY;
1408
1409 for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next, i++) {
1410 if(lookup_class_funcs(class_desc, prop_decl->name)) {
1411 FIXME("Property %s redefined\n", debugstr_w(prop_decl->name));
1412 return E_FAIL;
1413 }
1414
1415 class_desc->props[i].name = compiler_alloc_string(ctx->code, prop_decl->name);
1416 if(!class_desc->props[i].name)
1417 return E_OUTOFMEMORY;
1418
1419 class_desc->props[i].is_public = prop_decl->is_public;
1420 }
1421
1422 class_desc->next = ctx->classes;
1423 ctx->classes = class_desc;
1424 return S_OK;
1425 }
1426
1427 static BOOL lookup_script_identifier(script_ctx_t *script, const WCHAR *identifier)
1428 {
1429 class_desc_t *class;
1430 dynamic_var_t *var;
1431 function_t *func;
1432
1433 for(var = script->global_vars; var; var = var->next) {
1434 if(!strcmpiW(var->name, identifier))
1435 return TRUE;
1436 }
1437
1438 for(func = script->global_funcs; func; func = func->next) {
1439 if(!strcmpiW(func->name, identifier))
1440 return TRUE;
1441 }
1442
1443 for(class = script->classes; class; class = class->next) {
1444 if(!strcmpiW(class->name, identifier))
1445 return TRUE;
1446 }
1447
1448 return FALSE;
1449 }
1450
1451 static HRESULT check_script_collisions(compile_ctx_t *ctx, script_ctx_t *script)
1452 {
1453 class_desc_t *class;
1454 dynamic_var_t *var;
1455 function_t *func;
1456
1457 for(var = ctx->global_vars; var; var = var->next) {
1458 if(lookup_script_identifier(script, var->name)) {
1459 FIXME("%s: redefined\n", debugstr_w(var->name));
1460 return E_FAIL;
1461 }
1462 }
1463
1464 for(func = ctx->funcs; func; func = func->next) {
1465 if(lookup_script_identifier(script, func->name)) {
1466 FIXME("%s: redefined\n", debugstr_w(func->name));
1467 return E_FAIL;
1468 }
1469 }
1470
1471 for(class = ctx->classes; class; class = class->next) {
1472 if(lookup_script_identifier(script, class->name)) {
1473 FIXME("%s: redefined\n", debugstr_w(class->name));
1474 return E_FAIL;
1475 }
1476 }
1477
1478 return S_OK;
1479 }
1480
1481 void release_vbscode(vbscode_t *code)
1482 {
1483 unsigned i;
1484
1485 list_remove(&code->entry);
1486
1487 for(i=0; i < code->bstr_cnt; i++)
1488 SysFreeString(code->bstr_pool[i]);
1489
1490 vbsheap_free(&code->heap);
1491
1492 heap_free(code->bstr_pool);
1493 heap_free(code->source);
1494 heap_free(code->instrs);
1495 heap_free(code);
1496 }
1497
1498 static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source)
1499 {
1500 vbscode_t *ret;
1501
1502 ret = heap_alloc(sizeof(*ret));
1503 if(!ret)
1504 return NULL;
1505
1506 ret->source = heap_strdupW(source);
1507 if(!ret->source) {
1508 heap_free(ret);
1509 return NULL;
1510 }
1511
1512 ret->instrs = heap_alloc(32*sizeof(instr_t));
1513 if(!ret->instrs) {
1514 release_vbscode(ret);
1515 return NULL;
1516 }
1517
1518 ctx->instr_cnt = 1;
1519 ctx->instr_size = 32;
1520 vbsheap_init(&ret->heap);
1521
1522 ret->option_explicit = ctx->parser.option_explicit;
1523
1524 ret->bstr_pool = NULL;
1525 ret->bstr_pool_size = 0;
1526 ret->bstr_cnt = 0;
1527 ret->global_executed = FALSE;
1528
1529 ret->global_code.type = FUNC_GLOBAL;
1530 ret->global_code.name = NULL;
1531 ret->global_code.code_ctx = ret;
1532 ret->global_code.vars = NULL;
1533 ret->global_code.var_cnt = 0;
1534 ret->global_code.arg_cnt = 0;
1535 ret->global_code.args = NULL;
1536
1537 list_init(&ret->entry);
1538 return ret;
1539 }
1540
1541 static void release_compiler(compile_ctx_t *ctx)
1542 {
1543 parser_release(&ctx->parser);
1544 heap_free(ctx->labels);
1545 if(ctx->code)
1546 release_vbscode(ctx->code);
1547 }
1548
1549 HRESULT compile_script(script_ctx_t *script, const WCHAR *src, vbscode_t **ret)
1550 {
1551 function_t *new_func;
1552 function_decl_t *func_decl;
1553 class_decl_t *class_decl;
1554 compile_ctx_t ctx;
1555 vbscode_t *code;
1556 HRESULT hres;
1557
1558 hres = parse_script(&ctx.parser, src);
1559 if(FAILED(hres))
1560 return hres;
1561
1562 code = ctx.code = alloc_vbscode(&ctx, src);
1563 if(!ctx.code)
1564 return E_OUTOFMEMORY;
1565
1566 ctx.funcs = NULL;
1567 ctx.func_decls = NULL;
1568 ctx.global_vars = NULL;
1569 ctx.dim_decls = NULL;
1570 ctx.classes = NULL;
1571 ctx.labels = NULL;
1572 ctx.global_consts = NULL;
1573 ctx.stat_ctx = NULL;
1574 ctx.labels_cnt = ctx.labels_size = 0;
1575
1576 hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->global_code);
1577 if(FAILED(hres)) {
1578 release_compiler(&ctx);
1579 return hres;
1580 }
1581
1582 ctx.global_consts = ctx.const_decls;
1583
1584 for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
1585 hres = create_function(&ctx, func_decl, &new_func);
1586 if(FAILED(hres)) {
1587 release_compiler(&ctx);
1588 return hres;
1589 }
1590
1591 new_func->next = ctx.funcs;
1592 ctx.funcs = new_func;
1593 }
1594
1595 for(class_decl = ctx.parser.class_decls; class_decl; class_decl = class_decl->next) {
1596 hres = compile_class(&ctx, class_decl);
1597 if(FAILED(hres)) {
1598 release_compiler(&ctx);
1599 return hres;
1600 }
1601 }
1602
1603 hres = check_script_collisions(&ctx, script);
1604 if(FAILED(hres)) {
1605 release_compiler(&ctx);
1606 return hres;
1607 }
1608
1609 if(ctx.global_vars) {
1610 dynamic_var_t *var;
1611
1612 for(var = ctx.global_vars; var->next; var = var->next);
1613
1614 var->next = script->global_vars;
1615 script->global_vars = ctx.global_vars;
1616 }
1617
1618 if(ctx.funcs) {
1619 for(new_func = ctx.funcs; new_func->next; new_func = new_func->next);
1620
1621 new_func->next = script->global_funcs;
1622 script->global_funcs = ctx.funcs;
1623 }
1624
1625 if(ctx.classes) {
1626 class_desc_t *class = ctx.classes;
1627
1628 while(1) {
1629 class->ctx = script;
1630 if(!class->next)
1631 break;
1632 class = class->next;
1633 }
1634
1635 class->next = script->classes;
1636 script->classes = ctx.classes;
1637 }
1638
1639 if(TRACE_ON(vbscript_disas))
1640 dump_code(&ctx);
1641
1642 ctx.code = NULL;
1643 release_compiler(&ctx);
1644
1645 list_add_tail(&script->code_list, &code->entry);
1646 *ret = code;
1647 return S_OK;
1648 }
Maarten's multimedia branch