dlls/jscript/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 <math.h>
  20 #include <assert.h>
  21
  22 #include "jscript.h"
  23 #include "engine.h"
  24 #include "parser.h"
  25
  26 #include "wine/rbtree.h"
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  30 WINE_DECLARE_DEBUG_CHANNEL(jscript_disas);
  31
  32 typedef struct _statement_ctx_t {
  33     unsigned stack_use;
  34     BOOL using_scope;
  35     BOOL using_except;
  36
  37     unsigned break_label;
  38     unsigned continue_label;
  39
  40     const labelled_statement_t *labelled_stat;
  41
  42     unsigned int scope_index;
  43     BOOL block_scope;
  44     BOOL scope_has_functions;
  45     struct _statement_ctx_t *next;
  46 } statement_ctx_t;
  47
  48 typedef struct {
  49     struct wine_rb_entry entry;
  50     BSTR name;
  51     int ref;
  52 } function_local_t;
  53
  54 typedef struct _compiler_ctx_t {
  55     parser_ctx_t *parser;
  56     bytecode_t *code;
  57
  58     BOOL from_eval;
  59
  60     unsigned code_off;
  61     unsigned code_size;
  62
  63     unsigned *labels;
  64     unsigned labels_size;
  65     unsigned labels_cnt;
  66
  67     struct
  68     {
  69         struct wine_rb_tree locals;
  70         unsigned int locals_cnt;
  71         unsigned int *ref_index;
  72     }
  73     *local_scopes;
  74     unsigned local_scope_count;
  75     unsigned local_scope_size;
  76
  77     statement_ctx_t *stat_ctx;
  78     function_code_t *func;
  79
  80     unsigned loc;
  81
  82     function_expression_t *func_head;
  83     function_expression_t *func_tail;
  84     function_expression_t *current_function_expr;
  85
  86     heap_pool_t heap;
  87 } compiler_ctx_t;
  88
  89 static const struct {
  90     const char *op_str;
  91     instr_arg_type_t arg1_type;
  92     instr_arg_type_t arg2_type;
  93 } instr_info[] = {
  94 #define X(n,a,b,c) {#n,b,c},
  95 OP_LIST
  96 #undef X
  97 };
  98
  99 static void dump_instr_arg(instr_arg_type_t type, instr_arg_t *arg)
 100 {
 101     switch(type) {
 102     case ARG_STR:
 103         TRACE_(jscript_disas)("\t%s", debugstr_jsstr(arg->str));
 104         break;
 105     case ARG_BSTR:
 106         TRACE_(jscript_disas)("\t%s", debugstr_wn(arg->bstr, SysStringLen(arg->bstr)));
 107         break;
 108     case ARG_INT:
 109         TRACE_(jscript_disas)("\t%d", arg->uint);
 110         break;
 111     case ARG_UINT:
 112     case ARG_ADDR:
 113         TRACE_(jscript_disas)("\t%u", arg->uint);
 114         break;
 115     case ARG_FUNC:
 116     case ARG_NONE:
 117         break;
 118     DEFAULT_UNREACHABLE;
 119     }
 120 }
 121
 122 static void dump_code(compiler_ctx_t *ctx, unsigned off)
 123 {
 124     instr_t *instr;
 125
 126     for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->code_off; instr++) {
 127         TRACE_(jscript_disas)("%d:\t%s", (int)(instr-ctx->code->instrs), instr_info[instr->op].op_str);
 128         if(instr_info[instr->op].arg1_type == ARG_DBL) {
 129             TRACE_(jscript_disas)("\t%lf", instr->u.dbl);
 130         }else {
 131             dump_instr_arg(instr_info[instr->op].arg1_type, instr->u.arg);
 132             dump_instr_arg(instr_info[instr->op].arg2_type, instr->u.arg+1);
 133         }
 134         TRACE_(jscript_disas)("\n");
 135     }
 136 }
 137
 138 static HRESULT compile_expression(compiler_ctx_t*,expression_t*,BOOL);
 139 static HRESULT compile_statement(compiler_ctx_t*,statement_ctx_t*,statement_t*);
 140
 141 static int function_local_cmp(const void *key, const struct wine_rb_entry *entry)
 142 {
 143     function_local_t *local = WINE_RB_ENTRY_VALUE(entry, function_local_t, entry);
 144     return wcscmp(key, local->name);
 145 }
 146
 147 static BOOL alloc_local_scope(compiler_ctx_t *ctx, unsigned int *scope_index)
 148 {
 149     unsigned int scope, new_size;
 150     void *new_alloc;
 151
 152     scope = ctx->local_scope_count++;
 153     if (scope == ctx->local_scope_size)
 154     {
 155         new_size = max(1, ctx->local_scope_size * 2);
 156         if (!(new_alloc = heap_realloc(ctx->local_scopes, new_size * sizeof(*ctx->local_scopes))))
 157             return FALSE;
 158         ctx->local_scopes = new_alloc;
 159         ctx->local_scope_size = new_size;
 160     }
 161
 162     ctx->local_scopes[scope].locals_cnt = 0;
 163     ctx->local_scopes[scope].ref_index = scope_index;
 164     wine_rb_init(&ctx->local_scopes[scope].locals, function_local_cmp);
 165     *scope_index = scope;
 166
 167     return TRUE;
 168 }
 169
 170 static void remove_local_scope(compiler_ctx_t *ctx, unsigned int scope_index)
 171 {
 172     unsigned int i;
 173
 174     assert(scope_index < ctx->local_scope_count);
 175     --ctx->local_scope_count;
 176     assert(scope_index == *ctx->local_scopes[scope_index].ref_index);
 177     *ctx->local_scopes[scope_index].ref_index = 0;
 178     memmove(&ctx->local_scopes[scope_index], &ctx->local_scopes[scope_index + 1],
 179             sizeof(*ctx->local_scopes) * (ctx->local_scope_count - scope_index));
 180     for (i = scope_index; i < ctx->local_scope_count; ++i)
 181         --*ctx->local_scopes[i].ref_index;
 182 }
 183
 184 static inline void *compiler_alloc(bytecode_t *code, size_t size)
 185 {
 186     return heap_pool_alloc(&code->heap, size);
 187 }
 188
 189 jsstr_t *compiler_alloc_string_len(compiler_ctx_t *ctx, const WCHAR *str, unsigned len)
 190 {
 191     jsstr_t *new_str;
 192
 193     if(!ctx->code->str_pool_size) {
 194         ctx->code->str_pool = heap_alloc(8 * sizeof(jsstr_t*));
 195         if(!ctx->code->str_pool)
 196             return NULL;
 197         ctx->code->str_pool_size = 8;
 198     }else if(ctx->code->str_pool_size == ctx->code->str_cnt) {
 199         jsstr_t **new_pool;
 200
 201         new_pool = heap_realloc(ctx->code->str_pool, ctx->code->str_pool_size*2*sizeof(jsstr_t*));
 202         if(!new_pool)
 203             return NULL;
 204
 205         ctx->code->str_pool = new_pool;
 206         ctx->code->str_pool_size *= 2;
 207     }
 208
 209     new_str = jsstr_alloc_len(str, len);
 210     if(!new_str)
 211         return NULL;
 212
 213     ctx->code->str_pool[ctx->code->str_cnt++] = new_str;
 214     return new_str;
 215 }
 216
 217 static jsstr_t *compiler_alloc_string(compiler_ctx_t *ctx, const WCHAR *str)
 218 {
 219     return compiler_alloc_string_len(ctx, str, lstrlenW(str));
 220 }
 221
 222 static BOOL ensure_bstr_slot(compiler_ctx_t *ctx)
 223 {
 224     if(!ctx->code->bstr_pool_size) {
 225         ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
 226         if(!ctx->code->bstr_pool)
 227             return FALSE;
 228         ctx->code->bstr_pool_size = 8;
 229     }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
 230         BSTR *new_pool;
 231
 232         new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
 233         if(!new_pool)
 234             return FALSE;
 235
 236         ctx->code->bstr_pool = new_pool;
 237         ctx->code->bstr_pool_size *= 2;
 238     }
 239
 240     return TRUE;
 241 }
 242
 243 static BSTR compiler_alloc_bstr(compiler_ctx_t *ctx, const WCHAR *str)
 244 {
 245     if(!ensure_bstr_slot(ctx))
 246         return NULL;
 247
 248     ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
 249     if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
 250         return NULL;
 251
 252     return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
 253 }
 254
 255 static BSTR compiler_alloc_bstr_len(compiler_ctx_t *ctx, const WCHAR *str, size_t len)
 256 {
 257     if(!ensure_bstr_slot(ctx))
 258         return NULL;
 259
 260     ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocStringLen(str, len);
 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 void set_compiler_loc(compiler_ctx_t *ctx, unsigned loc)
 268 {
 269     ctx->loc = loc;
 270 }
 271
 272 static unsigned push_instr(compiler_ctx_t *ctx, jsop_t op)
 273 {
 274     assert(ctx->code_size >= ctx->code_off);
 275
 276     if(ctx->code_size == ctx->code_off) {
 277         instr_t *new_instrs;
 278
 279         new_instrs = heap_realloc(ctx->code->instrs, ctx->code_size*2*sizeof(instr_t));
 280         if(!new_instrs)
 281             return 0;
 282
 283         ctx->code->instrs = new_instrs;
 284         ctx->code_size *= 2;
 285     }
 286
 287     ctx->code->instrs[ctx->code_off].op = op;
 288     ctx->code->instrs[ctx->code_off].loc = ctx->loc;
 289     return ctx->code_off++;
 290 }
 291
 292 static inline instr_t *instr_ptr(compiler_ctx_t *ctx, unsigned off)
 293 {
 294     assert(off < ctx->code_off);
 295     return ctx->code->instrs + off;
 296 }
 297
 298 static HRESULT push_instr_int(compiler_ctx_t *ctx, jsop_t op, LONG arg)
 299 {
 300     unsigned instr;
 301
 302     instr = push_instr(ctx, op);
 303     if(!instr)
 304         return E_OUTOFMEMORY;
 305
 306     instr_ptr(ctx, instr)->u.arg->lng = arg;
 307     return S_OK;
 308 }
 309
 310 static HRESULT push_instr_str(compiler_ctx_t *ctx, jsop_t op, jsstr_t *str)
 311 {
 312     unsigned instr;
 313
 314     instr = push_instr(ctx, op);
 315     if(!instr)
 316         return E_OUTOFMEMORY;
 317
 318     instr_ptr(ctx, instr)->u.arg->str = str;
 319     return S_OK;
 320 }
 321
 322 static HRESULT push_instr_str_uint(compiler_ctx_t *ctx, jsop_t op, jsstr_t *str, unsigned arg2)
 323 {
 324     unsigned instr;
 325
 326     instr = push_instr(ctx, op);
 327     if(!instr)
 328         return E_OUTOFMEMORY;
 329
 330     instr_ptr(ctx, instr)->u.arg[0].str = str;
 331     instr_ptr(ctx, instr)->u.arg[1].uint = arg2;
 332     return S_OK;
 333 }
 334
 335 static HRESULT push_instr_bstr(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
 336 {
 337     unsigned instr;
 338     WCHAR *str;
 339
 340     str = compiler_alloc_bstr(ctx, arg);
 341     if(!str)
 342         return E_OUTOFMEMORY;
 343
 344     instr = push_instr(ctx, op);
 345     if(!instr)
 346         return E_OUTOFMEMORY;
 347
 348     instr_ptr(ctx, instr)->u.arg->bstr = str;
 349     return S_OK;
 350 }
 351
 352 static HRESULT push_instr_bstr_uint(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg1, unsigned arg2)
 353 {
 354     unsigned instr;
 355     WCHAR *str;
 356
 357     str = compiler_alloc_bstr(ctx, arg1);
 358     if(!str)
 359         return E_OUTOFMEMORY;
 360
 361     instr = push_instr(ctx, op);
 362     if(!instr)
 363         return E_OUTOFMEMORY;
 364
 365     instr_ptr(ctx, instr)->u.arg[0].bstr = str;
 366     instr_ptr(ctx, instr)->u.arg[1].uint = arg2;
 367     return S_OK;
 368 }
 369
 370 static HRESULT push_instr_uint_str(compiler_ctx_t *ctx, jsop_t op, unsigned arg1, const WCHAR *arg2)
 371 {
 372     unsigned instr;
 373     jsstr_t *str;
 374
 375     str = compiler_alloc_string(ctx, arg2);
 376     if(!str)
 377         return E_OUTOFMEMORY;
 378
 379     instr = push_instr(ctx, op);
 380     if(!instr)
 381         return E_OUTOFMEMORY;
 382
 383     instr_ptr(ctx, instr)->u.arg[0].uint = arg1;
 384     instr_ptr(ctx, instr)->u.arg[1].str = str;
 385     return S_OK;
 386 }
 387
 388 static HRESULT push_instr_double(compiler_ctx_t *ctx, jsop_t op, double arg)
 389 {
 390     unsigned instr;
 391
 392     instr = push_instr(ctx, op);
 393     if(!instr)
 394         return E_OUTOFMEMORY;
 395
 396     instr_ptr(ctx, instr)->u.dbl = arg;
 397     return S_OK;
 398 }
 399
 400 static inline void set_arg_uint(compiler_ctx_t *ctx, unsigned instr, unsigned arg)
 401 {
 402     instr_ptr(ctx, instr)->u.arg->uint = arg;
 403 }
 404
 405 static HRESULT push_instr_uint(compiler_ctx_t *ctx, jsop_t op, unsigned arg)
 406 {
 407     unsigned instr;
 408
 409     instr = push_instr(ctx, op);
 410     if(!instr)
 411         return E_OUTOFMEMORY;
 412
 413     set_arg_uint(ctx, instr, arg);
 414     return S_OK;
 415 }
 416
 417 static HRESULT compile_binary_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 418 {
 419     HRESULT hres;
 420
 421     hres = compile_expression(ctx, expr->expression1, TRUE);
 422     if(FAILED(hres))
 423         return hres;
 424
 425     hres = compile_expression(ctx, expr->expression2, TRUE);
 426     if(FAILED(hres))
 427         return hres;
 428
 429     return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
 430 }
 431
 432 static HRESULT compile_unary_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op)
 433 {
 434     HRESULT hres;
 435
 436     hres = compile_expression(ctx, expr->expression, TRUE);
 437     if(FAILED(hres))
 438         return hres;
 439
 440     return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
 441 }
 442
 443 /* ECMA-262 3rd Edition    11.2.1 */
 444 static HRESULT compile_member_expression(compiler_ctx_t *ctx, member_expression_t *expr)
 445 {
 446     HRESULT hres;
 447
 448     hres = compile_expression(ctx, expr->expression, TRUE);
 449     if(FAILED(hres))
 450         return hres;
 451
 452     return push_instr_bstr(ctx, OP_member, expr->identifier);
 453 }
 454
 455 #define LABEL_FLAG 0x80000000
 456
 457 static unsigned alloc_label(compiler_ctx_t *ctx)
 458 {
 459     if(!ctx->labels_size) {
 460         ctx->labels = heap_alloc(8 * sizeof(*ctx->labels));
 461         if(!ctx->labels)
 462             return 0;
 463         ctx->labels_size = 8;
 464     }else if(ctx->labels_size == ctx->labels_cnt) {
 465         unsigned *new_labels;
 466
 467         new_labels = heap_realloc(ctx->labels, 2*ctx->labels_size*sizeof(*ctx->labels));
 468         if(!new_labels)
 469             return 0;
 470
 471         ctx->labels = new_labels;
 472         ctx->labels_size *= 2;
 473     }
 474
 475     return ctx->labels_cnt++ | LABEL_FLAG;
 476 }
 477
 478 static void label_set_addr(compiler_ctx_t *ctx, unsigned label)
 479 {
 480     assert(label & LABEL_FLAG);
 481     ctx->labels[label & ~LABEL_FLAG] = ctx->code_off;
 482 }
 483
 484 static inline BOOL is_memberid_expr(expression_type_t type)
 485 {
 486     return type == EXPR_IDENT || type == EXPR_MEMBER || type == EXPR_ARRAY;
 487 }
 488
 489 static BOOL bind_local(compiler_ctx_t *ctx, const WCHAR *identifier, int *ret_ref)
 490 {
 491     statement_ctx_t *iter;
 492     local_ref_t *ref;
 493
 494     for(iter = ctx->stat_ctx; iter; iter = iter->next) {
 495         if(iter->using_scope)
 496         {
 497             if (!iter->block_scope)
 498                 return FALSE;
 499
 500             if ((ref = lookup_local(ctx->func, identifier, iter->scope_index)))
 501             {
 502                 *ret_ref = ref->ref;
 503                 return TRUE;
 504             }
 505         }
 506     }
 507
 508     ref = lookup_local(ctx->func, identifier, 0);
 509     if(!ref)
 510         return FALSE;
 511
 512     *ret_ref = ref->ref;
 513     return TRUE;
 514 }
 515
 516 static HRESULT emit_identifier_ref(compiler_ctx_t *ctx, const WCHAR *identifier, unsigned flags)
 517 {
 518     int local_ref;
 519     if(bind_local(ctx, identifier, &local_ref))
 520         return push_instr_int(ctx, OP_local_ref, local_ref);
 521     return push_instr_bstr_uint(ctx, OP_identid, identifier, flags);
 522 }
 523
 524 static HRESULT emit_identifier(compiler_ctx_t *ctx, const WCHAR *identifier)
 525 {
 526     int local_ref;
 527     if(bind_local(ctx, identifier, &local_ref))
 528         return push_instr_int(ctx, OP_local, local_ref);
 529     return push_instr_bstr(ctx, OP_ident, identifier);
 530 }
 531
 532 static HRESULT emit_member_expression(compiler_ctx_t *ctx, expression_t *expr)
 533 {
 534     HRESULT hres;
 535
 536     if(expr->type == EXPR_ARRAY) {
 537         binary_expression_t *array_expr = (binary_expression_t*)expr;
 538
 539         hres = compile_expression(ctx, array_expr->expression1, TRUE);
 540         if(FAILED(hres))
 541             return hres;
 542
 543         hres = compile_expression(ctx, array_expr->expression2, TRUE);
 544         if(FAILED(hres))
 545             return hres;
 546
 547         if(!push_instr(ctx, OP_to_string))
 548             return E_OUTOFMEMORY;
 549     }else {
 550         member_expression_t *member_expr = (member_expression_t*)expr;
 551         jsstr_t *jsstr;
 552
 553         assert(expr->type == EXPR_MEMBER);
 554
 555         hres = compile_expression(ctx, member_expr->expression, TRUE);
 556         if(FAILED(hres))
 557             return hres;
 558
 559         jsstr = compiler_alloc_string(ctx, member_expr->identifier);
 560         if(!jsstr)
 561             return E_OUTOFMEMORY;
 562
 563         hres = push_instr_str(ctx, OP_str, jsstr);
 564         if(FAILED(hres))
 565             return hres;
 566     }
 567
 568     return S_OK;
 569 }
 570
 571 static void push_compiler_statement_ctx(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx)
 572 {
 573     if (stat_ctx)
 574     {
 575         stat_ctx->next = ctx->stat_ctx;
 576         ctx->stat_ctx = stat_ctx;
 577     }
 578 }
 579
 580 static void pop_compiler_statement_ctx(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx)
 581 {
 582     if (stat_ctx)
 583     {
 584         assert(ctx->stat_ctx == stat_ctx);
 585         ctx->stat_ctx = stat_ctx->next;
 586     }
 587 }
 588
 589 static HRESULT compile_memberid_expression(compiler_ctx_t *ctx, expression_t *expr, unsigned flags)
 590 {
 591     HRESULT hres;
 592
 593     if(expr->type == EXPR_IDENT) {
 594         identifier_expression_t *ident_expr = (identifier_expression_t*)expr;
 595         return emit_identifier_ref(ctx, ident_expr->identifier, flags);
 596     }
 597
 598     hres = emit_member_expression(ctx, expr);
 599     if(FAILED(hres))
 600         return hres;
 601
 602     return push_instr_uint(ctx, OP_memberid, flags);
 603 }
 604
 605 static HRESULT compile_increment_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op, int n)
 606 {
 607     HRESULT hres;
 608
 609     if(!is_memberid_expr(expr->expression->type)) {
 610         hres = compile_expression(ctx, expr->expression, TRUE);
 611         if(FAILED(hres))
 612             return hres;
 613
 614         return push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
 615     }
 616
 617     hres = compile_memberid_expression(ctx, expr->expression, fdexNameEnsure);
 618     if(FAILED(hres))
 619         return hres;
 620
 621     return push_instr_int(ctx, op, n);
 622 }
 623
 624 /* ECMA-262 3rd Edition    11.14 */
 625 static HRESULT compile_comma_expression(compiler_ctx_t *ctx, binary_expression_t *expr, BOOL emit_ret)
 626 {
 627     HRESULT hres;
 628
 629     hres = compile_expression(ctx, expr->expression1, FALSE);
 630     if(FAILED(hres))
 631         return hres;
 632
 633     return compile_expression(ctx, expr->expression2, emit_ret);
 634 }
 635
 636 /* ECMA-262 3rd Edition    11.11 */
 637 static HRESULT compile_logical_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 638 {
 639     unsigned instr;
 640     HRESULT hres;
 641
 642     hres = compile_expression(ctx, expr->expression1, TRUE);
 643     if(FAILED(hres))
 644         return hres;
 645
 646     instr = push_instr(ctx, op);
 647     if(!instr)
 648         return E_OUTOFMEMORY;
 649
 650     hres = compile_expression(ctx, expr->expression2, TRUE);
 651     if(FAILED(hres))
 652         return hres;
 653
 654     set_arg_uint(ctx, instr, ctx->code_off);
 655     return S_OK;
 656 }
 657
 658 /* ECMA-262 3rd Edition    11.12 */
 659 static HRESULT compile_conditional_expression(compiler_ctx_t *ctx, conditional_expression_t *expr)
 660 {
 661     unsigned jmp_false, jmp_end;
 662     HRESULT hres;
 663
 664     hres = compile_expression(ctx, expr->expression, TRUE);
 665     if(FAILED(hres))
 666         return hres;
 667
 668     jmp_false = push_instr(ctx, OP_cnd_z);
 669     if(!jmp_false)
 670         return E_OUTOFMEMORY;
 671
 672     hres = compile_expression(ctx, expr->true_expression, TRUE);
 673     if(FAILED(hres))
 674         return hres;
 675
 676     jmp_end = push_instr(ctx, OP_jmp);
 677     if(!jmp_end)
 678         return E_OUTOFMEMORY;
 679
 680     set_arg_uint(ctx, jmp_false, ctx->code_off);
 681     hres = push_instr_uint(ctx, OP_pop, 1);
 682     if(FAILED(hres))
 683         return hres;
 684
 685     hres = compile_expression(ctx, expr->false_expression, TRUE);
 686     if(FAILED(hres))
 687         return hres;
 688
 689     set_arg_uint(ctx, jmp_end, ctx->code_off);
 690     return S_OK;
 691 }
 692
 693 static HRESULT compile_new_expression(compiler_ctx_t *ctx, call_expression_t *expr)
 694 {
 695     unsigned arg_cnt = 0;
 696     argument_t *arg;
 697     HRESULT hres;
 698
 699     hres = compile_expression(ctx, expr->expression, TRUE);
 700     if(FAILED(hres))
 701         return hres;
 702
 703     for(arg = expr->argument_list; arg; arg = arg->next) {
 704         hres = compile_expression(ctx, arg->expr, TRUE);
 705         if(FAILED(hres))
 706             return hres;
 707         arg_cnt++;
 708     }
 709
 710     hres = push_instr_uint(ctx, OP_new, arg_cnt);
 711     if(FAILED(hres))
 712         return hres;
 713
 714     hres = push_instr_uint(ctx, OP_pop, arg_cnt+1);
 715     if(FAILED(hres))
 716         return hres;
 717
 718     return push_instr(ctx, OP_push_acc) ? S_OK : E_OUTOFMEMORY;
 719 }
 720
 721 static HRESULT compile_call_expression(compiler_ctx_t *ctx, call_expression_t *expr, BOOL emit_ret)
 722 {
 723     unsigned arg_cnt = 0, extra_args;
 724     argument_t *arg;
 725     unsigned instr;
 726     jsop_t op;
 727     HRESULT hres;
 728
 729     if(is_memberid_expr(expr->expression->type)) {
 730         op = OP_call_member;
 731         extra_args = 2;
 732         hres = compile_memberid_expression(ctx, expr->expression, 0);
 733     }else {
 734         op = OP_call;
 735         extra_args = 1;
 736         hres = compile_expression(ctx, expr->expression, TRUE);
 737     }
 738
 739     if(FAILED(hres))
 740         return hres;
 741
 742     for(arg = expr->argument_list; arg; arg = arg->next) {
 743         hres = compile_expression(ctx, arg->expr, TRUE);
 744         if(FAILED(hres))
 745             return hres;
 746         arg_cnt++;
 747     }
 748
 749     instr = push_instr(ctx, op);
 750     if(!instr)
 751         return E_OUTOFMEMORY;
 752
 753     instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
 754     instr_ptr(ctx, instr)->u.arg[1].lng = emit_ret;
 755
 756     hres = push_instr_uint(ctx, OP_pop, arg_cnt + extra_args);
 757     if(FAILED(hres))
 758         return hres;
 759
 760     return !emit_ret || push_instr(ctx, OP_push_acc) ? S_OK : E_OUTOFMEMORY;
 761 }
 762
 763 static HRESULT compile_delete_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
 764 {
 765     HRESULT hres;
 766
 767     switch(expr->expression->type) {
 768     case EXPR_ARRAY: {
 769         binary_expression_t *array_expr = (binary_expression_t*)expr->expression;
 770
 771         hres = compile_expression(ctx, array_expr->expression1, TRUE);
 772         if(FAILED(hres))
 773             return hres;
 774
 775         hres = compile_expression(ctx, array_expr->expression2, TRUE);
 776         if(FAILED(hres))
 777             return hres;
 778
 779         if(!push_instr(ctx, OP_delete))
 780             return E_OUTOFMEMORY;
 781         break;
 782     }
 783     case EXPR_MEMBER: {
 784         member_expression_t *member_expr = (member_expression_t*)expr->expression;
 785         jsstr_t *jsstr;
 786
 787         hres = compile_expression(ctx, member_expr->expression, TRUE);
 788         if(FAILED(hres))
 789             return hres;
 790
 791         /* FIXME: Potential optimization */
 792         jsstr = compiler_alloc_string(ctx, member_expr->identifier);
 793         if(!jsstr)
 794             return E_OUTOFMEMORY;
 795
 796         hres = push_instr_str(ctx, OP_str, jsstr);
 797         if(FAILED(hres))
 798             return hres;
 799
 800         if(!push_instr(ctx, OP_delete))
 801             return E_OUTOFMEMORY;
 802         break;
 803     }
 804     case EXPR_IDENT:
 805         return push_instr_bstr(ctx, OP_delete_ident, ((identifier_expression_t*)expr->expression)->identifier);
 806     default: {
 807         WARN("invalid delete, unimplemented exception message\n");
 808
 809         hres = compile_expression(ctx, expr->expression, TRUE);
 810         if(FAILED(hres))
 811             return hres;
 812
 813         return push_instr_uint_str(ctx, OP_throw_type, JS_E_INVALID_DELETE, L"FIXME");
 814     }
 815     }
 816
 817     return S_OK;
 818 }
 819
 820 static HRESULT compile_assign_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 821 {
 822     jsop_t assign_op = OP_throw_ref;
 823     unsigned arg_cnt = 0;
 824     HRESULT hres;
 825
 826     if(expr->expression1->type == EXPR_CALL) {
 827         call_expression_t *call_expr = (call_expression_t*)expr->expression1;
 828         argument_t *arg;
 829
 830         if(is_memberid_expr(call_expr->expression->type) && call_expr->argument_list) {
 831             hres = compile_memberid_expression(ctx, call_expr->expression, fdexNameEnsure);
 832             if(FAILED(hres))
 833                 return hres;
 834
 835             for(arg = call_expr->argument_list; arg; arg = arg->next) {
 836                 hres = compile_expression(ctx, arg->expr, TRUE);
 837                 if(FAILED(hres))
 838                     return hres;
 839                 arg_cnt++;
 840             }
 841
 842             if(op != OP_LAST) {
 843                 unsigned instr;
 844
 845                 /* We need to call the functions twice: to get the value and to set it.
 846                  * JavaScript interpreted functions may to modify value on the stack,
 847                  * but assignment calls are allowed only on external functions, so we
 848                  * may reuse the stack here. */
 849                 instr = push_instr(ctx, OP_call_member);
 850                 if(!instr)
 851                     return E_OUTOFMEMORY;
 852                 instr_ptr(ctx, instr)->u.arg[0].uint = arg_cnt;
 853                 instr_ptr(ctx, instr)->u.arg[1].lng = 1;
 854
 855                 if(!push_instr(ctx, OP_push_acc))
 856                     return E_OUTOFMEMORY;
 857             }
 858             assign_op = OP_assign_call;
 859         }
 860     }else if(is_memberid_expr(expr->expression1->type)) {
 861         if(op != OP_LAST || expr->expression1->type == EXPR_IDENT) {
 862             hres = compile_memberid_expression(ctx, expr->expression1, fdexNameEnsure);
 863             if(FAILED(hres))
 864                 return hres;
 865             if(op != OP_LAST && !push_instr(ctx, OP_refval))
 866                 return E_OUTOFMEMORY;
 867             assign_op = OP_assign;
 868         }else {
 869             hres = emit_member_expression(ctx, expr->expression1);
 870             if(FAILED(hres))
 871                 return hres;
 872             assign_op = OP_set_member;
 873         }
 874     }
 875
 876     if(assign_op == OP_throw_ref) {
 877         /* Illegal assignment: evaluate and throw */
 878         hres = compile_expression(ctx, expr->expression1, TRUE);
 879         if(FAILED(hres))
 880             return hres;
 881         arg_cnt = JS_E_ILLEGAL_ASSIGN;
 882     }
 883
 884     hres = compile_expression(ctx, expr->expression2, TRUE);
 885     if(FAILED(hres))
 886         return hres;
 887
 888     if(op != OP_LAST && !push_instr(ctx, op))
 889         return E_OUTOFMEMORY;
 890
 891     return push_instr_uint(ctx, assign_op, arg_cnt);
 892 }
 893
 894 static HRESULT compile_typeof_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
 895 {
 896     jsop_t op;
 897     HRESULT hres;
 898
 899     if(is_memberid_expr(expr->expression->type)) {
 900         if(expr->expression->type == EXPR_IDENT)
 901             return push_instr_bstr(ctx, OP_typeofident, ((identifier_expression_t*)expr->expression)->identifier);
 902
 903         op = OP_typeofid;
 904         hres = compile_memberid_expression(ctx, expr->expression, 0);
 905     }else {
 906         op = OP_typeof;
 907         hres = compile_expression(ctx, expr->expression, TRUE);
 908     }
 909     if(FAILED(hres))
 910         return hres;
 911
 912     return push_instr(ctx, op) ? S_OK : E_OUTOFMEMORY;
 913 }
 914
 915 static HRESULT compile_literal(compiler_ctx_t *ctx, literal_t *literal)
 916 {
 917     switch(literal->type) {
 918     case LT_BOOL:
 919         return push_instr_int(ctx, OP_bool, literal->u.bval);
 920     case LT_DOUBLE:
 921         return push_instr_double(ctx, OP_double, literal->u.dval);
 922     case LT_NULL:
 923         return push_instr(ctx, OP_null) ? S_OK : E_OUTOFMEMORY;
 924     case LT_STRING:
 925         return push_instr_str(ctx, OP_str, literal->u.str);
 926     case LT_REGEXP:
 927         return push_instr_str_uint(ctx, OP_regexp, literal->u.regexp.str, literal->u.regexp.flags);
 928     DEFAULT_UNREACHABLE;
 929     }
 930     return E_FAIL;
 931 }
 932
 933 static HRESULT literal_as_string(compiler_ctx_t *ctx, literal_t *literal, jsstr_t **str)
 934 {
 935     switch(literal->type) {
 936     case LT_STRING:
 937         *str = literal->u.str;
 938         break;
 939     case LT_DOUBLE:
 940         return double_to_string(literal->u.dval, str);
 941     DEFAULT_UNREACHABLE;
 942     }
 943
 944     return *str ? S_OK : E_OUTOFMEMORY;
 945 }
 946
 947 static HRESULT compile_array_literal(compiler_ctx_t *ctx, array_literal_expression_t *expr)
 948 {
 949     unsigned length = 0;
 950     array_element_t *iter;
 951     unsigned array_instr;
 952     HRESULT hres;
 953
 954     array_instr = push_instr(ctx, OP_carray);
 955
 956     for(iter = expr->element_list; iter; iter = iter->next) {
 957         length += iter->elision;
 958
 959         hres = compile_expression(ctx, iter->expr, TRUE);
 960         if(FAILED(hres))
 961             return hres;
 962
 963         hres = push_instr_uint(ctx, OP_carray_set, length);
 964         if(FAILED(hres))
 965             return hres;
 966
 967         length++;
 968     }
 969
 970     instr_ptr(ctx, array_instr)->u.arg[0].uint = length + expr->length;
 971     return S_OK;
 972 }
 973
 974 static HRESULT compile_object_literal(compiler_ctx_t *ctx, property_value_expression_t *expr)
 975 {
 976     property_definition_t *iter;
 977     jsstr_t *name;
 978     HRESULT hres;
 979
 980     if(!push_instr(ctx, OP_new_obj))
 981         return E_OUTOFMEMORY;
 982
 983     for(iter = expr->property_list; iter; iter = iter->next) {
 984         hres = literal_as_string(ctx, iter->name, &name);
 985         if(FAILED(hres))
 986             return hres;
 987
 988         hres = compile_expression(ctx, iter->value, TRUE);
 989         if(FAILED(hres))
 990             return hres;
 991
 992         hres = push_instr_str_uint(ctx, OP_obj_prop, name, iter->type);
 993         if(FAILED(hres))
 994             return hres;
 995     }
 996
 997     return S_OK;
 998 }
 999
1000 static HRESULT compile_function_expression(compiler_ctx_t *ctx, function_expression_t *expr, BOOL emit_ret)
1001 {
1002     statement_ctx_t *stat_ctx;
1003
1004     assert(ctx->current_function_expr);
1005
1006     for(stat_ctx = ctx->stat_ctx; stat_ctx; stat_ctx = stat_ctx->next)
1007     {
1008         if(stat_ctx->block_scope)
1009             break;
1010     }
1011     ctx->current_function_expr->scope_index = stat_ctx ? stat_ctx->scope_index : 0;
1012     ctx->current_function_expr = ctx->current_function_expr->next;
1013
1014     return emit_ret ? push_instr_uint(ctx, OP_func, expr->func_id) : S_OK;
1015 }
1016
1017 static HRESULT compile_expression(compiler_ctx_t *ctx, expression_t *expr, BOOL emit_ret)
1018 {
1019     HRESULT hres;
1020
1021     switch(expr->type) {
1022     case EXPR_ADD:
1023         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
1024         break;
1025     case EXPR_AND:
1026         hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_z);
1027         break;
1028     case EXPR_ARRAY:
1029         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_array);
1030         break;
1031     case EXPR_ARRAYLIT:
1032         hres = compile_array_literal(ctx, (array_literal_expression_t*)expr);
1033         break;
1034     case EXPR_ASSIGN:
1035         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_LAST);
1036         break;
1037     case EXPR_ASSIGNADD:
1038         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_add);
1039         break;
1040     case EXPR_ASSIGNAND:
1041         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_and);
1042         break;
1043     case EXPR_ASSIGNSUB:
1044         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_sub);
1045         break;
1046     case EXPR_ASSIGNMUL:
1047         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mul);
1048         break;
1049     case EXPR_ASSIGNDIV:
1050         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_div);
1051         break;
1052     case EXPR_ASSIGNMOD:
1053         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mod);
1054         break;
1055     case EXPR_ASSIGNOR:
1056         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_or);
1057         break;
1058     case EXPR_ASSIGNLSHIFT:
1059         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_lshift);
1060         break;
1061     case EXPR_ASSIGNRSHIFT:
1062         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift);
1063         break;
1064     case EXPR_ASSIGNRRSHIFT:
1065         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
1066         break;
1067     case EXPR_ASSIGNXOR:
1068         hres = compile_assign_expression(ctx, (binary_expression_t*)expr, OP_xor);
1069         break;
1070     case EXPR_BAND:
1071         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
1072         break;
1073     case EXPR_BITNEG:
1074         hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_bneg);
1075         break;
1076     case EXPR_BOR:
1077         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
1078         break;
1079     case EXPR_CALL:
1080         return compile_call_expression(ctx, (call_expression_t*)expr, emit_ret);
1081     case EXPR_COMMA:
1082         return compile_comma_expression(ctx, (binary_expression_t*)expr, emit_ret);
1083     case EXPR_COND:
1084         hres = compile_conditional_expression(ctx, (conditional_expression_t*)expr);
1085         break;
1086     case EXPR_DELETE:
1087         hres = compile_delete_expression(ctx, (unary_expression_t*)expr);
1088         break;
1089     case EXPR_DIV:
1090         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
1091         break;
1092     case EXPR_EQ:
1093         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq);
1094         break;
1095     case EXPR_EQEQ:
1096         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq2);
1097         break;
1098     case EXPR_FUNC:
1099         return compile_function_expression(ctx, (function_expression_t*)expr, emit_ret);
1100     case EXPR_GREATER:
1101         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
1102         break;
1103     case EXPR_GREATEREQ:
1104         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
1105         break;
1106     case EXPR_IDENT:
1107         hres = emit_identifier(ctx, ((identifier_expression_t*)expr)->identifier);
1108         break;
1109     case EXPR_IN:
1110         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_in);
1111         break;
1112     case EXPR_INSTANCEOF:
1113         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_instanceof);
1114         break;
1115     case EXPR_LESS:
1116         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
1117         break;
1118     case EXPR_LESSEQ:
1119         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
1120         break;
1121     case EXPR_LITERAL:
1122         hres = compile_literal(ctx, ((literal_expression_t*)expr)->literal);
1123         break;
1124     case EXPR_LOGNEG:
1125         hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
1126         break;
1127     case EXPR_LSHIFT:
1128         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lshift);
1129         break;
1130     case EXPR_MEMBER:
1131         hres = compile_member_expression(ctx, (member_expression_t*)expr);
1132         break;
1133     case EXPR_MINUS:
1134         hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_minus);
1135         break;
1136     case EXPR_MOD:
1137         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
1138         break;
1139     case EXPR_MUL:
1140         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
1141         break;
1142     case EXPR_NEW:
1143         hres = compile_new_expression(ctx, (call_expression_t*)expr);
1144         break;
1145     case EXPR_NOTEQ:
1146         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq);
1147         break;
1148     case EXPR_NOTEQEQ:
1149         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq2);
1150         break;
1151     case EXPR_OR:
1152         hres = compile_logical_expression(ctx, (binary_expression_t*)expr, OP_cnd_nz);
1153         break;
1154     case EXPR_PLUS:
1155         hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_tonum);
1156         break;
1157     case EXPR_POSTDEC:
1158         hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, -1);
1159         break;
1160     case EXPR_POSTINC:
1161         hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, 1);
1162         break;
1163     case EXPR_PREDEC:
1164         hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, -1);
1165         break;
1166     case EXPR_PREINC:
1167         hres = compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, 1);
1168         break;
1169     case EXPR_PROPVAL:
1170         hres = compile_object_literal(ctx, (property_value_expression_t*)expr);
1171         break;
1172     case EXPR_RSHIFT:
1173         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift);
1174         break;
1175     case EXPR_RRSHIFT:
1176         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
1177         break;
1178     case EXPR_SUB:
1179         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
1180         break;
1181     case EXPR_THIS:
1182         return !emit_ret || push_instr(ctx, OP_this) ? S_OK : E_OUTOFMEMORY;
1183     case EXPR_TYPEOF:
1184         hres = compile_typeof_expression(ctx, (unary_expression_t*)expr);
1185         break;
1186     case EXPR_VOID:
1187         hres = compile_unary_expression(ctx, (unary_expression_t*)expr, OP_void);
1188         break;
1189     case EXPR_BXOR:
1190         hres = compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
1191         break;
1192     DEFAULT_UNREACHABLE;
1193     }
1194
1195     if(FAILED(hres))
1196         return hres;
1197
1198     return emit_ret ? S_OK : push_instr_uint(ctx, OP_pop, 1);
1199 }
1200
1201 static inline BOOL is_loop_statement(statement_type_t type)
1202 {
1203     return type == STAT_FOR || type == STAT_FORIN || type == STAT_WHILE;
1204 }
1205
1206 /* ECMA-262 3rd Edition    12.1 */
1207 static HRESULT compile_block_statement(compiler_ctx_t *ctx, block_statement_t *block, statement_t *iter)
1208 {
1209     statement_ctx_t stat_ctx = {0, TRUE};
1210     BOOL needs_scope;
1211     HRESULT hres;
1212
1213     needs_scope = block && block->scope_index;
1214     if (needs_scope)
1215     {
1216         if(FAILED(hres = push_instr_uint(ctx, OP_push_block_scope, block->scope_index)))
1217             return hres;
1218
1219         stat_ctx.scope_index = block->scope_index;
1220         stat_ctx.block_scope = TRUE;
1221     }
1222
1223     while(iter) {
1224         hres = compile_statement(ctx, needs_scope ? &stat_ctx : NULL, iter);
1225         if(FAILED(hres))
1226             return hres;
1227
1228         iter = iter->next;
1229     }
1230
1231     if(needs_scope && !push_instr(ctx, OP_pop_scope))
1232         return E_OUTOFMEMORY;
1233
1234     return S_OK;
1235 }
1236
1237 /* ECMA-262 3rd Edition    12.2 */
1238 static HRESULT compile_variable_list(compiler_ctx_t *ctx, variable_declaration_t *list)
1239 {
1240     variable_declaration_t *iter;
1241     HRESULT hres;
1242
1243     assert(list != NULL);
1244
1245     for(iter = list; iter; iter = iter->next) {
1246         if(!iter->expr)
1247             continue;
1248
1249         if (iter->constant)
1250             FIXME("Constant variables are not supported.\n");
1251
1252         hres = emit_identifier_ref(ctx, iter->identifier, 0);
1253         if(FAILED(hres))
1254             return hres;
1255
1256         hres = compile_expression(ctx, iter->expr, TRUE);
1257         if(FAILED(hres))
1258             return hres;
1259
1260         if(!push_instr(ctx, OP_assign))
1261             return E_OUTOFMEMORY;
1262
1263         hres = push_instr_uint(ctx, OP_pop, 1);
1264         if(FAILED(hres))
1265             return hres;
1266     }
1267
1268     return S_OK;
1269 }
1270
1271 /* ECMA-262 3rd Edition    12.2 */
1272 static HRESULT compile_var_statement(compiler_ctx_t *ctx, var_statement_t *stat)
1273 {
1274     return compile_variable_list(ctx, stat->variable_list);
1275 }
1276
1277 /* ECMA-262 3rd Edition    12.4 */
1278 static HRESULT compile_expression_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1279 {
1280     HRESULT hres;
1281
1282     hres = compile_expression(ctx, stat->expr, ctx->from_eval);
1283     if(FAILED(hres))
1284         return hres;
1285
1286     return !ctx->from_eval || push_instr(ctx, OP_setret) ? S_OK : E_OUTOFMEMORY;
1287 }
1288
1289 /* ECMA-262 3rd Edition    12.5 */
1290 static HRESULT compile_if_statement(compiler_ctx_t *ctx, if_statement_t *stat)
1291 {
1292     unsigned jmp_else;
1293     HRESULT hres;
1294
1295     hres = compile_expression(ctx, stat->expr, TRUE);
1296     if(FAILED(hres))
1297         return hres;
1298
1299     jmp_else = push_instr(ctx, OP_jmp_z);
1300     if(!jmp_else)
1301         return E_OUTOFMEMORY;
1302
1303     hres = compile_statement(ctx, NULL, stat->if_stat);
1304     if(FAILED(hres))
1305         return hres;
1306
1307     if(stat->else_stat) {
1308         unsigned jmp_end;
1309
1310         jmp_end = push_instr(ctx, OP_jmp);
1311         if(!jmp_end)
1312             return E_OUTOFMEMORY;
1313
1314         set_arg_uint(ctx, jmp_else, ctx->code_off);
1315
1316         hres = compile_statement(ctx, NULL, stat->else_stat);
1317         if(FAILED(hres))
1318             return hres;
1319
1320         set_arg_uint(ctx, jmp_end, ctx->code_off);
1321     }else {
1322         set_arg_uint(ctx, jmp_else, ctx->code_off);
1323     }
1324
1325     return S_OK;
1326 }
1327
1328 /* ECMA-262 3rd Edition    12.6.2 */
1329 static HRESULT compile_while_statement(compiler_ctx_t *ctx, while_statement_t *stat)
1330 {
1331     statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1332     unsigned jmp_off;
1333     HRESULT hres;
1334
1335     stat_ctx.break_label = alloc_label(ctx);
1336     if(!stat_ctx.break_label)
1337         return E_OUTOFMEMORY;
1338
1339     stat_ctx.continue_label = alloc_label(ctx);
1340     if(!stat_ctx.continue_label)
1341         return E_OUTOFMEMORY;
1342
1343     jmp_off = ctx->code_off;
1344
1345     if(!stat->do_while) {
1346         label_set_addr(ctx, stat_ctx.continue_label);
1347         hres = compile_expression(ctx, stat->expr, TRUE);
1348         if(FAILED(hres))
1349             return hres;
1350
1351         hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1352         if(FAILED(hres))
1353             return hres;
1354     }
1355
1356     hres = compile_statement(ctx, &stat_ctx, stat->statement);
1357     if(FAILED(hres))
1358         return hres;
1359
1360     set_compiler_loc(ctx, stat->stat.loc);
1361     if(stat->do_while) {
1362         label_set_addr(ctx, stat_ctx.continue_label);
1363         hres = compile_expression(ctx, stat->expr, TRUE);
1364         if(FAILED(hres))
1365             return hres;
1366
1367         hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1368         if(FAILED(hres))
1369             return hres;
1370     }
1371
1372     hres = push_instr_uint(ctx, OP_jmp, jmp_off);
1373     if(FAILED(hres))
1374         return hres;
1375
1376     label_set_addr(ctx, stat_ctx.break_label);
1377     return S_OK;
1378 }
1379
1380 /* ECMA-262 10th Edition   13.7.4 */
1381 static HRESULT compile_for_statement(compiler_ctx_t *ctx, for_statement_t *stat)
1382 {
1383     statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1384     statement_ctx_t scope_stat_ctx = {0, TRUE};
1385     unsigned expr_off;
1386     HRESULT hres;
1387
1388     if (stat->scope_index)
1389     {
1390         if(FAILED(hres = push_instr_uint(ctx, OP_push_block_scope, stat->scope_index)))
1391             return hres;
1392
1393         scope_stat_ctx.scope_index = stat->scope_index;
1394         scope_stat_ctx.block_scope = TRUE;
1395         push_compiler_statement_ctx(ctx, &scope_stat_ctx);
1396     }
1397
1398     if(stat->variable_list) {
1399         hres = compile_variable_list(ctx, stat->variable_list);
1400         if(FAILED(hres))
1401             goto done;
1402     }else if(stat->begin_expr) {
1403         hres = compile_expression(ctx, stat->begin_expr, FALSE);
1404         if(FAILED(hres))
1405             goto done;
1406     }
1407
1408     stat_ctx.break_label = alloc_label(ctx);
1409     if(!stat_ctx.break_label)
1410     {
1411         hres = E_OUTOFMEMORY;
1412         goto done;
1413     }
1414
1415     stat_ctx.continue_label = alloc_label(ctx);
1416     if(!stat_ctx.continue_label)
1417     {
1418         hres = E_OUTOFMEMORY;
1419         goto done;
1420     }
1421     expr_off = ctx->code_off;
1422
1423     if(stat->expr) {
1424         set_compiler_loc(ctx, stat->expr_loc);
1425         hres = compile_expression(ctx, stat->expr, TRUE);
1426         if(FAILED(hres))
1427             goto done;
1428
1429         hres = push_instr_uint(ctx, OP_jmp_z, stat_ctx.break_label);
1430         if(FAILED(hres))
1431             goto done;
1432     }
1433
1434     hres = compile_statement(ctx, &stat_ctx, stat->statement);
1435     if(FAILED(hres))
1436         goto done;
1437
1438     label_set_addr(ctx, stat_ctx.continue_label);
1439
1440     if(stat->end_expr) {
1441         set_compiler_loc(ctx, stat->end_loc);
1442         hres = compile_expression(ctx, stat->end_expr, FALSE);
1443         if(FAILED(hres))
1444             goto done;
1445     }
1446
1447     hres = push_instr_uint(ctx, OP_jmp, expr_off);
1448     if(FAILED(hres))
1449         goto done;
1450
1451     label_set_addr(ctx, stat_ctx.break_label);
1452     hres = S_OK;
1453 done:
1454     if (stat->scope_index)
1455     {
1456         pop_compiler_statement_ctx(ctx, &scope_stat_ctx);
1457         if(SUCCEEDED(hres) && !push_instr(ctx, OP_pop_scope))
1458             return E_OUTOFMEMORY;
1459     }
1460     return hres;
1461 }
1462
1463 /* ECMA-262 3rd Edition    12.6.4 */
1464 static HRESULT compile_forin_statement(compiler_ctx_t *ctx, forin_statement_t *stat)
1465 {
1466     statement_ctx_t stat_ctx = {4, FALSE, FALSE};
1467     HRESULT hres;
1468
1469     if(stat->variable) {
1470         hres = compile_variable_list(ctx, stat->variable);
1471         if(FAILED(hres))
1472             return hres;
1473     }
1474
1475     stat_ctx.break_label = alloc_label(ctx);
1476     if(!stat_ctx.break_label)
1477         return E_OUTOFMEMORY;
1478
1479     stat_ctx.continue_label = alloc_label(ctx);
1480     if(!stat_ctx.continue_label)
1481         return E_OUTOFMEMORY;
1482
1483     hres = compile_expression(ctx, stat->in_expr, TRUE);
1484     if(FAILED(hres))
1485         return hres;
1486
1487     if(stat->variable) {
1488         hres = emit_identifier_ref(ctx, stat->variable->identifier, fdexNameEnsure);
1489         if(FAILED(hres))
1490             return hres;
1491     }else if(is_memberid_expr(stat->expr->type)) {
1492         hres = compile_memberid_expression(ctx, stat->expr, fdexNameEnsure);
1493         if(FAILED(hres))
1494             return hres;
1495     }else {
1496         hres = push_instr_uint(ctx, OP_throw_ref, JS_E_ILLEGAL_ASSIGN);
1497         if(FAILED(hres))
1498             return hres;
1499
1500         /* FIXME: compile statement anyways when we depend on compiler to check errors */
1501         return S_OK;
1502     }
1503
1504     hres = push_instr_int(ctx, OP_int, DISPID_STARTENUM);
1505     if(FAILED(hres))
1506         return hres;
1507
1508     label_set_addr(ctx, stat_ctx.continue_label);
1509     hres = push_instr_uint(ctx, OP_forin, stat_ctx.break_label);
1510     if(FAILED(hres))
1511         return E_OUTOFMEMORY;
1512
1513     hres = compile_statement(ctx, &stat_ctx, stat->statement);
1514     if(FAILED(hres))
1515         return hres;
1516
1517     hres = push_instr_uint(ctx, OP_jmp, stat_ctx.continue_label);
1518     if(FAILED(hres))
1519         return hres;
1520
1521     label_set_addr(ctx, stat_ctx.break_label);
1522     return S_OK;
1523 }
1524
1525 static HRESULT pop_to_stat(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx)
1526 {
1527     unsigned stack_pop = 0;
1528     statement_ctx_t *iter;
1529     HRESULT hres;
1530
1531     for(iter = ctx->stat_ctx; iter != stat_ctx; iter = iter->next) {
1532         if(iter->using_scope && !push_instr(ctx, OP_pop_scope))
1533             return E_OUTOFMEMORY;
1534         if(iter->using_except) {
1535             if(stack_pop) {
1536                 hres = push_instr_uint(ctx, OP_pop, stack_pop);
1537                 if(FAILED(hres))
1538                     return hres;
1539                 stack_pop = 0;
1540             }
1541             hres = push_instr_uint(ctx, OP_pop_except, ctx->code_off+1);
1542             if(FAILED(hres))
1543                 return hres;
1544         }
1545         stack_pop += iter->stack_use;
1546     }
1547
1548     if(stack_pop) {
1549         hres = push_instr_uint(ctx, OP_pop, stack_pop);
1550         if(FAILED(hres))
1551             return hres;
1552     }
1553
1554     return S_OK;
1555 }
1556
1557 /* ECMA-262 3rd Edition    12.7 */
1558 static HRESULT compile_continue_statement(compiler_ctx_t *ctx, branch_statement_t *stat)
1559 {
1560     statement_ctx_t *pop_ctx;
1561     HRESULT hres;
1562
1563     if(stat->identifier) {
1564         statement_t *label_stat;
1565         statement_ctx_t *iter;
1566
1567         pop_ctx = NULL;
1568
1569         for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1570             if(iter->continue_label)
1571                 pop_ctx = iter;
1572             if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier))
1573                 break;
1574         }
1575
1576         if(!iter) {
1577             WARN("Label not found\n");
1578             return JS_E_LABEL_NOT_FOUND;
1579         }
1580
1581         /* Labelled continue are allowed only on loops */
1582         for(label_stat = iter->labelled_stat->statement;
1583             label_stat->type == STAT_LABEL;
1584             label_stat = ((labelled_statement_t*)label_stat)->statement);
1585         if(!is_loop_statement(label_stat->type)) {
1586             WARN("Label is not a loop\n");
1587             return JS_E_INVALID_CONTINUE;
1588         }
1589
1590         assert(pop_ctx != NULL);
1591     }else {
1592         for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1593             if(pop_ctx->continue_label)
1594                 break;
1595         }
1596
1597         if(!pop_ctx) {
1598             WARN("continue outside loop\n");
1599             return JS_E_INVALID_CONTINUE;
1600         }
1601     }
1602
1603     hres = pop_to_stat(ctx, pop_ctx);
1604     if(FAILED(hres))
1605         return hres;
1606
1607     return push_instr_uint(ctx, OP_jmp, pop_ctx->continue_label);
1608 }
1609
1610 /* ECMA-262 3rd Edition    12.8 */
1611 static HRESULT compile_break_statement(compiler_ctx_t *ctx, branch_statement_t *stat)
1612 {
1613     statement_ctx_t *pop_ctx;
1614     HRESULT hres;
1615
1616     if(stat->identifier) {
1617         for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1618             if(pop_ctx->labelled_stat && !wcscmp(pop_ctx->labelled_stat->identifier, stat->identifier)) {
1619                 assert(pop_ctx->break_label);
1620                 break;
1621             }
1622         }
1623
1624         if(!pop_ctx) {
1625             WARN("Label not found\n");
1626             return JS_E_LABEL_NOT_FOUND;
1627         }
1628     }else {
1629         for(pop_ctx = ctx->stat_ctx; pop_ctx; pop_ctx = pop_ctx->next) {
1630             if(pop_ctx->break_label && !pop_ctx->labelled_stat)
1631                 break;
1632         }
1633
1634         if(!pop_ctx) {
1635             WARN("Break outside loop\n");
1636             return JS_E_INVALID_BREAK;
1637         }
1638     }
1639
1640     hres = pop_to_stat(ctx, pop_ctx->next);
1641     if(FAILED(hres))
1642         return hres;
1643
1644     return push_instr_uint(ctx, OP_jmp, pop_ctx->break_label);
1645 }
1646
1647 /* ECMA-262 3rd Edition    12.9 */
1648 static HRESULT compile_return_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1649 {
1650     HRESULT hres;
1651
1652     if(ctx->from_eval) {
1653         WARN("misplaced return statement\n");
1654         return JS_E_MISPLACED_RETURN;
1655     }
1656
1657     if(stat->expr) {
1658         hres = compile_expression(ctx, stat->expr, TRUE);
1659         if(FAILED(hres))
1660             return hres;
1661         if(!push_instr(ctx, OP_setret))
1662             return E_OUTOFMEMORY;
1663     }
1664
1665     hres = pop_to_stat(ctx, NULL);
1666     if(FAILED(hres))
1667         return hres;
1668
1669     return push_instr_uint(ctx, OP_ret, !stat->expr);
1670 }
1671
1672 /* ECMA-262 3rd Edition    12.10 */
1673 static HRESULT compile_with_statement(compiler_ctx_t *ctx, with_statement_t *stat)
1674 {
1675     statement_ctx_t stat_ctx = {0, TRUE, FALSE};
1676     HRESULT hres;
1677
1678     hres = compile_expression(ctx, stat->expr, TRUE);
1679     if(FAILED(hres))
1680         return hres;
1681
1682     if(!push_instr(ctx, OP_push_with_scope))
1683         return E_OUTOFMEMORY;
1684
1685     hres = compile_statement(ctx, &stat_ctx, stat->statement);
1686     if(FAILED(hres))
1687         return hres;
1688
1689     if(!push_instr(ctx, OP_pop_scope))
1690         return E_OUTOFMEMORY;
1691
1692     return S_OK;
1693 }
1694
1695 /* ECMA-262 3rd Edition    12.10 */
1696 static HRESULT compile_labelled_statement(compiler_ctx_t *ctx, labelled_statement_t *stat)
1697 {
1698     statement_ctx_t stat_ctx = {0, FALSE, FALSE, 0, 0, stat}, *iter;
1699     HRESULT hres;
1700
1701     for(iter = ctx->stat_ctx; iter; iter = iter->next) {
1702         if(iter->labelled_stat && !wcscmp(iter->labelled_stat->identifier, stat->identifier)) {
1703             WARN("Label %s redefined\n", debugstr_w(stat->identifier));
1704             return JS_E_LABEL_REDEFINED;
1705         }
1706     }
1707
1708     /* Labelled breaks are allowed for any labelled statements, not only loops (violating spec) */
1709     stat_ctx.break_label = alloc_label(ctx);
1710     if(!stat_ctx.break_label)
1711         return E_OUTOFMEMORY;
1712
1713     hres = compile_statement(ctx, &stat_ctx, stat->statement);
1714     if(FAILED(hres))
1715         return hres;
1716
1717     label_set_addr(ctx, stat_ctx.break_label);
1718     return S_OK;
1719 }
1720
1721 /* ECMA-262 3rd Edition    12.13 */
1722 static HRESULT compile_switch_statement(compiler_ctx_t *ctx, switch_statement_t *stat)
1723 {
1724     statement_ctx_t stat_ctx = {0, FALSE, FALSE};
1725     unsigned case_cnt = 0, *case_jmps, i, default_jmp;
1726     BOOL have_default = FALSE;
1727     statement_t *stat_iter;
1728     case_clausule_t *iter;
1729     HRESULT hres;
1730
1731     hres = compile_expression(ctx, stat->expr, TRUE);
1732     if(FAILED(hres))
1733         return hres;
1734
1735     stat_ctx.break_label = alloc_label(ctx);
1736     if(!stat_ctx.break_label)
1737         return E_OUTOFMEMORY;
1738
1739     for(iter = stat->case_list; iter; iter = iter->next) {
1740         if(iter->expr)
1741             case_cnt++;
1742     }
1743
1744     case_jmps = heap_alloc(case_cnt * sizeof(*case_jmps));
1745     if(!case_jmps)
1746         return E_OUTOFMEMORY;
1747
1748     i = 0;
1749     for(iter = stat->case_list; iter; iter = iter->next) {
1750         if(!iter->expr) {
1751             have_default = TRUE;
1752             continue;
1753         }
1754
1755         set_compiler_loc(ctx, iter->loc);
1756         hres = compile_expression(ctx, iter->expr, TRUE);
1757         if(FAILED(hres))
1758             break;
1759
1760         case_jmps[i] = push_instr(ctx, OP_case);
1761         if(!case_jmps[i]) {
1762             hres = E_OUTOFMEMORY;
1763             break;
1764         }
1765         i++;
1766     }
1767
1768     if(SUCCEEDED(hres)) {
1769         hres = push_instr_uint(ctx, OP_pop, 1);
1770         if(SUCCEEDED(hres)) {
1771             default_jmp = push_instr(ctx, OP_jmp);
1772             if(!default_jmp)
1773                 hres = E_OUTOFMEMORY;
1774         }
1775     }
1776
1777     if(FAILED(hres)) {
1778         heap_free(case_jmps);
1779         return hres;
1780     }
1781
1782     i = 0;
1783     for(iter = stat->case_list; iter; iter = iter->next) {
1784         while(iter->next && iter->next->stat == iter->stat) {
1785             set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);
1786             iter = iter->next;
1787         }
1788
1789         set_arg_uint(ctx, iter->expr ? case_jmps[i++] : default_jmp, ctx->code_off);
1790
1791         for(stat_iter = iter->stat; stat_iter && (!iter->next || iter->next->stat != stat_iter);
1792             stat_iter = stat_iter->next) {
1793             hres = compile_statement(ctx, &stat_ctx, stat_iter);
1794             if(FAILED(hres))
1795                 break;
1796         }
1797         if(FAILED(hres))
1798             break;
1799     }
1800
1801     heap_free(case_jmps);
1802     if(FAILED(hres))
1803         return hres;
1804     assert(i == case_cnt);
1805
1806     if(!have_default) {
1807         hres = push_instr_uint(ctx, OP_jmp, stat_ctx.break_label);
1808         if(FAILED(hres))
1809             return hres;
1810         set_arg_uint(ctx, default_jmp, ctx->code_off);
1811     }
1812
1813     label_set_addr(ctx, stat_ctx.break_label);
1814     return S_OK;
1815 }
1816
1817 /* ECMA-262 3rd Edition    12.13 */
1818 static HRESULT compile_throw_statement(compiler_ctx_t *ctx, expression_statement_t *stat)
1819 {
1820     HRESULT hres;
1821
1822     hres = compile_expression(ctx, stat->expr, TRUE);
1823     if(FAILED(hres))
1824         return hres;
1825
1826     return push_instr(ctx, OP_throw) ? S_OK : E_OUTOFMEMORY;
1827 }
1828
1829 /* ECMA-262 3rd Edition    12.14 */
1830 static HRESULT compile_try_statement(compiler_ctx_t *ctx, try_statement_t *stat)
1831 {
1832     statement_ctx_t try_ctx = {0, FALSE, TRUE}, finally_ctx = {2, FALSE, FALSE};
1833     unsigned push_except, finally_off = 0, catch_off = 0, pop_except, catch_pop_except = 0;
1834     BSTR ident;
1835     HRESULT hres;
1836
1837     push_except = push_instr(ctx, OP_push_except);
1838     if(!push_except)
1839         return E_OUTOFMEMORY;
1840
1841     if(stat->catch_block) {
1842         ident = compiler_alloc_bstr(ctx, stat->catch_block->identifier);
1843         if(!ident)
1844             return E_OUTOFMEMORY;
1845     }else {
1846         ident = NULL;
1847     }
1848
1849     hres = compile_statement(ctx, &try_ctx, stat->try_statement);
1850     if(FAILED(hres))
1851         return hres;
1852
1853     pop_except = push_instr(ctx, OP_pop_except);
1854     if(!pop_except)
1855         return E_OUTOFMEMORY;
1856
1857     if(stat->catch_block) {
1858         statement_ctx_t catch_ctx = {0, TRUE, stat->finally_statement != NULL};
1859
1860         if(stat->finally_statement)
1861             catch_ctx.using_except = TRUE;
1862
1863         catch_off = ctx->code_off;
1864
1865         hres = push_instr_bstr(ctx, OP_enter_catch, ident);
1866         if(FAILED(hres))
1867             return hres;
1868
1869         hres = compile_statement(ctx, &catch_ctx, stat->catch_block->statement);
1870         if(FAILED(hres))
1871             return hres;
1872
1873         if(!push_instr(ctx, OP_pop_scope))
1874             return E_OUTOFMEMORY;
1875
1876         if(stat->finally_statement) {
1877             catch_pop_except = push_instr(ctx, OP_pop_except);
1878             if(!catch_pop_except)
1879                 return E_OUTOFMEMORY;
1880         }
1881     }
1882
1883     if(stat->finally_statement) {
1884         /*
1885          * finally block expects two elements on the stack, which may be:
1886          * - (true, return_addr) set by OP_pop_except, OP_end_finally jumps back to passed address
1887          * - (false, exception_value) set when unwinding an exception, which OP_end_finally rethrows
1888          */
1889         finally_off = ctx->code_off;
1890         hres = compile_statement(ctx, &finally_ctx, stat->finally_statement);
1891         if(FAILED(hres))
1892             return hres;
1893
1894         set_compiler_loc(ctx, stat->finally_loc);
1895         if(!push_instr(ctx, OP_end_finally))
1896             return E_OUTOFMEMORY;
1897     }
1898
1899     instr_ptr(ctx, pop_except)->u.arg[0].uint = ctx->code_off;
1900     if(catch_pop_except)
1901         instr_ptr(ctx, catch_pop_except)->u.arg[0].uint = ctx->code_off;
1902     instr_ptr(ctx, push_except)->u.arg[0].uint = catch_off;
1903     instr_ptr(ctx, push_except)->u.arg[1].uint = finally_off;
1904     return S_OK;
1905 }
1906
1907 static HRESULT compile_statement(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
1908 {
1909     HRESULT hres;
1910
1911     push_compiler_statement_ctx(ctx, stat_ctx);
1912
1913     set_compiler_loc(ctx, stat->loc);
1914
1915     switch(stat->type) {
1916     case STAT_BLOCK:
1917         hres = compile_block_statement(ctx, (block_statement_t*)stat, ((block_statement_t*)stat)->stat_list);
1918         break;
1919     case STAT_BREAK:
1920         hres = compile_break_statement(ctx, (branch_statement_t*)stat);
1921         break;
1922     case STAT_CONTINUE:
1923         hres = compile_continue_statement(ctx, (branch_statement_t*)stat);
1924         break;
1925     case STAT_EMPTY:
1926         /* nothing to do */
1927         hres = S_OK;
1928         break;
1929     case STAT_EXPR:
1930         hres = compile_expression_statement(ctx, (expression_statement_t*)stat);
1931         break;
1932     case STAT_FOR:
1933         hres = compile_for_statement(ctx, (for_statement_t*)stat);
1934         break;
1935     case STAT_FORIN:
1936         hres = compile_forin_statement(ctx, (forin_statement_t*)stat);
1937         break;
1938     case STAT_IF:
1939         hres = compile_if_statement(ctx, (if_statement_t*)stat);
1940         break;
1941     case STAT_LABEL:
1942         hres = compile_labelled_statement(ctx, (labelled_statement_t*)stat);
1943         break;
1944     case STAT_RETURN:
1945         hres = compile_return_statement(ctx, (expression_statement_t*)stat);
1946         break;
1947     case STAT_SWITCH:
1948         hres = compile_switch_statement(ctx, (switch_statement_t*)stat);
1949         break;
1950     case STAT_THROW:
1951         hres = compile_throw_statement(ctx, (expression_statement_t*)stat);
1952         break;
1953     case STAT_TRY:
1954         hres = compile_try_statement(ctx, (try_statement_t*)stat);
1955         break;
1956     case STAT_VAR:
1957         hres = compile_var_statement(ctx, (var_statement_t*)stat);
1958         break;
1959     case STAT_WHILE:
1960         hres = compile_while_statement(ctx, (while_statement_t*)stat);
1961         break;
1962     case STAT_WITH:
1963         hres = compile_with_statement(ctx, (with_statement_t*)stat);
1964         break;
1965     DEFAULT_UNREACHABLE;
1966     }
1967
1968     pop_compiler_statement_ctx(ctx, stat_ctx);
1969
1970     return hres;
1971 }
1972
1973 static inline function_local_t *find_local(compiler_ctx_t *ctx, const WCHAR *name, unsigned int scope)
1974 {
1975     struct wine_rb_entry *entry = wine_rb_get(&ctx->local_scopes[scope].locals, name);
1976     return entry ? WINE_RB_ENTRY_VALUE(entry, function_local_t, entry) : NULL;
1977 }
1978
1979 static BOOL alloc_local(compiler_ctx_t *ctx, BSTR name, int ref, unsigned int scope)
1980 {
1981     function_local_t *local;
1982
1983     local = heap_pool_alloc(&ctx->heap, sizeof(*local));
1984     if(!local)
1985         return FALSE;
1986
1987     local->name = name;
1988     local->ref = ref;
1989     wine_rb_put(&ctx->local_scopes[scope].locals, name, &local->entry);
1990     ctx->local_scopes[scope].locals_cnt++;
1991     return TRUE;
1992 }
1993
1994 static BOOL alloc_variable(compiler_ctx_t *ctx, const WCHAR *name, unsigned int scope)
1995 {
1996     BSTR ident;
1997
1998     if(find_local(ctx, name, scope))
1999         return TRUE;
2000
2001     ident = compiler_alloc_bstr(ctx, name);
2002     if(!ident)
2003         return FALSE;
2004
2005     return alloc_local(ctx, ident, ctx->func->var_cnt++, scope);
2006 }
2007
2008 static HRESULT visit_function_expression(compiler_ctx_t *ctx, function_expression_t *expr)
2009 {
2010     statement_ctx_t *stat_ctx;
2011
2012     expr->func_id = ctx->func->func_cnt++;
2013     ctx->func_tail = ctx->func_tail ? (ctx->func_tail->next = expr) : (ctx->func_head = expr);
2014
2015     if(!expr->identifier || expr->event_target)
2016         return S_OK;
2017
2018     for (stat_ctx = ctx->stat_ctx; stat_ctx; stat_ctx = stat_ctx->next)
2019     {
2020         if (stat_ctx->block_scope)
2021         {
2022             stat_ctx->scope_has_functions = TRUE;
2023             break;
2024         }
2025     }
2026
2027     if(!expr->is_statement && ctx->parser->script->version >= SCRIPTLANGUAGEVERSION_ES5)
2028         return S_OK;
2029
2030     return alloc_variable(ctx, expr->identifier, stat_ctx ? stat_ctx->scope_index : 0) ? S_OK : E_OUTOFMEMORY;
2031 }
2032
2033 static HRESULT visit_expression(compiler_ctx_t *ctx, expression_t *expr)
2034 {
2035     HRESULT hres = S_OK;
2036
2037     switch(expr->type) {
2038     case EXPR_ADD:
2039     case EXPR_AND:
2040     case EXPR_ARRAY:
2041     case EXPR_ASSIGN:
2042     case EXPR_ASSIGNADD:
2043     case EXPR_ASSIGNAND:
2044     case EXPR_ASSIGNSUB:
2045     case EXPR_ASSIGNMUL:
2046     case EXPR_ASSIGNDIV:
2047     case EXPR_ASSIGNMOD:
2048     case EXPR_ASSIGNOR:
2049     case EXPR_ASSIGNLSHIFT:
2050     case EXPR_ASSIGNRSHIFT:
2051     case EXPR_ASSIGNRRSHIFT:
2052     case EXPR_ASSIGNXOR:
2053     case EXPR_BAND:
2054     case EXPR_BOR:
2055     case EXPR_COMMA:
2056     case EXPR_DIV:
2057     case EXPR_EQ:
2058     case EXPR_EQEQ:
2059     case EXPR_GREATER:
2060     case EXPR_GREATEREQ:
2061     case EXPR_IN:
2062     case EXPR_INSTANCEOF:
2063     case EXPR_LESS:
2064     case EXPR_LESSEQ:
2065     case EXPR_LSHIFT:
2066     case EXPR_MOD:
2067     case EXPR_MUL:
2068     case EXPR_NOTEQ:
2069     case EXPR_NOTEQEQ:
2070     case EXPR_OR:
2071     case EXPR_RSHIFT:
2072     case EXPR_RRSHIFT:
2073     case EXPR_SUB:
2074     case EXPR_BXOR: {
2075         binary_expression_t *binary_expr = (binary_expression_t*)expr;
2076
2077         hres = visit_expression(ctx, binary_expr->expression1);
2078         if(FAILED(hres))
2079             return hres;
2080
2081         hres = visit_expression(ctx, binary_expr->expression2);
2082         break;
2083     }
2084     case EXPR_BITNEG:
2085     case EXPR_DELETE:
2086     case EXPR_LOGNEG:
2087     case EXPR_MINUS:
2088     case EXPR_PLUS:
2089     case EXPR_POSTDEC:
2090     case EXPR_POSTINC:
2091     case EXPR_PREDEC:
2092     case EXPR_PREINC:
2093     case EXPR_TYPEOF:
2094     case EXPR_VOID:
2095         hres = visit_expression(ctx, ((unary_expression_t*)expr)->expression);
2096         break;
2097     case EXPR_IDENT:
2098     case EXPR_LITERAL:
2099     case EXPR_THIS:
2100         break;
2101     case EXPR_ARRAYLIT: {
2102         array_literal_expression_t *array_expr = (array_literal_expression_t*)expr;
2103         array_element_t *iter;
2104
2105         for(iter = array_expr->element_list; iter; iter = iter->next) {
2106             hres = visit_expression(ctx, iter->expr);
2107             if(FAILED(hres))
2108                 return hres;
2109         }
2110         break;
2111     }
2112     case EXPR_CALL:
2113     case EXPR_NEW: {
2114         call_expression_t *call_expr = (call_expression_t*)expr;
2115         argument_t *arg;
2116
2117         hres = visit_expression(ctx, call_expr->expression);
2118         if(FAILED(hres))
2119             return hres;
2120
2121         for(arg = call_expr->argument_list; arg; arg = arg->next) {
2122             hres = visit_expression(ctx, arg->expr);
2123             if(FAILED(hres))
2124                 return hres;
2125         }
2126         break;
2127     }
2128     case EXPR_COND: {
2129         conditional_expression_t *cond_expr = (conditional_expression_t*)expr;
2130
2131         hres = visit_expression(ctx, cond_expr->expression);
2132         if(FAILED(hres))
2133             return hres;
2134
2135         hres = visit_expression(ctx, cond_expr->true_expression);
2136         if(FAILED(hres))
2137             return hres;
2138
2139         hres = visit_expression(ctx, cond_expr->false_expression);
2140         break;
2141     }
2142     case EXPR_FUNC:
2143         hres = visit_function_expression(ctx, (function_expression_t*)expr);
2144         break;
2145     case EXPR_MEMBER:
2146         hres = visit_expression(ctx, ((member_expression_t*)expr)->expression);
2147         break;
2148     case EXPR_PROPVAL: {
2149         property_definition_t *iter;
2150         for(iter = ((property_value_expression_t*)expr)->property_list; iter; iter = iter->next) {
2151             hres = visit_expression(ctx, iter->value);
2152             if(FAILED(hres))
2153                 return hres;
2154         }
2155         break;
2156     }
2157     DEFAULT_UNREACHABLE;
2158     }
2159
2160     return hres;
2161 }
2162
2163 static HRESULT visit_variable_list(compiler_ctx_t *ctx, variable_declaration_t *list)
2164 {
2165     variable_declaration_t *iter;
2166     statement_ctx_t *stat_ctx;
2167     HRESULT hres;
2168
2169     for(iter = list; iter; iter = iter->next) {
2170         for (stat_ctx = ctx->stat_ctx; stat_ctx; stat_ctx = stat_ctx->next)
2171         {
2172             if (stat_ctx->block_scope)
2173                 break;
2174         }
2175
2176         if(!alloc_variable(ctx, iter->identifier, iter->block_scope && stat_ctx ? stat_ctx->scope_index : 0))
2177                 return E_OUTOFMEMORY;
2178
2179         if(iter->expr) {
2180             hres = visit_expression(ctx, iter->expr);
2181             if(FAILED(hres))
2182                 return hres;
2183         }
2184     }
2185
2186     return S_OK;
2187 }
2188
2189 static HRESULT visit_statement(compiler_ctx_t*,statement_ctx_t *,statement_t*);
2190
2191 static HRESULT visit_block_statement(compiler_ctx_t *ctx, block_statement_t *block, statement_t *iter)
2192 {
2193     statement_ctx_t stat_ctx = {0, TRUE};
2194     BOOL needs_scope;
2195     HRESULT hres;
2196
2197     needs_scope = block && ctx->parser->script->version >= SCRIPTLANGUAGEVERSION_ES5;
2198     if (needs_scope)
2199     {
2200         if (!alloc_local_scope(ctx, &block->scope_index))
2201             return E_OUTOFMEMORY;
2202
2203         stat_ctx.scope_index = block->scope_index;
2204         stat_ctx.block_scope = TRUE;
2205     }
2206
2207     while(iter) {
2208         hres = visit_statement(ctx, needs_scope ? &stat_ctx : NULL, iter);
2209         if(FAILED(hres))
2210             return hres;
2211
2212         iter = iter->next;
2213     }
2214
2215     if (needs_scope && !(ctx->local_scopes[stat_ctx.scope_index].locals_cnt || stat_ctx.scope_has_functions))
2216         remove_local_scope(ctx, block->scope_index);
2217
2218     return S_OK;
2219 }
2220
2221 static HRESULT visit_statement(compiler_ctx_t *ctx, statement_ctx_t *stat_ctx, statement_t *stat)
2222 {
2223     HRESULT hres = S_OK;
2224
2225     push_compiler_statement_ctx(ctx, stat_ctx);
2226
2227     switch(stat->type) {
2228     case STAT_BLOCK:
2229         hres = visit_block_statement(ctx, (block_statement_t*)stat, ((block_statement_t*)stat)->stat_list);
2230         break;
2231     case STAT_BREAK:
2232     case STAT_CONTINUE:
2233     case STAT_EMPTY:
2234         break;
2235     case STAT_EXPR: {
2236         expression_statement_t *expr_stat = (expression_statement_t*)stat;
2237         if(expr_stat->expr) {
2238             if(expr_stat->expr->type == EXPR_FUNC)
2239                 ((function_expression_t*)expr_stat->expr)->is_statement = TRUE;
2240             hres = visit_expression(ctx, expr_stat->expr);
2241         }
2242         break;
2243     }
2244     case STAT_RETURN:
2245     case STAT_THROW: {
2246         expression_statement_t *expr_stat = (expression_statement_t*)stat;
2247         if(expr_stat->expr)
2248             hres = visit_expression(ctx, expr_stat->expr);
2249         break;
2250     }
2251     case STAT_FOR: {
2252         statement_ctx_t stat_ctx_data = {0, TRUE}, *stat_ctx = NULL;
2253         for_statement_t *for_stat = (for_statement_t*)stat;
2254
2255         if(for_stat->variable_list)
2256         {
2257             variable_declaration_t *var;
2258
2259             for(var = for_stat->variable_list; var; var = var->next)
2260             {
2261                 if (var->block_scope)
2262                 {
2263                     stat_ctx = &stat_ctx_data;
2264                     break;
2265                 }
2266             }
2267
2268             if (stat_ctx)
2269             {
2270                 if (!alloc_local_scope(ctx, &for_stat->scope_index))
2271                 {
2272                     hres = E_OUTOFMEMORY;
2273                     break;
2274                 }
2275                 stat_ctx->scope_index = for_stat->scope_index;
2276                 stat_ctx->block_scope = TRUE;
2277                 push_compiler_statement_ctx(ctx, stat_ctx);
2278             }
2279             hres = visit_variable_list(ctx, for_stat->variable_list);
2280         }
2281         else if(for_stat->begin_expr)
2282             hres = visit_expression(ctx, for_stat->begin_expr);
2283         if(FAILED(hres))
2284         {
2285             pop_compiler_statement_ctx(ctx, stat_ctx);
2286             break;
2287         }
2288
2289         if(for_stat->expr) {
2290             hres = visit_expression(ctx, for_stat->expr);
2291             if(FAILED(hres))
2292             {
2293                 pop_compiler_statement_ctx(ctx, stat_ctx);
2294                 break;
2295             }
2296         }
2297
2298         hres = visit_statement(ctx, NULL, for_stat->statement);
2299         if(FAILED(hres))
2300         {
2301             pop_compiler_statement_ctx(ctx, stat_ctx);
2302             break;
2303         }
2304         if(for_stat->end_expr)
2305             hres = visit_expression(ctx, for_stat->end_expr);
2306         pop_compiler_statement_ctx(ctx, stat_ctx);
2307         break;
2308     }
2309     case STAT_FORIN:  {
2310         forin_statement_t *forin_stat = (forin_statement_t*)stat;
2311
2312         if(forin_stat->variable) {
2313             hres = visit_variable_list(ctx, forin_stat->variable);
2314             if(FAILED(hres))
2315                 break;
2316         }
2317
2318         hres = visit_expression(ctx, forin_stat->in_expr);
2319         if(FAILED(hres))
2320             return hres;
2321
2322         if(forin_stat->expr) {
2323             hres = visit_expression(ctx, forin_stat->expr);
2324             if(FAILED(hres))
2325                 return hres;
2326         }
2327
2328         hres = visit_statement(ctx, NULL, forin_stat->statement);
2329         break;
2330     }
2331     case STAT_IF: {
2332         if_statement_t *if_stat = (if_statement_t*)stat;
2333
2334         hres = visit_expression(ctx, if_stat->expr);
2335         if(FAILED(hres))
2336             return hres;
2337
2338         hres = visit_statement(ctx, NULL, if_stat->if_stat);
2339         if(FAILED(hres))
2340             return hres;
2341
2342         if(if_stat->else_stat)
2343             hres = visit_statement(ctx, NULL, if_stat->else_stat);
2344         break;
2345     }
2346     case STAT_LABEL:
2347         hres = visit_statement(ctx, NULL, ((labelled_statement_t*)stat)->statement);
2348         break;
2349     case STAT_SWITCH: {
2350         switch_statement_t *switch_stat = (switch_statement_t*)stat;
2351         statement_t *stat_iter;
2352         case_clausule_t *iter;
2353
2354         hres = visit_expression(ctx, switch_stat->expr);
2355         if(FAILED(hres))
2356             return hres;
2357
2358         for(iter = switch_stat->case_list; iter; iter = iter->next) {
2359             if(!iter->expr)
2360                 continue;
2361             hres = visit_expression(ctx, iter->expr);
2362             if(FAILED(hres))
2363                 return hres;
2364         }
2365
2366         for(iter = switch_stat->case_list; iter; iter = iter->next) {
2367             while(iter->next && iter->next->stat == iter->stat)
2368                 iter = iter->next;
2369             for(stat_iter = iter->stat; stat_iter && (!iter->next || iter->next->stat != stat_iter);
2370                 stat_iter = stat_iter->next) {
2371                 hres = visit_statement(ctx, NULL, stat_iter);
2372                 if(FAILED(hres))
2373                     return hres;
2374             }
2375         }
2376         break;
2377     }
2378     case STAT_TRY: {
2379         try_statement_t *try_stat = (try_statement_t*)stat;
2380
2381         hres = visit_statement(ctx, NULL, try_stat->try_statement);
2382         if(FAILED(hres))
2383             return hres;
2384
2385         if(try_stat->catch_block) {
2386             hres = visit_statement(ctx, NULL, try_stat->catch_block->statement);
2387             if(FAILED(hres))
2388                 return hres;
2389         }
2390
2391         if(try_stat->finally_statement)
2392             hres = visit_statement(ctx, NULL, try_stat->finally_statement);
2393         break;
2394     }
2395     case STAT_VAR:
2396         hres = visit_variable_list(ctx, ((var_statement_t*)stat)->variable_list);
2397         break;
2398     case STAT_WHILE: {
2399         while_statement_t *while_stat = (while_statement_t*)stat;
2400
2401         hres = visit_expression(ctx, while_stat->expr);
2402         if(FAILED(hres))
2403             return hres;
2404
2405         hres = visit_statement(ctx, NULL, while_stat->statement);
2406         break;
2407     }
2408     case STAT_WITH: {
2409         with_statement_t *with_stat = (with_statement_t*)stat;
2410
2411         hres = visit_expression(ctx, with_stat->expr);
2412         if(FAILED(hres))
2413             return hres;
2414
2415         hres = visit_statement(ctx, NULL, with_stat->statement);
2416         break;
2417     }
2418     DEFAULT_UNREACHABLE;
2419     }
2420
2421     pop_compiler_statement_ctx(ctx, stat_ctx);
2422
2423     return hres;
2424 }
2425
2426 static void resolve_labels(compiler_ctx_t *ctx, unsigned off)
2427 {
2428     instr_t *instr;
2429
2430     for(instr = ctx->code->instrs+off; instr < ctx->code->instrs+ctx->code_off; instr++) {
2431         if(instr_info[instr->op].arg1_type == ARG_ADDR && (instr->u.arg->uint & LABEL_FLAG)) {
2432             assert((instr->u.arg->uint & ~LABEL_FLAG) < ctx->labels_cnt);
2433             instr->u.arg->uint = ctx->labels[instr->u.arg->uint & ~LABEL_FLAG];
2434         }
2435         assert(instr_info[instr->op].arg2_type != ARG_ADDR);
2436     }
2437
2438     ctx->labels_cnt = 0;
2439 }
2440
2441 unsigned get_location_line(bytecode_t *code, unsigned loc, unsigned *char_pos)
2442 {
2443     unsigned line = code->start_line;
2444     const WCHAR *nl, *p;
2445
2446     for(nl = p = code->source; p < code->source + loc; p++) {
2447         if(*p != '\n') continue;
2448         line++;
2449         nl = p + 1;
2450     }
2451     *char_pos = loc - (nl - code->source);
2452     return line;
2453 }
2454
2455 void release_bytecode(bytecode_t *code)
2456 {
2457     unsigned i;
2458
2459     if(--code->ref)
2460         return;
2461
2462     for(i=0; i < code->bstr_cnt; i++)
2463         SysFreeString(code->bstr_pool[i]);
2464     for(i=0; i < code->str_cnt; i++)
2465         jsstr_release(code->str_pool[i]);
2466
2467     if(code->named_item)
2468         release_named_item(code->named_item);
2469     heap_free(code->source);
2470     heap_pool_free(&code->heap);
2471     heap_free(code->bstr_pool);
2472     heap_free(code->str_pool);
2473     heap_free(code->instrs);
2474     heap_free(code);
2475 }
2476
2477 static HRESULT init_code(compiler_ctx_t *compiler, const WCHAR *source, UINT64 source_context, unsigned start_line)
2478 {
2479     size_t len = source ? lstrlenW(source) : 0;
2480
2481     if(len > INT32_MAX)
2482         return E_OUTOFMEMORY;
2483
2484     compiler->code = heap_alloc_zero(sizeof(bytecode_t));
2485     if(!compiler->code)
2486         return E_OUTOFMEMORY;
2487
2488     compiler->code->ref = 1;
2489     compiler->code->source_context = source_context;
2490     compiler->code->start_line = start_line;
2491     heap_pool_init(&compiler->code->heap);
2492
2493     compiler->code->source = heap_alloc((len + 1) * sizeof(WCHAR));
2494     if(!compiler->code->source) {
2495         release_bytecode(compiler->code);
2496         return E_OUTOFMEMORY;
2497     }
2498     if(len)
2499         memcpy(compiler->code->source, source, len * sizeof(WCHAR));
2500     compiler->code->source[len] = 0;
2501
2502     compiler->code->instrs = heap_alloc(64 * sizeof(instr_t));
2503     if(!compiler->code->instrs) {
2504         release_bytecode(compiler->code);
2505         return E_OUTOFMEMORY;
2506     }
2507
2508     compiler->code_size = 64;
2509     compiler->code_off = 1;
2510     return S_OK;
2511 }
2512
2513 static HRESULT compile_function(compiler_ctx_t *ctx, statement_t *source, function_expression_t *func_expr,
2514         BOOL from_eval, function_code_t *func)
2515 {
2516     function_expression_t *iter;
2517     function_local_t *local;
2518     unsigned off, i, scope;
2519     HRESULT hres;
2520
2521     TRACE("\n");
2522
2523     func->bytecode = ctx->code;
2524     func->local_ref = INVALID_LOCAL_REF;
2525     func->scope_index = 0;
2526     ctx->func_head = ctx->func_tail = NULL;
2527     ctx->from_eval = from_eval;
2528     ctx->func = func;
2529     ctx->local_scope_count = 0;
2530     if (!alloc_local_scope(ctx, &scope))
2531         return E_OUTOFMEMORY;
2532     assert(!scope);
2533
2534     if(func_expr) {
2535         parameter_t *param_iter;
2536
2537         if(func_expr->identifier) {
2538             func->name = compiler_alloc_bstr(ctx, func_expr->identifier);
2539             if(!func->name)
2540                 return E_OUTOFMEMORY;
2541         }
2542
2543         if(func_expr->event_target) {
2544             func->event_target = compiler_alloc_bstr(ctx, func_expr->event_target);
2545             if(!func->event_target)
2546                 return E_OUTOFMEMORY;
2547         }
2548
2549         func->source = func_expr->src_str;
2550         func->source_len = func_expr->src_len;
2551
2552         for(param_iter = func_expr->parameter_list; param_iter; param_iter = param_iter->next)
2553             func->param_cnt++;
2554
2555         func->params = compiler_alloc(ctx->code, func->param_cnt * sizeof(*func->params));
2556         if(!func->params)
2557             return E_OUTOFMEMORY;
2558
2559         for(param_iter = func_expr->parameter_list, i=0; param_iter; param_iter = param_iter->next, i++) {
2560             func->params[i] = compiler_alloc_bstr(ctx, param_iter->identifier);
2561             if(!func->params[i])
2562                 return E_OUTOFMEMORY;
2563         }
2564     }
2565
2566     for(i = 0; i < func->param_cnt; i++) {
2567         if(!find_local(ctx, func->params[i], 0) && !alloc_local(ctx, func->params[i], -i-1, 0))
2568             return E_OUTOFMEMORY;
2569     }
2570
2571     hres = visit_block_statement(ctx, NULL, source);
2572     if(FAILED(hres))
2573         return hres;
2574
2575     func->local_scope_count = ctx->local_scope_count;
2576     func->local_scopes = compiler_alloc(ctx->code, func->local_scope_count * sizeof(*func->local_scopes));
2577     if(!func->local_scopes)
2578         return E_OUTOFMEMORY;
2579
2580     func->variables = compiler_alloc(ctx->code, func->var_cnt * sizeof(*func->variables));
2581     if(!func->variables)
2582         return E_OUTOFMEMORY;
2583
2584     for (scope = 0; scope < func->local_scope_count; ++scope)
2585     {
2586         func->local_scopes[scope].locals = compiler_alloc(ctx->code,
2587                 ctx->local_scopes[scope].locals_cnt * sizeof(*func->local_scopes[scope].locals));
2588         if(!func->local_scopes[scope].locals)
2589             return E_OUTOFMEMORY;
2590         func->local_scopes[scope].locals_cnt = ctx->local_scopes[scope].locals_cnt;
2591
2592         i = 0;
2593         WINE_RB_FOR_EACH_ENTRY(local, &ctx->local_scopes[scope].locals, function_local_t, entry) {
2594             func->local_scopes[scope].locals[i].name = local->name;
2595             func->local_scopes[scope].locals[i].ref = local->ref;
2596             if(local->ref >= 0) {
2597                 func->variables[local->ref].name = local->name;
2598                 func->variables[local->ref].func_id = -1;
2599             }
2600             i++;
2601         }
2602         assert(i == ctx->local_scopes[scope].locals_cnt);
2603     }
2604
2605     func->funcs = compiler_alloc(ctx->code, func->func_cnt * sizeof(*func->funcs));
2606     if(!func->funcs)
2607         return E_OUTOFMEMORY;
2608     memset(func->funcs, 0, func->func_cnt * sizeof(*func->funcs));
2609
2610     ctx->current_function_expr = ctx->func_head;
2611     off = ctx->code_off;
2612     hres = compile_block_statement(ctx, NULL, source);
2613     if(FAILED(hres))
2614         return hres;
2615
2616     resolve_labels(ctx, off);
2617
2618     hres = push_instr_uint(ctx, OP_ret, !from_eval);
2619     if(FAILED(hres))
2620         return hres;
2621
2622     if(TRACE_ON(jscript_disas))
2623         dump_code(ctx, off);
2624
2625     func->instr_off = off;
2626
2627     for(iter = ctx->func_head, i=0; iter; iter = iter->next, i++) {
2628         hres = compile_function(ctx, iter->statement_list, iter, FALSE, func->funcs+i);
2629         if(FAILED(hres))
2630             return hres;
2631
2632         func->funcs[i].scope_index = iter->scope_index;
2633
2634         TRACE("[%d] func %s, scope_index %u\n", i, debugstr_w(func->funcs[i].name), iter->scope_index);
2635         if((ctx->parser->script->version < SCRIPTLANGUAGEVERSION_ES5 || iter->is_statement) &&
2636            func->funcs[i].name && !func->funcs[i].event_target) {
2637             local_ref_t *local_ref = lookup_local(func, func->funcs[i].name, func->funcs[i].scope_index);
2638
2639             func->funcs[i].local_ref = local_ref->ref;
2640             TRACE("found ref %s %d for %s\n", debugstr_w(local_ref->name), local_ref->ref, debugstr_w(func->funcs[i].name));
2641             if(local_ref->ref >= 0)
2642                 func->variables[local_ref->ref].func_id = i;
2643         }
2644     }
2645
2646     assert(i == func->func_cnt);
2647
2648     return S_OK;
2649 }
2650
2651 static HRESULT parse_arguments(compiler_ctx_t *ctx, const WCHAR *args, BSTR *arg_array, unsigned *args_size)
2652 {
2653     const WCHAR *ptr = args, *ptr2;
2654     unsigned arg_cnt = 0;
2655
2656     while(iswspace(*ptr))
2657         ptr++;
2658     if(!*ptr) {
2659         if(args_size)
2660             *args_size = 0;
2661         return S_OK;
2662     }
2663
2664     while(1) {
2665         if(!iswalpha(*ptr) && *ptr != '_') {
2666             FIXME("expected alpha or '_': %s\n", debugstr_w(ptr));
2667             return E_FAIL;
2668         }
2669
2670         ptr2 = ptr;
2671         while(iswalnum(*ptr) || *ptr == '_')
2672             ptr++;
2673
2674         if(*ptr && *ptr != ',' && !iswspace(*ptr)) {
2675             FIXME("unexpected har %s\n", debugstr_w(ptr));
2676             return E_FAIL;
2677         }
2678
2679         if(arg_array) {
2680             arg_array[arg_cnt] = compiler_alloc_bstr_len(ctx, ptr2, ptr-ptr2);
2681             if(!arg_array[arg_cnt])
2682                 return E_OUTOFMEMORY;
2683         }
2684         arg_cnt++;
2685
2686         while(iswspace(*ptr))
2687             ptr++;
2688         if(!*ptr)
2689             break;
2690         if(*ptr != ',') {
2691             FIXME("expected ',': %s\n", debugstr_w(ptr));
2692             return E_FAIL;
2693         }
2694
2695         ptr++;
2696         while(iswspace(*ptr))
2697             ptr++;
2698     }
2699
2700     if(args_size)
2701         *args_size = arg_cnt;
2702     return S_OK;
2703 }
2704
2705 static HRESULT compile_arguments(compiler_ctx_t *ctx, const WCHAR *args)
2706 {
2707     HRESULT hres;
2708
2709     hres = parse_arguments(ctx, args, NULL, &ctx->code->global_code.param_cnt);
2710     if(FAILED(hres))
2711         return hres;
2712
2713     ctx->code->global_code.params = compiler_alloc(ctx->code,
2714             ctx->code->global_code.param_cnt * sizeof(*ctx->code->global_code.params));
2715     if(!ctx->code->global_code.params)
2716         return E_OUTOFMEMORY;
2717
2718     return parse_arguments(ctx, args, ctx->code->global_code.params, NULL);
2719 }
2720
2721 HRESULT compile_script(script_ctx_t *ctx, const WCHAR *code, UINT64 source_context, unsigned start_line,
2722                        const WCHAR *args, const WCHAR *delimiter, BOOL from_eval, BOOL use_decode,
2723                        named_item_t *named_item, bytecode_t **ret)
2724 {
2725     compiler_ctx_t compiler = {0};
2726     HRESULT hres;
2727
2728     hres = init_code(&compiler, code, source_context, start_line);
2729     if(FAILED(hres))
2730         return hres;
2731
2732     if(args) {
2733         hres = compile_arguments(&compiler, args);
2734         if(FAILED(hres))
2735             return hres;
2736     }
2737
2738     if(use_decode) {
2739         hres = decode_source(compiler.code->source);
2740         if(FAILED(hres)) {
2741             WARN("Decoding failed\n");
2742             return hres;
2743         }
2744     }
2745
2746     hres = script_parse(ctx, &compiler, compiler.code, delimiter, from_eval, &compiler.parser);
2747     if(FAILED(hres)) {
2748         release_bytecode(compiler.code);
2749         return hres;
2750     }
2751
2752     heap_pool_init(&compiler.heap);
2753     hres = compile_function(&compiler, compiler.parser->source, NULL, from_eval, &compiler.code->global_code);
2754     heap_free(compiler.local_scopes);
2755     heap_pool_free(&compiler.heap);
2756     parser_release(compiler.parser);
2757     if(FAILED(hres)) {
2758         if(hres != DISP_E_EXCEPTION)
2759             throw_error(ctx, hres, NULL);
2760         set_error_location(ctx->ei, compiler.code, compiler.loc, IDS_COMPILATION_ERROR, NULL);
2761         release_bytecode(compiler.code);
2762         return DISP_E_EXCEPTION;
2763     }
2764
2765     if(named_item) {
2766         compiler.code->named_item = named_item;
2767         named_item->ref++;
2768     }
2769
2770     *ret = compiler.code;
2771     return S_OK;
2772 }