git.oblomov.eu Git - wine/blob - dlls/vbscript/compile.c

   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 {
  31     parser_ctx_t parser;
  32
  33     unsigned instr_cnt;
  34     unsigned instr_size;
  35     vbscode_t *code;
  36
  37     unsigned *labels;
  38     unsigned labels_size;
  39     unsigned labels_cnt;
  40
  41     unsigned while_end_label;
  42     unsigned sub_end_label;
  43     unsigned func_end_label;
  44     unsigned prop_end_label;
  45
  46     dim_decl_t *dim_decls;
  47     dynamic_var_t *global_vars;
  48
  49     function_t *func;
  50     function_t *funcs;
  51     function_decl_t *func_decls;
  52
  53     class_desc_t *classes;
  54 } compile_ctx_t;
  55
  56 static HRESULT compile_expression(compile_ctx_t*,expression_t*);
  57 static HRESULT compile_statement(compile_ctx_t*,statement_t*);
  58
  59 static const struct {
  60     const char *op_str;
  61     instr_arg_type_t arg1_type;
  62     instr_arg_type_t arg2_type;
  63 } instr_info[] = {
  64 #define X(n,a,b,c) {#n,b,c},
  65 OP_LIST
  66 #undef X
  67 };
  68
  69 static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg)
  70 {
  71     switch(type) {
  72     case ARG_STR:
  73     case ARG_BSTR:
  74         TRACE_(vbscript_disas)("\t%s", debugstr_w(arg->str));
  75         break;
  76     case ARG_INT:
  77         TRACE_(vbscript_disas)("\t%d", arg->uint);
  78         break;
  79     case ARG_UINT:
  80     case ARG_ADDR:
  81         TRACE_(vbscript_disas)("\t%u", arg->uint);
  82         break;
  83     case ARG_DOUBLE:
  84         TRACE_(vbscript_disas)("\t%lf", *arg->dbl);
  85         break;
  86     case ARG_NONE:
  87         break;
  88     default:
  89         assert(0);
  90     }
  91 }
  92
  93 static void dump_code(compile_ctx_t *ctx)
  94 {
  95     instr_t *instr;
  96
  97     for(instr = ctx->code->instrs; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
  98         TRACE_(vbscript_disas)("%d:\t%s", instr-ctx->code->instrs, instr_info[instr->op].op_str);
  99         dump_instr_arg(instr_info[instr->op].arg1_type, &instr->arg1);
 100         dump_instr_arg(instr_info[instr->op].arg2_type, &instr->arg2);
 101         TRACE_(vbscript_disas)("\n");
 102     }
 103 }
 104
 105 static inline void *compiler_alloc(vbscode_t *vbscode, size_t size)
 106 {
 107     return vbsheap_alloc(&vbscode->heap, size);
 108 }
 109
 110 static WCHAR *compiler_alloc_string(vbscode_t *vbscode, const WCHAR *str)
 111 {
 112     size_t size;
 113     WCHAR *ret;
 114
 115     size = (strlenW(str)+1)*sizeof(WCHAR);
 116     ret = compiler_alloc(vbscode, size);
 117     if(ret)
 118         memcpy(ret, str, size);
 119     return ret;
 120 }
 121
 122 static inline instr_t *instr_ptr(compile_ctx_t *ctx, unsigned id)
 123 {
 124     assert(id < ctx->instr_cnt);
 125     return ctx->code->instrs + id;
 126 }
 127
 128 static unsigned push_instr(compile_ctx_t *ctx, vbsop_t op)
 129 {
 130     assert(ctx->instr_size && ctx->instr_size >= ctx->instr_cnt);
 131
 132     if(ctx->instr_size == ctx->instr_cnt) {
 133         instr_t *new_instr;
 134
 135         new_instr = heap_realloc(ctx->code->instrs, ctx->instr_size*2*sizeof(instr_t));
 136         if(!new_instr)
 137             return -1;
 138
 139         ctx->code->instrs = new_instr;
 140         ctx->instr_size *= 2;
 141     }
 142
 143     ctx->code->instrs[ctx->instr_cnt].op = op;
 144     return ctx->instr_cnt++;
 145 }
 146
 147 static HRESULT push_instr_int(compile_ctx_t *ctx, vbsop_t op, LONG arg)
 148 {
 149     unsigned ret;
 150
 151     ret = push_instr(ctx, op);
 152     if(ret == -1)
 153         return E_OUTOFMEMORY;
 154
 155     instr_ptr(ctx, ret)->arg1.lng = arg;
 156     return S_OK;
 157 }
 158
 159 static HRESULT push_instr_addr(compile_ctx_t *ctx, vbsop_t op, unsigned arg)
 160 {
 161     unsigned ret;
 162
 163     ret = push_instr(ctx, op);
 164     if(ret == -1)
 165         return E_OUTOFMEMORY;
 166
 167     instr_ptr(ctx, ret)->arg1.uint = arg;
 168     return S_OK;
 169 }
 170
 171 static HRESULT push_instr_str(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg)
 172 {
 173     unsigned instr;
 174     WCHAR *str;
 175
 176     str = compiler_alloc_string(ctx->code, arg);
 177     if(!str)
 178         return E_OUTOFMEMORY;
 179
 180     instr = push_instr(ctx, op);
 181     if(instr == -1)
 182         return E_OUTOFMEMORY;
 183
 184     instr_ptr(ctx, instr)->arg1.str = str;
 185     return S_OK;
 186 }
 187
 188 static HRESULT push_instr_double(compile_ctx_t *ctx, vbsop_t op, double arg)
 189 {
 190     unsigned instr;
 191     double *d;
 192
 193     d = compiler_alloc(ctx->code, sizeof(double));
 194     if(!d)
 195         return E_OUTOFMEMORY;
 196
 197     instr = push_instr(ctx, op);
 198     if(instr == -1)
 199         return E_OUTOFMEMORY;
 200
 201     *d = arg;
 202     instr_ptr(ctx, instr)->arg1.dbl = d;
 203     return S_OK;
 204 }
 205
 206 static BSTR alloc_bstr_arg(compile_ctx_t *ctx, const WCHAR *str)
 207 {
 208     if(!ctx->code->bstr_pool_size) {
 209         ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
 210         if(!ctx->code->bstr_pool)
 211             return NULL;
 212         ctx->code->bstr_pool_size = 8;
 213     }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
 214        BSTR *new_pool;
 215
 216         new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
 217         if(!new_pool)
 218             return NULL;
 219
 220         ctx->code->bstr_pool = new_pool;
 221         ctx->code->bstr_pool_size *= 2;
 222     }
 223
 224     ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
 225     if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
 226         return NULL;
 227
 228     return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
 229 }
 230
 231 static HRESULT push_instr_bstr(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg)
 232 {
 233     unsigned instr;
 234     BSTR bstr;
 235
 236     bstr = alloc_bstr_arg(ctx, arg);
 237     if(!bstr)
 238         return E_OUTOFMEMORY;
 239
 240     instr = push_instr(ctx, op);
 241     if(instr == -1)
 242         return E_OUTOFMEMORY;
 243
 244     instr_ptr(ctx, instr)->arg1.bstr = bstr;
 245     return S_OK;
 246 }
 247
 248 static HRESULT push_instr_bstr_uint(compile_ctx_t *ctx, vbsop_t op, const WCHAR *arg1, unsigned arg2)
 249 {
 250     unsigned instr;
 251     BSTR bstr;
 252
 253     bstr = alloc_bstr_arg(ctx, arg1);
 254     if(!bstr)
 255         return E_OUTOFMEMORY;
 256
 257     instr = push_instr(ctx, op);
 258     if(instr == -1)
 259         return E_OUTOFMEMORY;
 260
 261     instr_ptr(ctx, instr)->arg1.bstr = bstr;
 262     instr_ptr(ctx, instr)->arg2.uint = arg2;
 263     return S_OK;
 264 }
 265
 266 #define LABEL_FLAG 0x80000000
 267
 268 static unsigned alloc_label(compile_ctx_t *ctx)
 269 {
 270     if(!ctx->labels_size) {
 271         ctx->labels = heap_alloc(8 * sizeof(*ctx->labels));
 272         if(!ctx->labels)
 273             return -1;
 274         ctx->labels_size = 8;
 275     }else if(ctx->labels_size == ctx->labels_cnt) {
 276         unsigned *new_labels;
 277
 278         new_labels = heap_realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
 279         if(!new_labels)
 280             return -1;
 281
 282         ctx->labels = new_labels;
 283         ctx->labels_size *= 2;
 284     }
 285
 286     return ctx->labels_cnt++ | LABEL_FLAG;
 287 }
 288
 289 static inline void label_set_addr(compile_ctx_t *ctx, unsigned label)
 290 {
 291     assert(label & LABEL_FLAG);
 292     ctx->labels[label & ~LABEL_FLAG] = ctx->instr_cnt;
 293 }
 294
 295 static HRESULT compile_args(compile_ctx_t *ctx, expression_t *args, unsigned *ret)
 296 {
 297     unsigned arg_cnt = 0;
 298     HRESULT hres;
 299
 300     while(args) {
 301         hres = compile_expression(ctx, args);
 302         if(FAILED(hres))
 303             return hres;
 304
 305         arg_cnt++;
 306         args = args->next;
 307     }
 308
 309     *ret = arg_cnt;
 310     return S_OK;
 311 }
 312
 313 static HRESULT compile_member_expression(compile_ctx_t *ctx, member_expression_t *expr, BOOL ret_val)
 314 {
 315     unsigned arg_cnt = 0;
 316     HRESULT hres;
 317
 318     hres = compile_args(ctx, expr->args, &arg_cnt);
 319     if(FAILED(hres))
 320         return hres;
 321
 322     if(expr->obj_expr) {
 323         hres = compile_expression(ctx, expr->obj_expr);
 324         if(FAILED(hres))
 325             return hres;
 326
 327         hres = push_instr_bstr_uint(ctx, ret_val ? OP_mcall : OP_mcallv, expr->identifier, arg_cnt);
 328     }else {
 329         hres = push_instr_bstr_uint(ctx, ret_val ? OP_icall : OP_icallv, expr->identifier, arg_cnt);
 330     }
 331
 332     return hres;
 333 }
 334
 335 static HRESULT compile_unary_expression(compile_ctx_t *ctx, unary_expression_t *expr, vbsop_t op)
 336 {
 337     HRESULT hres;
 338
 339     hres = compile_expression(ctx, expr->subexpr);
 340     if(FAILED(hres))
 341         return hres;
 342
 343     return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
 344 }
 345
 346 static HRESULT compile_binary_expression(compile_ctx_t *ctx, binary_expression_t *expr, vbsop_t op)
 347 {
 348     HRESULT hres;
 349
 350     hres = compile_expression(ctx, expr->left);
 351     if(FAILED(hres))
 352         return hres;
 353
 354     hres = compile_expression(ctx, expr->right);
 355     if(FAILED(hres))
 356         return hres;
 357
 358     return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
 359 }
 360
 361 static HRESULT compile_expression(compile_ctx_t *ctx, expression_t *expr)
 362 {
 363     switch(expr->type) {
 364     case EXPR_ADD:
 365         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
 366     case EXPR_AND:
 367         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
 368     case EXPR_BOOL:
 369         return push_instr_int(ctx, OP_bool, ((bool_expression_t*)expr)->value);
 370     case EXPR_CONCAT:
 371         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_concat);
 372     case EXPR_DIV:
 373         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
 374     case EXPR_DOUBLE:
 375         return push_instr_double(ctx, OP_double, ((double_expression_t*)expr)->value);
 376     case EXPR_EMPTY:
 377         return push_instr(ctx, OP_empty) != -1 ? S_OK : E_OUTOFMEMORY;
 378     case EXPR_EQUAL:
 379         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_equal);
 380     case EXPR_EQV:
 381         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eqv);
 382     case EXPR_EXP:
 383         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_exp);
 384     case EXPR_IDIV:
 385         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_idiv);
 386     case EXPR_IMP:
 387         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_imp);
 388     case EXPR_MEMBER:
 389         return compile_member_expression(ctx, (member_expression_t*)expr, TRUE);
 390     case EXPR_MOD:
 391         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
 392     case EXPR_MUL:
 393         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
 394     case EXPR_NEG:
 395         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
 396     case EXPR_NEQUAL:
 397         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_nequal);
 398     case EXPR_NEW:
 399         return push_instr_str(ctx, OP_new, ((string_expression_t*)expr)->value);
 400     case EXPR_NOT:
 401         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_not);
 402     case EXPR_NOTHING:
 403         return push_instr(ctx, OP_nothing) != -1 ? S_OK : E_OUTOFMEMORY;
 404     case EXPR_NULL:
 405         return push_instr(ctx, OP_null) != -1 ? S_OK : E_OUTOFMEMORY;
 406     case EXPR_OR:
 407         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
 408     case EXPR_STRING:
 409         return push_instr_str(ctx, OP_string, ((string_expression_t*)expr)->value);
 410     case EXPR_SUB:
 411         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
 412     case EXPR_USHORT:
 413         return push_instr_int(ctx, OP_short, ((int_expression_t*)expr)->value);
 414     case EXPR_ULONG:
 415         return push_instr_int(ctx, OP_long, ((int_expression_t*)expr)->value);
 416     case EXPR_XOR:
 417         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
 418     default:
 419         FIXME("Unimplemented expression type %d\n", expr->type);
 420         return E_NOTIMPL;
 421     }
 422
 423     return S_OK;
 424 }
 425
 426 static HRESULT compile_if_statement(compile_ctx_t *ctx, if_statement_t *stat)
 427 {
 428     unsigned cnd_jmp, endif_label = -1;
 429     elseif_decl_t *elseif_decl;
 430     HRESULT hres;
 431
 432     hres = compile_expression(ctx, stat->expr);
 433     if(FAILED(hres))
 434         return hres;
 435
 436     cnd_jmp = push_instr(ctx, OP_jmp_false);
 437     if(cnd_jmp == -1)
 438         return E_OUTOFMEMORY;
 439
 440     hres = compile_statement(ctx, stat->if_stat);
 441     if(FAILED(hres))
 442         return hres;
 443
 444     if(stat->else_stat || stat->elseifs) {
 445         endif_label = alloc_label(ctx);
 446         if(endif_label == -1)
 447             return E_OUTOFMEMORY;
 448
 449         hres = push_instr_addr(ctx, OP_jmp, endif_label);
 450         if(FAILED(hres))
 451             return hres;
 452     }
 453
 454     for(elseif_decl = stat->elseifs; elseif_decl; elseif_decl = elseif_decl->next) {
 455         instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
 456
 457         hres = compile_expression(ctx, elseif_decl->expr);
 458         if(FAILED(hres))
 459             return hres;
 460
 461         cnd_jmp = push_instr(ctx, OP_jmp_false);
 462         if(cnd_jmp == -1)
 463             return E_OUTOFMEMORY;
 464
 465         hres = compile_statement(ctx, elseif_decl->stat);
 466         if(FAILED(hres))
 467             return hres;
 468
 469         hres = push_instr_addr(ctx, OP_jmp, endif_label);
 470         if(FAILED(hres))
 471             return hres;
 472     }
 473
 474     instr_ptr(ctx, cnd_jmp)->arg1.uint = ctx->instr_cnt;
 475
 476     if(stat->else_stat) {
 477         hres = compile_statement(ctx, stat->else_stat);
 478         if(FAILED(hres))
 479             return hres;
 480     }
 481
 482     if(endif_label != -1)
 483         label_set_addr(ctx, endif_label);
 484     return S_OK;
 485 }
 486
 487 static HRESULT compile_while_statement(compile_ctx_t *ctx, while_statement_t *stat)
 488 {
 489     unsigned start_addr, prev_label;
 490     unsigned jmp_end;
 491     HRESULT hres;
 492
 493     start_addr = ctx->instr_cnt;
 494
 495     hres = compile_expression(ctx, stat->expr);
 496     if(FAILED(hres))
 497         return hres;
 498
 499     jmp_end = push_instr(ctx, stat->stat.type == STAT_UNTIL ? OP_jmp_true : OP_jmp_false);
 500     if(jmp_end == -1)
 501         return E_OUTOFMEMORY;
 502
 503     if(stat->stat.type != STAT_WHILE) {
 504         prev_label = ctx->while_end_label;
 505         if((ctx->while_end_label = alloc_label(ctx)) == -1)
 506             return E_OUTOFMEMORY;
 507     }
 508
 509     hres = compile_statement(ctx, stat->body);
 510     if(FAILED(hres))
 511         return hres;
 512
 513     hres = push_instr_addr(ctx, OP_jmp, start_addr);
 514     if(FAILED(hres))
 515         return hres;
 516
 517     instr_ptr(ctx, jmp_end)->arg1.uint = ctx->instr_cnt;
 518
 519     if(stat->stat.type != STAT_WHILE) {
 520         label_set_addr(ctx, ctx->while_end_label);
 521         ctx->while_end_label = prev_label;
 522     }
 523
 524     return S_OK;
 525 }
 526
 527 static HRESULT compile_assign_statement(compile_ctx_t *ctx, assign_statement_t *stat, BOOL is_set)
 528 {
 529     HRESULT hres;
 530
 531     hres = compile_expression(ctx, stat->value_expr);
 532     if(FAILED(hres))
 533         return hres;
 534
 535     if(stat->member_expr->args) {
 536         FIXME("arguments support not implemented\n");
 537         return E_NOTIMPL;
 538     }
 539
 540     if(stat->member_expr->obj_expr) {
 541         hres = compile_expression(ctx, stat->member_expr->obj_expr);
 542         if(FAILED(hres))
 543             return hres;
 544
 545         hres = push_instr_bstr(ctx, is_set ? OP_set_member : OP_assign_member, stat->member_expr->identifier);
 546     }else {
 547         hres = push_instr_bstr(ctx, is_set ? OP_set_ident : OP_assign_ident, stat->member_expr->identifier);
 548     }
 549
 550     return hres;
 551 }
 552
 553 static BOOL lookup_dim_decls(compile_ctx_t *ctx, const WCHAR *name)
 554 {
 555     dim_decl_t *dim_decl;
 556
 557     for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
 558         if(!strcmpiW(dim_decl->name, name))
 559             return TRUE;
 560     }
 561
 562     return FALSE;
 563 }
 564
 565 static BOOL lookup_args_name(compile_ctx_t *ctx, const WCHAR *name)
 566 {
 567     unsigned i;
 568
 569     for(i = 0; i < ctx->func->arg_cnt; i++) {
 570         if(!strcmpiW(ctx->func->args[i].name, name))
 571             return TRUE;
 572     }
 573
 574     return FALSE;
 575 }
 576
 577 static HRESULT compile_dim_statement(compile_ctx_t *ctx, dim_statement_t *stat)
 578 {
 579     dim_decl_t *dim_decl = stat->dim_decls;
 580
 581     while(1) {
 582         if(lookup_dim_decls(ctx, dim_decl->name) || lookup_args_name(ctx, dim_decl->name)) {
 583             FIXME("dim %s name redefined\n", debugstr_w(dim_decl->name));
 584             return E_FAIL;
 585         }
 586
 587         if(!dim_decl->next)
 588             break;
 589         dim_decl = dim_decl->next;
 590     }
 591
 592     dim_decl->next = ctx->dim_decls;
 593     ctx->dim_decls = stat->dim_decls;
 594     ctx->func->var_cnt++;
 595     return S_OK;
 596 }
 597
 598 static HRESULT compile_function_statement(compile_ctx_t *ctx, function_statement_t *stat)
 599 {
 600     if(ctx->func != &ctx->code->global_code) {
 601         FIXME("Function is not in the global code\n");
 602         return E_FAIL;
 603     }
 604
 605     stat->func_decl->next = ctx->func_decls;
 606     ctx->func_decls = stat->func_decl;
 607     return S_OK;
 608 }
 609
 610 static HRESULT compile_exitdo_statement(compile_ctx_t *ctx)
 611 {
 612     if(ctx->while_end_label == -1) {
 613         FIXME("Exit Do outside Do Loop\n");
 614         return E_FAIL;
 615     }
 616
 617     return push_instr_addr(ctx, OP_jmp, ctx->while_end_label);
 618 }
 619
 620 static HRESULT compile_exitsub_statement(compile_ctx_t *ctx)
 621 {
 622     if(ctx->sub_end_label == -1) {
 623         FIXME("Exit Sub outside Sub?\n");
 624         return E_FAIL;
 625     }
 626
 627     return push_instr_addr(ctx, OP_jmp, ctx->sub_end_label);
 628 }
 629
 630 static HRESULT compile_exitfunc_statement(compile_ctx_t *ctx)
 631 {
 632     if(ctx->func_end_label == -1) {
 633         FIXME("Exit Function outside Function?\n");
 634         return E_FAIL;
 635     }
 636
 637     return push_instr_addr(ctx, OP_jmp, ctx->func_end_label);
 638 }
 639
 640 static HRESULT compile_exitprop_statement(compile_ctx_t *ctx)
 641 {
 642     if(ctx->prop_end_label == -1) {
 643         FIXME("Exit Property outside Property?\n");
 644         return E_FAIL;
 645     }
 646
 647     return push_instr_addr(ctx, OP_jmp, ctx->prop_end_label);
 648 }
 649
 650 static HRESULT compile_statement(compile_ctx_t *ctx, statement_t *stat)
 651 {
 652     HRESULT hres;
 653
 654     while(stat) {
 655         switch(stat->type) {
 656         case STAT_ASSIGN:
 657             hres = compile_assign_statement(ctx, (assign_statement_t*)stat, FALSE);
 658             break;
 659         case STAT_CALL:
 660             hres = compile_member_expression(ctx, ((call_statement_t*)stat)->expr, FALSE);
 661             break;
 662         case STAT_DIM:
 663             hres = compile_dim_statement(ctx, (dim_statement_t*)stat);
 664             break;
 665         case STAT_EXITDO:
 666             hres = compile_exitdo_statement(ctx);
 667             break;
 668         case STAT_EXITFUNC:
 669             hres = compile_exitfunc_statement(ctx);
 670             break;
 671         case STAT_EXITPROP:
 672             hres = compile_exitprop_statement(ctx);
 673             break;
 674         case STAT_EXITSUB:
 675             hres = compile_exitsub_statement(ctx);
 676             break;
 677         case STAT_FUNC:
 678             hres = compile_function_statement(ctx, (function_statement_t*)stat);
 679             break;
 680         case STAT_IF:
 681             hres = compile_if_statement(ctx, (if_statement_t*)stat);
 682             break;
 683         case STAT_SET:
 684             hres = compile_assign_statement(ctx, (assign_statement_t*)stat, TRUE);
 685             break;
 686         case STAT_STOP:
 687             hres = push_instr(ctx, OP_stop) == -1 ? E_OUTOFMEMORY : S_OK;
 688             break;
 689         case STAT_UNTIL:
 690         case STAT_WHILE:
 691         case STAT_WHILELOOP:
 692             hres = compile_while_statement(ctx, (while_statement_t*)stat);
 693             break;
 694         default:
 695             FIXME("Unimplemented statement type %d\n", stat->type);
 696             hres = E_NOTIMPL;
 697         }
 698
 699         if(FAILED(hres))
 700             return hres;
 701         stat = stat->next;
 702     }
 703
 704     return S_OK;
 705 }
 706
 707 static void resolve_labels(compile_ctx_t *ctx, unsigned off)
 708 {
 709     instr_t *instr;
 710
 711     for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->instr_cnt; instr++) {
 712         if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->arg1.uint & LABEL_FLAG)) {
 713             assert((instr->arg1.uint & ~LABEL_FLAG) < ctx->labels_cnt);
 714             instr->arg1.uint = ctx->labels[instr->arg1.uint & ~LABEL_FLAG];
 715         }
 716         assert(instr_info[instr->op].arg2_type != ARG_ADDR);
 717     }
 718
 719     ctx->labels_cnt = 0;
 720 }
 721
 722 static HRESULT compile_func(compile_ctx_t *ctx, statement_t *stat, function_t *func)
 723 {
 724     HRESULT hres;
 725
 726     func->code_off = ctx->instr_cnt;
 727
 728     ctx->while_end_label = -1;
 729     ctx->sub_end_label = -1;
 730     ctx->func_end_label = -1;
 731     ctx->prop_end_label = -1;
 732
 733     switch(func->type) {
 734     case FUNC_FUNCTION:
 735         ctx->func_end_label = alloc_label(ctx);
 736         if(ctx->func_end_label == -1)
 737             return E_OUTOFMEMORY; /* FIXME ! */
 738         break;
 739     case FUNC_SUB:
 740         ctx->sub_end_label = alloc_label(ctx);
 741         if(ctx->sub_end_label == -1)
 742             return E_OUTOFMEMORY;
 743         break;
 744     case FUNC_PROPGET:
 745     case FUNC_PROPLET:
 746     case FUNC_PROPSET:
 747     case FUNC_DEFGET:
 748         ctx->prop_end_label = alloc_label(ctx);
 749         if(ctx->prop_end_label == -1)
 750             return E_OUTOFMEMORY;
 751         break;
 752     case FUNC_GLOBAL:
 753         break;
 754     }
 755
 756     ctx->func = func;
 757     ctx->dim_decls = NULL;
 758     hres = compile_statement(ctx, stat);
 759     ctx->func = NULL;
 760     if(FAILED(hres))
 761         return hres;
 762
 763     assert(ctx->while_end_label == -1);
 764
 765     if(ctx->sub_end_label != -1)
 766         label_set_addr(ctx, ctx->sub_end_label);
 767     if(ctx->func_end_label != -1)
 768         label_set_addr(ctx, ctx->func_end_label);
 769     if(ctx->prop_end_label != -1)
 770         label_set_addr(ctx, ctx->prop_end_label);
 771
 772     if(push_instr(ctx, OP_ret) == -1)
 773         return E_OUTOFMEMORY;
 774
 775     resolve_labels(ctx, func->code_off);
 776
 777     if(func->var_cnt) {
 778         dim_decl_t *dim_decl;
 779
 780         if(func->type == FUNC_GLOBAL) {
 781             dynamic_var_t *new_var;
 782
 783             func->var_cnt = 0;
 784
 785             for(dim_decl = ctx->dim_decls; dim_decl; dim_decl = dim_decl->next) {
 786                 new_var = compiler_alloc(ctx->code, sizeof(*new_var));
 787                 if(!new_var)
 788                     return E_OUTOFMEMORY;
 789
 790                 new_var->name = compiler_alloc_string(ctx->code, dim_decl->name);
 791                 if(!new_var->name)
 792                     return E_OUTOFMEMORY;
 793
 794                 V_VT(&new_var->v) = VT_EMPTY;
 795
 796                 new_var->next = ctx->global_vars;
 797                 ctx->global_vars = new_var;
 798             }
 799         }else {
 800             unsigned i;
 801
 802             func->vars = compiler_alloc(ctx->code, func->var_cnt * sizeof(var_desc_t));
 803             if(!func->vars)
 804                 return E_OUTOFMEMORY;
 805
 806             for(dim_decl = ctx->dim_decls, i=0; dim_decl; dim_decl = dim_decl->next, i++) {
 807                 func->vars[i].name = compiler_alloc_string(ctx->code, dim_decl->name);
 808                 if(!func->vars[i].name)
 809                     return E_OUTOFMEMORY;
 810             }
 811
 812             assert(i == func->var_cnt);
 813         }
 814     }
 815
 816     return S_OK;
 817 }
 818
 819 static BOOL lookup_funcs_name(compile_ctx_t *ctx, const WCHAR *name)
 820 {
 821     function_t *iter;
 822
 823     for(iter = ctx->funcs; iter; iter = iter->next) {
 824         if(!strcmpiW(iter->name, name))
 825             return TRUE;
 826     }
 827
 828     return FALSE;
 829 }
 830
 831 static HRESULT create_function(compile_ctx_t *ctx, function_decl_t *decl, function_t **ret)
 832 {
 833     function_t *func;
 834     HRESULT hres;
 835
 836     if(lookup_dim_decls(ctx, decl->name) || lookup_funcs_name(ctx, decl->name)) {
 837         FIXME("%s: redefinition\n", debugstr_w(decl->name));
 838         return E_FAIL;
 839     }
 840
 841     func = compiler_alloc(ctx->code, sizeof(*func));
 842     if(!func)
 843         return E_OUTOFMEMORY;
 844
 845     func->name = compiler_alloc_string(ctx->code, decl->name);
 846     if(!func->name)
 847         return E_OUTOFMEMORY;
 848
 849     func->vars = NULL;
 850     func->var_cnt = 0;
 851     func->code_ctx = ctx->code;
 852     func->type = decl->type;
 853     func->is_public = decl->is_public;
 854
 855     func->arg_cnt = 0;
 856     if(decl->args) {
 857         arg_decl_t *arg;
 858         unsigned i;
 859
 860         for(arg = decl->args; arg; arg = arg->next)
 861             func->arg_cnt++;
 862
 863         func->args = compiler_alloc(ctx->code, func->arg_cnt * sizeof(arg_desc_t));
 864         if(!func->args)
 865             return E_OUTOFMEMORY;
 866
 867         for(i = 0, arg = decl->args; arg; arg = arg->next, i++) {
 868             func->args[i].name = compiler_alloc_string(ctx->code, arg->name);
 869             if(!func->args[i].name)
 870                 return E_OUTOFMEMORY;
 871             func->args[i].by_ref = arg->by_ref;
 872         }
 873     }else {
 874         func->args = NULL;
 875     }
 876
 877     hres = compile_func(ctx, decl->body, func);
 878     if(FAILED(hres))
 879         return hres;
 880
 881     *ret = func;
 882     return S_OK;
 883 }
 884
 885 static BOOL lookup_class_name(compile_ctx_t *ctx, const WCHAR *name)
 886 {
 887     class_desc_t *iter;
 888
 889     for(iter = ctx->classes; iter; iter = iter->next) {
 890         if(!strcmpiW(iter->name, name))
 891             return TRUE;
 892     }
 893
 894     return FALSE;
 895 }
 896
 897 static HRESULT create_class_funcprop(compile_ctx_t *ctx, function_decl_t *func_decl, vbdisp_funcprop_desc_t *desc)
 898 {
 899     vbdisp_invoke_type_t invoke_type;
 900     function_decl_t *funcprop_decl;
 901     HRESULT hres;
 902
 903     desc->name = compiler_alloc_string(ctx->code, func_decl->name);
 904     if(!desc->name)
 905         return E_OUTOFMEMORY;
 906
 907     for(funcprop_decl = func_decl; funcprop_decl; funcprop_decl = funcprop_decl->next_prop_func) {
 908         switch(funcprop_decl->type) {
 909         case FUNC_FUNCTION:
 910         case FUNC_SUB:
 911         case FUNC_PROPGET:
 912         case FUNC_DEFGET:
 913             invoke_type = VBDISP_CALLGET;
 914             break;
 915         case FUNC_PROPLET:
 916             invoke_type = VBDISP_LET;
 917             break;
 918         case FUNC_PROPSET:
 919             invoke_type = VBDISP_SET;
 920             break;
 921         default:
 922             assert(0);
 923         }
 924
 925         assert(!desc->entries[invoke_type]);
 926
 927         if(funcprop_decl->is_public)
 928             desc->is_public = TRUE;
 929
 930         hres = create_function(ctx, funcprop_decl, desc->entries+invoke_type);
 931         if(FAILED(hres))
 932             return hres;
 933     }
 934
 935     return S_OK;
 936 }
 937
 938 static BOOL lookup_class_funcs(class_desc_t *class_desc, const WCHAR *name)
 939 {
 940     unsigned i;
 941
 942     for(i=0; i < class_desc->func_cnt; i++) {
 943         if(class_desc->funcs[i].name && !strcmpiW(class_desc->funcs[i].name, name))
 944             return TRUE;
 945     }
 946
 947     return FALSE;
 948 }
 949
 950 static HRESULT compile_class(compile_ctx_t *ctx, class_decl_t *class_decl)
 951 {
 952     function_decl_t *func_decl, *func_prop_decl;
 953     class_prop_decl_t *prop_decl;
 954     class_desc_t *class_desc;
 955     unsigned i;
 956     HRESULT hres;
 957
 958     static const WCHAR class_initializeW[] = {'c','l','a','s','s','_','i','n','i','t','i','a','l','i','z','e',0};
 959     static const WCHAR class_terminateW[] = {'c','l','a','s','s','_','t','e','r','m','i','n','a','t','e',0};
 960
 961     if(lookup_dim_decls(ctx, class_decl->name) || lookup_funcs_name(ctx, class_decl->name)
 962             || lookup_class_name(ctx, class_decl->name)) {
 963         FIXME("%s: redefinition\n", debugstr_w(class_decl->name));
 964         return E_FAIL;
 965     }
 966
 967     class_desc = compiler_alloc(ctx->code, sizeof(*class_desc));
 968     if(!class_desc)
 969         return E_OUTOFMEMORY;
 970
 971     class_desc->name = compiler_alloc_string(ctx->code, class_decl->name);
 972     if(!class_desc->name)
 973         return E_OUTOFMEMORY;
 974
 975     class_desc->func_cnt = 1; /* always allocate slot for default getter */
 976     class_desc->prop_cnt = 0;
 977     class_desc->class_initialize_id = 0;
 978     class_desc->class_terminate_id = 0;
 979
 980     for(func_decl = class_decl->funcs; func_decl; func_decl = func_decl->next) {
 981         for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
 982             if(func_prop_decl->type == FUNC_DEFGET)
 983                 break;
 984         }
 985         if(!func_prop_decl)
 986             class_desc->func_cnt++;
 987     }
 988
 989     class_desc->funcs = compiler_alloc(ctx->code, class_desc->func_cnt*sizeof(*class_desc->funcs));
 990     if(!class_desc->funcs)
 991         return E_OUTOFMEMORY;
 992     memset(class_desc->funcs, 0, class_desc->func_cnt*sizeof(*class_desc->funcs));
 993
 994     for(func_decl = class_decl->funcs, i=1; func_decl; func_decl = func_decl->next, i++) {
 995         for(func_prop_decl = func_decl; func_prop_decl; func_prop_decl = func_prop_decl->next_prop_func) {
 996             if(func_prop_decl->type == FUNC_DEFGET) {
 997                 i--;
 998                 break;
 999             }
1000         }
1001
1002         if(!strcmpiW(class_initializeW, func_decl->name)) {
1003             if(func_decl->type != FUNC_SUB) {
1004                 FIXME("class initializer is not sub\n");
1005                 return E_FAIL;
1006             }
1007
1008             class_desc->class_initialize_id = i;
1009         }else  if(!strcmpiW(class_terminateW, func_decl->name)) {
1010             if(func_decl->type != FUNC_SUB) {
1011                 FIXME("class terminator is not sub\n");
1012                 return E_FAIL;
1013             }
1014
1015             class_desc->class_terminate_id = i;
1016         }
1017
1018         hres = create_class_funcprop(ctx, func_decl, class_desc->funcs + (func_prop_decl ? 0 : i));
1019         if(FAILED(hres))
1020             return hres;
1021     }
1022
1023     for(prop_decl = class_decl->props; prop_decl; prop_decl = prop_decl->next)
1024         class_desc->prop_cnt++;
1025
1026     class_desc->props = compiler_alloc(ctx->code, class_desc->prop_cnt*sizeof(*class_desc->props));
1027     if(!class_desc->props)
1028         return E_OUTOFMEMORY;
1029
1030     for(prop_decl = class_decl->props, i=0; prop_decl; prop_decl = prop_decl->next, i++) {
1031         if(lookup_class_funcs(class_desc, prop_decl->name)) {
1032             FIXME("Property %s redefined\n", debugstr_w(prop_decl->name));
1033             return E_FAIL;
1034         }
1035
1036         class_desc->props[i].name = compiler_alloc_string(ctx->code, prop_decl->name);
1037         if(!class_desc->props[i].name)
1038             return E_OUTOFMEMORY;
1039
1040         class_desc->props[i].is_public = prop_decl->is_public;
1041     }
1042
1043     class_desc->next = ctx->classes;
1044     ctx->classes = class_desc;
1045     return S_OK;
1046 }
1047
1048 static BOOL lookup_script_identifier(script_ctx_t *script, const WCHAR *identifier)
1049 {
1050     class_desc_t *class;
1051     dynamic_var_t *var;
1052     function_t *func;
1053
1054     for(var = script->global_vars; var; var = var->next) {
1055         if(!strcmpiW(var->name, identifier))
1056             return TRUE;
1057     }
1058
1059     for(func = script->global_funcs; func; func = func->next) {
1060         if(!strcmpiW(func->name, identifier))
1061             return TRUE;
1062     }
1063
1064     for(class = script->classes; class; class = class->next) {
1065         if(!strcmpiW(class->name, identifier))
1066             return TRUE;
1067     }
1068
1069     return FALSE;
1070 }
1071
1072 static HRESULT check_script_collisions(compile_ctx_t *ctx, script_ctx_t *script)
1073 {
1074     class_desc_t *class;
1075     dynamic_var_t *var;
1076     function_t *func;
1077
1078     for(var = ctx->global_vars; var; var = var->next) {
1079         if(lookup_script_identifier(script, var->name)) {
1080             FIXME("%s: redefined\n", debugstr_w(var->name));
1081             return E_FAIL;
1082         }
1083     }
1084
1085     for(func = ctx->funcs; func; func = func->next) {
1086         if(lookup_script_identifier(script, func->name)) {
1087             FIXME("%s: redefined\n", debugstr_w(func->name));
1088             return E_FAIL;
1089         }
1090     }
1091
1092     for(class = ctx->classes; class; class = class->next) {
1093         if(lookup_script_identifier(script, class->name)) {
1094             FIXME("%s: redefined\n", debugstr_w(class->name));
1095             return E_FAIL;
1096         }
1097     }
1098
1099     return S_OK;
1100 }
1101
1102 void release_vbscode(vbscode_t *code)
1103 {
1104     unsigned i;
1105
1106     list_remove(&code->entry);
1107
1108     for(i=0; i < code->bstr_cnt; i++)
1109         SysFreeString(code->bstr_pool[i]);
1110
1111     vbsheap_free(&code->heap);
1112
1113     heap_free(code->bstr_pool);
1114     heap_free(code->source);
1115     heap_free(code->instrs);
1116     heap_free(code);
1117 }
1118
1119 static vbscode_t *alloc_vbscode(compile_ctx_t *ctx, const WCHAR *source)
1120 {
1121     vbscode_t *ret;
1122
1123     ret = heap_alloc(sizeof(*ret));
1124     if(!ret)
1125         return NULL;
1126
1127     ret->source = heap_strdupW(source);
1128     if(!ret->source) {
1129         heap_free(ret);
1130         return NULL;
1131     }
1132
1133     ret->instrs = heap_alloc(32*sizeof(instr_t));
1134     if(!ret->instrs) {
1135         release_vbscode(ret);
1136         return NULL;
1137     }
1138
1139     ctx->instr_cnt = 0;
1140     ctx->instr_size = 32;
1141     vbsheap_init(&ret->heap);
1142
1143     ret->option_explicit = ctx->parser.option_explicit;
1144
1145     ret->bstr_pool = NULL;
1146     ret->bstr_pool_size = 0;
1147     ret->bstr_cnt = 0;
1148     ret->global_executed = FALSE;
1149
1150     ret->global_code.type = FUNC_GLOBAL;
1151     ret->global_code.name = NULL;
1152     ret->global_code.code_ctx = ret;
1153     ret->global_code.vars = NULL;
1154     ret->global_code.var_cnt = 0;
1155     ret->global_code.arg_cnt = 0;
1156     ret->global_code.args = NULL;
1157
1158     list_init(&ret->entry);
1159     return ret;
1160 }
1161
1162 static void release_compiler(compile_ctx_t *ctx)
1163 {
1164     parser_release(&ctx->parser);
1165     heap_free(ctx->labels);
1166     if(ctx->code)
1167         release_vbscode(ctx->code);
1168 }
1169
1170 HRESULT compile_script(script_ctx_t *script, const WCHAR *src, vbscode_t **ret)
1171 {
1172     function_t *new_func;
1173     function_decl_t *func_decl;
1174     class_decl_t *class_decl;
1175     compile_ctx_t ctx;
1176     vbscode_t *code;
1177     HRESULT hres;
1178
1179     hres = parse_script(&ctx.parser, src);
1180     if(FAILED(hres))
1181         return hres;
1182
1183     code = ctx.code = alloc_vbscode(&ctx, src);
1184     if(!ctx.code)
1185         return E_OUTOFMEMORY;
1186
1187     ctx.funcs = NULL;
1188     ctx.func_decls = NULL;
1189     ctx.global_vars = NULL;
1190     ctx.dim_decls = NULL;
1191     ctx.classes = NULL;
1192     ctx.labels = NULL;
1193     ctx.labels_cnt = ctx.labels_size = 0;
1194
1195     hres = compile_func(&ctx, ctx.parser.stats, &ctx.code->global_code);
1196     if(FAILED(hres)) {
1197         release_compiler(&ctx);
1198         return hres;
1199     }
1200
1201     for(func_decl = ctx.func_decls; func_decl; func_decl = func_decl->next) {
1202         hres = create_function(&ctx, func_decl, &new_func);
1203         if(FAILED(hres)) {
1204             release_compiler(&ctx);
1205             return hres;
1206         }
1207
1208         new_func->next = ctx.funcs;
1209         ctx.funcs = new_func;
1210     }
1211
1212     for(class_decl = ctx.parser.class_decls; class_decl; class_decl = class_decl->next) {
1213         hres = compile_class(&ctx, class_decl);
1214         if(FAILED(hres)) {
1215             release_compiler(&ctx);
1216             return hres;
1217         }
1218     }
1219
1220     hres = check_script_collisions(&ctx, script);
1221     if(FAILED(hres)) {
1222         release_compiler(&ctx);
1223         return hres;
1224     }
1225
1226     if(ctx.global_vars) {
1227         dynamic_var_t *var;
1228
1229         for(var = ctx.global_vars; var->next; var = var->next);
1230
1231         var->next = script->global_vars;
1232         script->global_vars = ctx.global_vars;
1233     }
1234
1235     if(ctx.funcs) {
1236         for(new_func = ctx.funcs; new_func->next; new_func = new_func->next);
1237
1238         new_func->next = script->global_funcs;
1239         script->global_funcs = ctx.funcs;
1240     }
1241
1242     if(ctx.classes) {
1243         class_desc_t *class = ctx.classes;
1244
1245         while(1) {
1246             class->ctx = script;
1247             if(!class->next)
1248                 break;
1249             class = class->next;
1250         }
1251
1252         class->next = script->classes;
1253         script->classes = ctx.classes;
1254     }
1255
1256     if(TRACE_ON(vbscript_disas))
1257         dump_code(&ctx);
1258
1259     ctx.code = NULL;
1260     release_compiler(&ctx);
1261
1262     list_add_tail(&script->code_list, &code->entry);
1263     *ret = code;
1264     return S_OK;
1265 }