?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
shlwapi: Use proper helpers for iface calls.
[wine/multimedia.git] / dlls / vbscript / compile.c
blob12db4e06b5049a483a62cfc3a70e76f46d10f7a2
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_select_statement(compile_ctx_t *ctx, select_statement_t *stat)
756 {
757 unsigned end_label, case_cnt = 0, *case_labels = NULL, i;
758 case_clausule_t *case_iter;
759 expression_t *expr_iter;
760 HRESULT hres;
761
762 hres = compile_expression(ctx, stat->expr);
763 if(FAILED(hres))
764 return hres;
765
766 if(!push_instr(ctx, OP_val))
767 return E_OUTOFMEMORY;
768
769 end_label = alloc_label(ctx);
770 if(!end_label)
771 return E_OUTOFMEMORY;
772
773 for(case_iter = stat->case_clausules; case_iter; case_iter = case_iter->next)
774 case_cnt++;
775
776 if(case_cnt) {
777 case_labels = heap_alloc(case_cnt*sizeof(*case_labels));
778 if(!case_labels)
779 return E_OUTOFMEMORY;
780 }
781
782 for(case_iter = stat->case_clausules, i=0; case_iter; case_iter = case_iter->next, i++) {
783 case_labels[i] = alloc_label(ctx);
784 if(!case_labels[i]) {
785 hres = E_OUTOFMEMORY;
786 break;
787 }
788
789 if(!case_iter->expr)
790 break;
791
792 for(expr_iter = case_iter->expr; expr_iter; expr_iter = expr_iter->next) {
793 hres = compile_expression(ctx, expr_iter);
794 if(FAILED(hres))
795 break;
796
797 hres = push_instr_addr(ctx, OP_case, case_labels[i]);
798 if(FAILED(hres))
799 break;
800 }
801 }
802
803 if(FAILED(hres)) {
804 heap_free(case_labels);
805 return hres;
806 }
807
808 hres = push_instr_uint(ctx, OP_pop, 1);
809 if(FAILED(hres)) {
810 heap_free(case_labels);
811 return hres;
812 }
813
814 hres = push_instr_addr(ctx, OP_jmp, case_iter ? case_labels[i] : end_label);
815 if(FAILED(hres)) {
816 heap_free(case_labels);
817 return hres;
818 }
819
820 for(case_iter = stat->case_clausules, i=0; case_iter; case_iter = case_iter->next, i++) {
821 label_set_addr(ctx, case_labels[i]);
822 hres = compile_statement(ctx, NULL, case_iter->stat);
823 if(FAILED(hres))
824 break;
825
826 if(!case_iter->next)
827 break;
828
829 hres = push_instr_addr(ctx, OP_jmp, end_label);
830 if(FAILED(hres))
831 return hres;
832 }
833
834 heap_free(case_labels);
835 if(FAILED(hres))
836 return hres;
837
838 label_set_addr(ctx, end_label);
839 return S_OK;
840 }
841
842 static HRESULT compile_assignment(compile_ctx_t *ctx, member_expression_t *member_expr, expression_t *value_expr, BOOL is_set)
843 {
844 unsigned args_cnt;
845 vbsop_t op;
846 HRESULT hres;
847
848 if(member_expr->obj_expr) {
849 hres = compile_expression(ctx, member_expr->obj_expr);
850 if(FAILED(hres))
851 return hres;
852
853 op = is_set ? OP_set_member : OP_assign_member;
854 }else {
855 op = is_set ? OP_set_ident : OP_assign_ident;
856 }
857
858 hres = compile_expression(ctx, value_expr);
859 if(FAILED(hres))
860 return hres;
861
862 hres = compile_args(ctx, member_expr->args, &args_cnt);
863 if(FAILED(hres))
864 return hres;
865
866 return push_instr_bstr_uint(ctx, op, member_expr->identifier, args_cnt);
867 }
868
869 static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *stat, BOOL is_set)
870 {
871 return compile_assignment(ctx, stat->member_expr, stat->value_expr, is_set);
872 }
873
874 static HRESULT compile_call_statement(compile_ctx_t *ctx, call_statement_t *stat)
875 {
876 /* It's challenging for parser to distinguish parameterized assignment with one argument from call
877 * with equality expression argument, so we do it in compiler. */
878 if(!stat->is_strict && stat->expr->args && !stat->expr->args->next && stat->expr->args->type == EXPR_EQUAL) {
879 binary_expression_t *eqexpr = (binary_expression_t*)stat->expr->args;
880
881 if(eqexpr->left->type == EXPR_BRACKETS) {
882 member_expression_t new_member = *stat->expr;
883
884 WARN("converting call expr to assign expr\n");
885
886 new_member.args = ((unary_expression_t*)eqexpr->left)->subexpr;
887 return compile_assignment(ctx, &new_member, eqexpr->right, FALSE);
888 }
889 }
890
891 return compile_member_expression(ctx, stat->expr, FALSE);
892 }
893
894 static BOOL lookup_dim_decls(compile_ctx_t *ctx, const WCHAR *name)
895 {
896 dim_decl_t *dim_decl;
897
898 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
899 if(!strcmpiW(dim_decl->name, name))
900 return TRUE;
901 }
902
903 return FALSE;
904 }
905
906 static BOOL lookup_args_name(compile_ctx_t *ctx, const WCHAR *name)
907 {
908 unsigned i;
909
910 for(i = 0; i < ctx->func->arg_cnt; i++) {
911 if(!strcmpiW(ctx->func->args[i].name, name))
912 return TRUE;
913 }
914
915 return FALSE;
916 }
917
918 static HRESULT compile_dim_statement(compile_ctx_t *ctx, dim_statement_t *stat)
919 {
920 dim_decl_t *dim_decl = stat->dim_decls;
921
922 while(1) {
923 if(lookup_dim_decls(ctx, dim_decl->name) || lookup_args_name(ctx, dim_decl->name)
924 || lookup_const_decls(ctx, dim_decl->name, FALSE)) {
925 FIXME("dim %s name redefined\n", debugstr_w(dim_decl->name));
926 return E_FAIL;
927 }
928
929 ctx->func->var_cnt++;
930 if(!dim_decl->next)
931 break;
932 dim_decl = dim_decl->next;
933 }
934
935 dim_decl->next = ctx->dim_decls;
936 ctx->dim_decls = stat->dim_decls;
937 return S_OK;
938 }
939
940 static HRESULT compile_const_statement(compile_ctx_t *ctx, const_statement_t *stat)
941 {
942 const_decl_t *decl, *next_decl = stat->decls;
943
944 do {
945 decl = next_decl;
946
947 if(lookup_const_decls(ctx, decl->name, FALSE) || lookup_args_name(ctx, decl->name)
948 || lookup_dim_decls(ctx, decl->name)) {
949 FIXME("%s redefined\n", debugstr_w(decl->name));
950 return E_FAIL;
951 }
952
953 if(ctx->func->type == FUNC_GLOBAL) {
954 HRESULT hres;
955
956 hres = compile_expression(ctx, decl->value_expr);
957 if(FAILED(hres))
958 return hres;
959
960 hres = push_instr_bstr(ctx, OP_const, decl->name);
961 if(FAILED(hres))
962 return hres;
963 }
964
965 next_decl = decl->next;
966 decl->next = ctx->const_decls;
967 ctx->const_decls = decl;
968 } while(next_decl);
969
970 return S_OK;
971 }
972
973 static HRESULT compile_function_statement(compile_ctx_t *ctx, function_statement_t *stat)
974 {
975 if(ctx->func != &ctx->code->global_code) {
976 FIXME("Function is not in the global code\n");
977 return E_FAIL;
978 }
979
980 stat->func_decl->next = ctx->func_decls;
981 ctx->func_decls = stat->func_decl;
982 return S_OK;
983 }
984
985 static HRESULT compile_exitdo_statement(compile_ctx_t *ctx)
986 {
987 statement_ctx_t *iter;
988 unsigned pop_cnt = 0;
989
990 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
991 pop_cnt += iter->stack_use;
992 if(iter->while_end_label)
993 break;
994 }
995 if(!iter) {
996 FIXME("Exit Do outside Do Loop\n");
997 return E_FAIL;
998 }
999
1000 if(pop_cnt) {
1001 HRESULT hres;
1002
1003 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1004 if(FAILED(hres))
1005 return hres;
1006 }
1007
1008 return push_instr_addr(ctx, OP_jmp, iter->while_end_label);
1009 }
1010
1011 static HRESULT compile_exitfor_statement(compile_ctx_t *ctx)
1012 {
1013 statement_ctx_t *iter;
1014 unsigned pop_cnt = 0;
1015
1016 for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1017 pop_cnt += iter->stack_use;
1018 if(iter->for_end_label)
1019 break;
1020 }
1021 if(!iter) {
1022 FIXME("Exit For outside For loop\n");
1023 return E_FAIL;
1024 }
1025
1026 if(pop_cnt) {
1027 HRESULT hres;
1028
1029 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1030 if(FAILED(hres))
1031 return hres;
1032 }
1033
1034 return push_instr_addr(ctx, OP_jmp, iter->for_end_label);
1035 }
1036
1037 static HRESULT exit_label(compile_ctx_t *ctx, unsigned jmp_label)
1038 {
1039 statement_ctx_t *iter;
1040 unsigned pop_cnt = 0;
1041
1042 for(iter = ctx->stat_ctx; iter; iter = iter->next)
1043 pop_cnt += iter->stack_use;
1044
1045 if(pop_cnt) {
1046 HRESULT hres;
1047
1048 hres = push_instr_uint(ctx, OP_pop, pop_cnt);
1049 if(FAILED(hres))
1050 return hres;
1051 }
1052
1053 return push_instr_addr(ctx, OP_jmp, jmp_label);
1054 }
1055
1056 static HRESULT compile_exitsub_statement(compile_ctx_t *ctx)
1057 {
1058 if(!ctx->sub_end_label) {
1059 FIXME("Exit Sub outside Sub?\n");
1060 return E_FAIL;
1061 }
1062
1063 return exit_label(ctx, ctx->sub_end_label);
1064 }
1065
1066 static HRESULT compile_exitfunc_statement(compile_ctx_t *ctx)
1067 {
1068 if(!ctx->func_end_label) {
1069 FIXME("Exit Function outside Function?\n");
1070 return E_FAIL;
1071 }
1072
1073 return exit_label(ctx, ctx->func_end_label);
1074 }
1075
1076 static HRESULT compile_exitprop_statement(compile_ctx_t *ctx)
1077 {
1078 if(!ctx->prop_end_label) {
1079 FIXME("Exit Property outside Property?\n");
1080 return E_FAIL;
1081 }
1082
1083 return exit_label(ctx, ctx->prop_end_label);
1084 }
1085
1086 static HRESULT compile_onerror_statement(compile_ctx_t *ctx, onerror_statement_t *stat)
1087 {
1088 return push_instr_int(ctx, OP_errmode, stat->resume_next);
1089 }
1090
1091 static HRESULT compile_statement(compile_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
1092 {
1093 HRESULT hres;
1094
1095 if(stat_ctx) {
1096 stat_ctx->next = ctx->stat_ctx;
1097 ctx->stat_ctx = stat_ctx;
1098 }
1099
1100 while(stat) {
1101 switch(stat->type) {
1102 case STAT_ASSIGN:
1103 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, FALSE);
1104 break;
1105 case STAT_CALL:
1106 hres = compile_call_statement(ctx, (call_statement_t*)stat);
1107 break;
1108 case STAT_CONST:
1109 hres = compile_const_statement(ctx, (const_statement_t*)stat);
1110 break;
1111 case STAT_DIM:
1112 hres = compile_dim_statement(ctx, (dim_statement_t*)stat);
1113 break;
1114 case STAT_DOWHILE:
1115 case STAT_DOUNTIL:
1116 hres = compile_dowhile_statement(ctx, (while_statement_t*)stat);
1117 break;
1118 case STAT_EXITDO:
1119 hres = compile_exitdo_statement(ctx);
1120 break;
1121 case STAT_EXITFOR:
1122 hres = compile_exitfor_statement(ctx);
1123 break;
1124 case STAT_EXITFUNC:
1125 hres = compile_exitfunc_statement(ctx);
1126 break;
1127 case STAT_EXITPROP:
1128 hres = compile_exitprop_statement(ctx);
1129 break;
1130 case STAT_EXITSUB:
1131 hres = compile_exitsub_statement(ctx);
1132 break;
1133 case STAT_FOREACH:
1134 hres = compile_foreach_statement(ctx, (foreach_statement_t*)stat);
1135 break;
1136 case STAT_FORTO:
1137 hres = compile_forto_statement(ctx, (forto_statement_t*)stat);
1138 break;
1139 case STAT_FUNC:
1140 hres = compile_function_statement(ctx, (function_statement_t*)stat);
1141 break;
1142 case STAT_IF:
1143 hres = compile_if_statement(ctx, (if_statement_t*)stat);
1144 break;
1145 case STAT_ONERROR:
1146 hres = compile_onerror_statement(ctx, (onerror_statement_t*)stat);
1147 break;
1148 case STAT_SELECT:
1149 hres = compile_select_statement(ctx, (select_statement_t*)stat);
1150 break;
1151 case STAT_SET:
1152 hres = compile_assign_statement(ctx, (assign_statement_t*)stat, TRUE);
1153 break;
1154 case STAT_STOP:
1155 hres = push_instr(ctx, OP_stop) ? S_OK : E_OUTOFMEMORY;
1156 break;
1157 case STAT_UNTIL:
1158 case STAT_WHILE:
1159 case STAT_WHILELOOP:
1160 hres = compile_while_statement(ctx, (while_statement_t*)stat);
1161 break;
1162 default:
1163 FIXME("Unimplemented statement type %d\n", stat->type);
1164 hres = E_NOTIMPL;
1165 }
1166
1167 if(FAILED(hres))
1168 return hres;
1169 stat = stat->next;
1170 }
1171
1172 if(stat_ctx) {
1173 assert(ctx->stat_ctx == stat_ctx);
1174 ctx->stat_ctx = stat_ctx->next;
1175 }
1176
1177 return S_OK;
1178 }
1179
1180 static void resolve_labels(compile_ctx_t *ctx, unsigned off)
1181 {
1182 instr_t *instr;
1183
1184 for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
1185 if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->arg1.uint & LABEL_FLAG)) {
1186 assert((instr->arg1.uint & ~LABEL_FLAG) < ctx->labels_cnt);
1187 instr->arg1.uint = ctx->labels[instr->arg1.uint & ~LABEL_FLAG];
1188 }
1189 assert(instr_info[instr->op].arg2_type != ARG_ADDR);
1190 }
1191
1192 ctx->labels_cnt = 0;
1193 }
1194
1195 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
1196 {
1197 HRESULT hres;
1198
1199 func->code_off = ctx->instr_cnt;
1200
1201 ctx->sub_end_label = 0;
1202 ctx->func_end_label = 0;
1203 ctx->prop_end_label = 0;
1204
1205 switch(func->type) {
1206 case FUNC_FUNCTION:
1207 ctx->func_end_label = alloc_label(ctx);
1208 if(!ctx->func_end_label)
1209 return E_OUTOFMEMORY;
1210 break;
1211 case FUNC_SUB:
1212 ctx->sub_end_label = alloc_label(ctx);
1213 if(!ctx->sub_end_label)
1214 return E_OUTOFMEMORY;
1215 break;
1216 case FUNC_PROPGET:
1217 case FUNC_PROPLET:
1218 case FUNC_PROPSET:
1219 case FUNC_DEFGET:
1220 ctx->prop_end_label = alloc_label(ctx);
1221 if(!ctx->prop_end_label)
1222 return E_OUTOFMEMORY;
1223 break;
1224 case FUNC_GLOBAL:
1225 break;
1226 }
1227
1228 ctx->func = func;
1229 ctx->dim_decls = NULL;
1230 ctx->const_decls = NULL;
1231 hres = compile_statement(ctx, NULL, stat);
1232 ctx->func = NULL;
1233 if(FAILED(hres))
1234 return hres;
1235
1236 if(ctx->sub_end_label)
1237 label_set_addr(ctx, ctx->sub_end_label);
1238 if(ctx->func_end_label)
1239 label_set_addr(ctx, ctx->func_end_label);
1240 if(ctx->prop_end_label)
1241 label_set_addr(ctx, ctx->prop_end_label);
1242
1243 if(!push_instr(ctx, OP_ret))
1244 return E_OUTOFMEMORY;
1245
1246 resolve_labels(ctx, func->code_off);
1247
1248 if(func->var_cnt) {
1249 dim_decl_t *dim_decl;
1250
1251 if(func->type == FUNC_GLOBAL) {
1252 dynamic_var_t *new_var;
1253
1254 func->var_cnt = 0;
1255
1256 for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
1257 new_var = compiler_alloc(ctx->code, sizeof(*new_var));
1258 if(!new_var)
1259 return E_OUTOFMEMORY;
1260
1261 new_var->name = compiler_alloc_string(ctx->code, dim_decl->name);
1262 if(!new_var->name)
1263 return E_OUTOFMEMORY;
1264
1265 V_VT(&new_var->v) = VT_EMPTY;
1266 new_var->is_const = FALSE;
1267
1268 new_var->next = ctx->global_vars;
1269 ctx->global_vars = new_var;
1270 }
1271 }else {
1272 unsigned i;
1273
1274 func->vars = compiler_alloc(ctx->code, func->var_cnt * sizeof(var_desc_t));
1275 if(!func->vars)
1276 return E_OUTOFMEMORY;
1277
1278 for(dim_decl = ctx->dim_decls, i=0; dim_decl; dim_decl = dim_decl->next, i++) {
1279 func->vars[i].name = compiler_alloc_string(ctx->code, dim_decl->name);
1280 if(!func->vars[i].name)
1281 return E_OUTOFMEMORY;
1282 }
1283
1284 assert(i == func->var_cnt);
1285 }
1286 }
1287
1288 return S_OK;
1289 }
1290
1291 static BOOL lookup_funcs_name(compile_ctx_t *ctx, const WCHAR *name)
1292 {
1293 function_t *iter;
1294
1295 for(iter = ctx->funcs; iter; iter = iter->next) {
1296 if(!strcmpiW(iter->name, name))
1297 return TRUE;
1298 }
1299
1300 return FALSE;
1301 }
1302
1303 static HRESULT create_function(compile_ctx_t *ctx, function_decl_t *decl, function_t **ret)
1304 {
1305 function_t *func;
1306 HRESULT hres;
1307
1308 if(lookup_dim_decls(ctx, decl->name) || lookup_funcs_name(ctx, decl->name) || lookup_const_decls(ctx, decl->name, FALSE)) {
1309 FIXME("%s: redefinition\n", debugstr_w(decl->name));
1310 return E_FAIL;
1311 }
1312
1313 func = compiler_alloc(ctx->code, sizeof(*func));
1314 if(!func)
1315 return E_OUTOFMEMORY;
1316
1317 func->name = compiler_alloc_string(ctx->code, decl->name);
1318 if(!func->name)
1319 return E_OUTOFMEMORY;
1320
1321 func->vars = NULL;
1322 func->var_cnt = 0;
1323 func->code_ctx = ctx->code;
1324 func->type = decl->type;
1325 func->is_public = decl->is_public;
1326
1327 func->arg_cnt = 0;
1328 if(decl->args) {
1329 arg_decl_t *arg;
1330 unsigned i;
1331
1332 for(arg = decl->args; arg; arg = arg->next)
1333 func->arg_cnt++;
1334
1335 func->args = compiler_alloc(ctx->code, func->arg_cnt * sizeof(arg_desc_t));
1336 if(!func->args)
1337 return E_OUTOFMEMORY;
1338
1339 for(i = 0, arg = decl->args; arg; arg = arg->next, i++) {
1340 func->args[i].name = compiler_alloc_string(ctx->code, arg->name);
1341 if(!func->args[i].name)
1342 return E_OUTOFMEMORY;
1343 func->args[i].by_ref = arg->by_ref;
1344 }
1345 }else {
1346 func->args = NULL;
1347 }
1348
1349 hres = compile_func(ctx, decl->body, func);
1350 if(FAILED(hres))
1351 return hres;
1352
1353 *ret = func;
1354 return S_OK;
1355 }
1356
1357 static BOOL lookup_class_name(compile_ctx_t *ctx, const WCHAR *name)
1358 {
1359 class_desc_t *iter;
1360
1361 for(iter = ctx->classes; iter; iter = iter->next) {
1362 if(!strcmpiW(iter->name, name))
1363 return TRUE;
1364 }
1365
1366 return FALSE;
1367 }
1368
1369 static HRESULT create_class_funcprop(compile_ctx_t *ctx, function_decl_t *func_decl, vbdisp_funcprop_desc_t *desc)
1370 {
1371 vbdisp_invoke_type_t invoke_type;
1372 function_decl_t *funcprop_decl;
1373 HRESULT hres;
1374
1375 desc->name = compiler_alloc_string(ctx->code, func_decl->name);
1376 if(!desc->name)
1377 return E_OUTOFMEMORY;
1378
1379 for(funcprop_decl = func_decl; funcprop_decl; funcprop_decl = funcprop_decl->next_prop_func) {
1380 switch(funcprop_decl->type) {
1381 case FUNC_FUNCTION:
1382 case FUNC_SUB:
1383 case FUNC_PROPGET:
1384 case FUNC_DEFGET:
1385 invoke_type = VBDISP_CALLGET;
1386 break;
1387 case FUNC_PROPLET:
1388 invoke_type = VBDISP_LET;
1389 break;
1390 case FUNC_PROPSET:
1391 invoke_type = VBDISP_SET;
1392 break;
1393 default:
1394 assert(0);
1395 }
1396
1397 assert(!desc->entries[invoke_type]);
1398
1399 if(funcprop_decl->is_public)
1400 desc->is_public = TRUE;
1401
1402 hres = create_function(ctx, funcprop_decl, desc->entries+invoke_type);
1403 if(FAILED(hres))
1404 return hres;
1405 }
1406
1407 return S_OK;
1408 }
1409
1410 static BOOL lookup_class_funcs(class_desc_t *class_desc, const WCHAR *name)
1411 {
1412 unsigned i;
1413
1414 for(i=0; i < class_desc->func_cnt; i++) {
1415 if(class_desc->funcs[i].name && !strcmpiW(class_desc->funcs[i].name, name))
1416 return TRUE;
1417 }
1418
1419 return FALSE;
1420 }
1421
1422 static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
1423 {
1424 function_decl_t *func_decl, *func_prop_decl;
1425 class_prop_decl_t *prop_decl;
1426 class_desc_t *class_desc;
1427 unsigned i;
1428 HRESULT hres;
1429
1430 static const WCHAR class_initializeW[] = {'c','l','a','s','s','_','i','n','i','t','i','a','l','i','z','e',0};
1431 static const WCHAR class_terminateW[] = {'c','l','a','s','s','_','t','e','r','m','i','n','a','t','e',0};
1432
1433 if(lookup_dim_decls(ctx, class_decl->name) || lookup_funcs_name(ctx, class_decl->name)
1434 || lookup_const_decls(ctx, class_decl->name, FALSE) || lookup_class_name(ctx, class_decl->name)) {
1435 FIXME("%s: redefinition\n", debugstr_w(class_decl->name));
1436 return E_FAIL;
1437 }
1438
1439 class_desc = compiler_alloc_zero(ctx->code, sizeof(*class_desc));
1440 if(!class_desc)
1441 return E_OUTOFMEMORY;
1442
1443 class_desc->name = compiler_alloc_string(ctx->code, class_decl->name);
1444 if(!class_desc->name)
1445 return E_OUTOFMEMORY;
1446
1447 class_desc->func_cnt = 1; /* always allocate slot for default getter */
1448
1449 for(func_decl = class_decl->funcs; func_decl; func_decl = func_decl->next) {
1450 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1451 if(func_prop_decl->type == FUNC_DEFGET)
1452 break;
1453 }
1454 if(!func_prop_decl)
1455 class_desc->func_cnt++;
1456 }
1457
1458 class_desc->funcs = compiler_alloc(ctx->code, class_desc->func_cnt*sizeof(*class_desc->funcs));
1459 if(!class_desc->funcs)
1460 return E_OUTOFMEMORY;
1461 memset(class_desc->funcs, 0, class_desc->func_cnt*sizeof(*class_desc->funcs));
1462
1463 for(func_decl = class_decl->funcs, i=1; func_decl; func_decl = func_decl->next, i++) {
1464 for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
1465 if(func_prop_decl->type == FUNC_DEFGET) {
1466 i--;
1467 break;
1468 }
1469 }
1470
1471 if(!strcmpiW(class_initializeW, func_decl->name)) {
1472 if(func_decl->type != FUNC_SUB) {
1473 FIXME("class initializer is not sub\n");
1474 return E_FAIL;
1475 }
1476
1477 class_desc->class_initialize_id = i;
1478 }else if(!strcmpiW(class_terminateW, func_decl->name)) {
1479 if(func_decl->type != FUNC_SUB) {
1480 FIXME("class terminator is not sub\n");
1481 return E_FAIL;
1482 }
1483
1484 class_desc->class_terminate_id = i;
1485 }
1486
1487 hres = create_class_funcprop(ctx, func_decl, class_desc->funcs + (func_prop_decl ? 0 : i));
1488 if(FAILED(hres))
1489 return hres;
1490 }
1491
1492 for(prop_decl = class_decl->props; prop_decl; prop_decl = prop_decl->next)
1493 class_desc->prop_cnt++;
1494
1495 class_desc->props = compiler_alloc(ctx->code, class_desc->prop_cnt*sizeof(*class_desc->props));
1496 if(!class_desc->props)
1497 return E_OUTOFMEMORY;
1498
1499 for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next, i++) {
1500 if(lookup_class_funcs(class_desc, prop_decl->name)) {
1501 FIXME("Property %s redefined\n", debugstr_w(prop_decl->name));
1502 return E_FAIL;
1503 }
1504
1505 class_desc->props[i].name = compiler_alloc_string(ctx->code, prop_decl->name);
1506 if(!class_desc->props[i].name)
1507 return E_OUTOFMEMORY;
1508
1509 class_desc->props[i].is_public = prop_decl->is_public;
1510 }
1511
1512 class_desc->next = ctx->classes;
1513 ctx->classes = class_desc;
1514 return S_OK;
1515 }
1516
1517 static BOOL lookup_script_identifier(script_ctx_t *script, const WCHAR *identifier)
1518 {
1519 class_desc_t *class;
1520 dynamic_var_t *var;
1521 function_t *func;
1522
1523 for(var = script->global_vars; var; var = var->next) {
1524 if(!strcmpiW(var->name, identifier))
1525 return TRUE;
1526 }
1527
1528 for(func = script->global_funcs; func; func = func->next) {
1529 if(!strcmpiW(func->name, identifier))
1530 return TRUE;
1531 }
1532
1533 for(class = script->classes; class; class = class->next) {
1534 if(!strcmpiW(class->name, identifier))
1535 return TRUE;
1536 }
1537
1538 return FALSE;
1539 }
1540
1541 static HRESULT check_script_collisions(compile_ctx_t *ctx, script_ctx_t *script)
1542 {
1543 class_desc_t *class;
1544 dynamic_var_t *var;
1545 function_t *func;
1546
1547 for(var = ctx->global_vars; var; var = var->next) {
1548 if(lookup_script_identifier(script, var->name)) {
1549 FIXME("%s: redefined\n", debugstr_w(var->name));
1550 return E_FAIL;
1551 }
1552 }
1553
1554 for(func = ctx->funcs; func; func = func->next) {
1555 if(lookup_script_identifier(script, func->name)) {
1556 FIXME("%s: redefined\n", debugstr_w(func->name));
1557 return E_FAIL;
1558 }
1559 }
1560
1561 for(class = ctx->classes; class; class = class->next) {
1562 if(lookup_script_identifier(script, class->name)) {
1563 FIXME("%s: redefined\n", debugstr_w(class->name));
1564 return E_FAIL;
1565 }
1566 }
1567
1568 return S_OK;
1569 }
1570
1571 void release_vbscode(vbscode_t *code)
1572 {
1573 unsigned i;
1574
1575 list_remove(&code->entry);
1576
1577 for(i=0; i < code->bstr_cnt; i++)
1578 SysFreeString(code->bstr_pool[i]);
1579
1580 vbsheap_free(&code->heap);
1581
1582 heap_free(code->bstr_pool);
1583 heap_free(code->source);
1584 heap_free(code->instrs);
1585 heap_free(code);
1586 }
1587
1588 static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source)
1589 {
1590 vbscode_t *ret;
1591
1592 ret = heap_alloc(sizeof(*ret));
1593 if(!ret)
1594 return NULL;
1595
1596 ret->source = heap_strdupW(source);
1597 if(!ret->source) {
1598 heap_free(ret);
1599 return NULL;
1600 }
1601
1602 ret->instrs = heap_alloc(32*sizeof(instr_t));
1603 if(!ret->instrs) {
1604 release_vbscode(ret);
1605 return NULL;
1606 }
1607
1608 ctx->instr_cnt = 1;
1609 ctx->instr_size = 32;
1610 vbsheap_init(&ret->heap);
1611
1612 ret->option_explicit = ctx->parser.option_explicit;
1613
1614 ret->bstr_pool = NULL;
1615 ret->bstr_pool_size = 0;
1616 ret->bstr_cnt = 0;
1617 ret->global_executed = FALSE;
1618
1619 ret->global_code.type = FUNC_GLOBAL;
1620 ret->global_code.name = NULL;
1621 ret->global_code.code_ctx = ret;
1622 ret->global_code.vars = NULL;
1623 ret->global_code.var_cnt = 0;
1624 ret->global_code.arg_cnt = 0;
1625 ret->global_code.args = NULL;
1626
1627 list_init(&ret->entry);
1628 return ret;
1629 }
1630
1631 static void release_compiler(compile_ctx_t *ctx)
1632 {
1633 parser_release(&ctx->parser);
1634 heap_free(ctx->labels);
1635 if(ctx->code)
1636 release_vbscode(ctx->code);
1637 }
1638
1639 HRESULT compile_script(script_ctx_t *script, const WCHAR *src, vbscode_t **ret)
1640 {
1641 function_t *new_func;
1642 function_decl_t *func_decl;
1643 class_decl_t *class_decl;
1644 compile_ctx_t ctx;
1645 vbscode_t *code;
1646 HRESULT hres;
1647
1648 hres = parse_script(&ctx.parser, src);
1649 if(FAILED(hres))
1650 return hres;
1651
1652 code = ctx.code = alloc_vbscode(&ctx, src);
1653 if(!ctx.code)
1654 return E_OUTOFMEMORY;
1655
1656 ctx.funcs = NULL;
1657 ctx.func_decls = NULL;
1658 ctx.global_vars = NULL;
1659 ctx.dim_decls = NULL;
1660 ctx.classes = NULL;
1661 ctx.labels = NULL;
1662 ctx.global_consts = NULL;
1663 ctx.stat_ctx = NULL;
1664 ctx.labels_cnt = ctx.labels_size = 0;
1665
1666 hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->global_code);
1667 if(FAILED(hres)) {
1668 release_compiler(&ctx);
1669 return hres;
1670 }
1671
1672 ctx.global_consts = ctx.const_decls;
1673
1674 for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
1675 hres = create_function(&ctx, func_decl, &new_func);
1676 if(FAILED(hres)) {
1677 release_compiler(&ctx);
1678 return hres;
1679 }
1680
1681 new_func->next = ctx.funcs;
1682 ctx.funcs = new_func;
1683 }
1684
1685 for(class_decl = ctx.parser.class_decls; class_decl; class_decl = class_decl->next) {
1686 hres = compile_class(&ctx, class_decl);
1687 if(FAILED(hres)) {
1688 release_compiler(&ctx);
1689 return hres;
1690 }
1691 }
1692
1693 hres = check_script_collisions(&ctx, script);
1694 if(FAILED(hres)) {
1695 release_compiler(&ctx);
1696 return hres;
1697 }
1698
1699 if(ctx.global_vars) {
1700 dynamic_var_t *var;
1701
1702 for(var = ctx.global_vars; var->next; var = var->next);
1703
1704 var->next = script->global_vars;
1705 script->global_vars = ctx.global_vars;
1706 }
1707
1708 if(ctx.funcs) {
1709 for(new_func = ctx.funcs; new_func->next; new_func = new_func->next);
1710
1711 new_func->next = script->global_funcs;
1712 script->global_funcs = ctx.funcs;
1713 }
1714
1715 if(ctx.classes) {
1716 class_desc_t *class = ctx.classes;
1717
1718 while(1) {
1719 class->ctx = script;
1720 if(!class->next)
1721 break;
1722 class = class->next;
1723 }
1724
1725 class->next = script->classes;
1726 script->classes = ctx.classes;
1727 }
1728
1729 if(TRACE_ON(vbscript_disas))
1730 dump_code(&ctx);
1731
1732 ctx.code = NULL;
1733 release_compiler(&ctx);
1734
1735 list_add_tail(&script->code_list, &code->entry);
1736 *ret = code;
1737 return S_OK;
1738 }
Maarten's multimedia branch