git.oblomov.eu Git - wine/blob - 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
  25 #include "wine/debug.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  28
  29 struct _compiler_ctx_t {
  30     parser_ctx_t *parser;
  31     bytecode_t *code;
  32
  33     unsigned code_off;
  34     unsigned code_size;
  35 };
  36
  37 static HRESULT compile_expression(compiler_ctx_t*,expression_t*);
  38
  39 static inline void *compiler_alloc(bytecode_t *code, size_t size)
  40 {
  41     return jsheap_alloc(&code->heap, size);
  42 }
  43
  44 static WCHAR *compiler_alloc_string(bytecode_t *code, const WCHAR *str)
  45 {
  46     size_t size;
  47     WCHAR *ret;
  48
  49     size = (strlenW(str)+1)*sizeof(WCHAR);
  50     ret = compiler_alloc(code, size);
  51     if(ret)
  52         memcpy(ret, str, size);
  53     return ret;
  54 }
  55
  56 static BSTR compiler_alloc_bstr(compiler_ctx_t *ctx, const WCHAR *str)
  57 {
  58     if(!ctx->code->bstr_pool_size) {
  59         ctx->code->bstr_pool = heap_alloc(8 * sizeof(BSTR));
  60         if(!ctx->code->bstr_pool)
  61             return NULL;
  62         ctx->code->bstr_pool_size = 8;
  63     }else if(ctx->code->bstr_pool_size == ctx->code->bstr_cnt) {
  64         BSTR *new_pool;
  65
  66         new_pool = heap_realloc(ctx->code->bstr_pool, ctx->code->bstr_pool_size*2*sizeof(BSTR));
  67         if(!new_pool)
  68             return NULL;
  69
  70         ctx->code->bstr_pool = new_pool;
  71         ctx->code->bstr_pool_size *= 2;
  72     }
  73
  74     ctx->code->bstr_pool[ctx->code->bstr_cnt] = SysAllocString(str);
  75     if(!ctx->code->bstr_pool[ctx->code->bstr_cnt])
  76         return NULL;
  77
  78     return ctx->code->bstr_pool[ctx->code->bstr_cnt++];
  79 }
  80
  81 static unsigned push_instr(compiler_ctx_t *ctx, jsop_t op)
  82 {
  83     assert(ctx->code_size >= ctx->code_off);
  84
  85     if(!ctx->code_size) {
  86         ctx->code->instrs = heap_alloc(64 * sizeof(instr_t));
  87         if(!ctx->code->instrs)
  88             return -1;
  89         ctx->code_size = 64;
  90     }else if(ctx->code_size == ctx->code_off) {
  91         instr_t *new_instrs;
  92
  93         new_instrs = heap_realloc(ctx->code->instrs, ctx->code_size*2*sizeof(instr_t));
  94         if(!new_instrs)
  95             return -1;
  96
  97         ctx->code->instrs = new_instrs;
  98         ctx->code_size *= 2;
  99     }
 100
 101     ctx->code->instrs[ctx->code_off].op = op;
 102     return ctx->code_off++;
 103 }
 104
 105 static inline instr_t *instr_ptr(compiler_ctx_t *ctx, unsigned off)
 106 {
 107     assert(off < ctx->code_off);
 108     return ctx->code->instrs + off;
 109 }
 110
 111 static HRESULT push_instr_int(compiler_ctx_t *ctx, jsop_t op, LONG arg)
 112 {
 113     unsigned instr;
 114
 115     instr = push_instr(ctx, op);
 116     if(instr == -1)
 117         return E_OUTOFMEMORY;
 118
 119     instr_ptr(ctx, instr)->arg1.lng = arg;
 120     return S_OK;
 121 }
 122
 123 static HRESULT push_instr_str(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
 124 {
 125     unsigned instr;
 126     WCHAR *str;
 127
 128     str = compiler_alloc_string(ctx->code, arg);
 129     if(!str)
 130         return E_OUTOFMEMORY;
 131
 132     instr = push_instr(ctx, op);
 133     if(instr == -1)
 134         return E_OUTOFMEMORY;
 135
 136     instr_ptr(ctx, instr)->arg1.str = str;
 137     return S_OK;
 138 }
 139
 140 static HRESULT push_instr_bstr(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg)
 141 {
 142     unsigned instr;
 143     WCHAR *str;
 144
 145     str = compiler_alloc_bstr(ctx, arg);
 146     if(!str)
 147         return E_OUTOFMEMORY;
 148
 149     instr = push_instr(ctx, op);
 150     if(instr == -1)
 151         return E_OUTOFMEMORY;
 152
 153     instr_ptr(ctx, instr)->arg1.bstr = str;
 154     return S_OK;
 155 }
 156
 157 static HRESULT push_instr_bstr_uint(compiler_ctx_t *ctx, jsop_t op, const WCHAR *arg1, unsigned arg2)
 158 {
 159     unsigned instr;
 160     WCHAR *str;
 161
 162     str = compiler_alloc_bstr(ctx, arg1);
 163     if(!str)
 164         return E_OUTOFMEMORY;
 165
 166     instr = push_instr(ctx, op);
 167     if(instr == -1)
 168         return E_OUTOFMEMORY;
 169
 170     instr_ptr(ctx, instr)->arg1.bstr = str;
 171     instr_ptr(ctx, instr)->arg2.uint = arg2;
 172     return S_OK;
 173 }
 174
 175 static HRESULT push_instr_uint_str(compiler_ctx_t *ctx, jsop_t op, unsigned arg1, const WCHAR *arg2)
 176 {
 177     unsigned instr;
 178     WCHAR *str;
 179
 180     str = compiler_alloc_string(ctx->code, arg2);
 181     if(!str)
 182         return E_OUTOFMEMORY;
 183
 184     instr = push_instr(ctx, op);
 185     if(instr == -1)
 186         return E_OUTOFMEMORY;
 187
 188     instr_ptr(ctx, instr)->arg1.uint = arg1;
 189     instr_ptr(ctx, instr)->arg2.str = str;
 190     return S_OK;
 191 }
 192
 193 static HRESULT push_instr_double(compiler_ctx_t *ctx, jsop_t op, double arg)
 194 {
 195     unsigned instr;
 196     DOUBLE *dbl;
 197
 198     dbl = compiler_alloc(ctx->code, sizeof(arg));
 199     if(!dbl)
 200         return E_OUTOFMEMORY;
 201     *dbl = arg;
 202
 203     instr = push_instr(ctx, op);
 204     if(instr == -1)
 205         return E_OUTOFMEMORY;
 206
 207     instr_ptr(ctx, instr)->arg1.dbl = dbl;
 208     return S_OK;
 209 }
 210
 211 static HRESULT push_instr_uint(compiler_ctx_t *ctx, jsop_t op, unsigned arg)
 212 {
 213     unsigned instr;
 214
 215     instr = push_instr(ctx, op);
 216     if(instr == -1)
 217         return E_OUTOFMEMORY;
 218
 219     instr_ptr(ctx, instr)->arg1.uint = arg;
 220     return S_OK;
 221 }
 222
 223 static HRESULT compile_binary_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 224 {
 225     HRESULT hres;
 226
 227     hres = compile_expression(ctx, expr->expression1);
 228     if(FAILED(hres))
 229         return hres;
 230
 231     hres = compile_expression(ctx, expr->expression2);
 232     if(FAILED(hres))
 233         return hres;
 234
 235     return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
 236 }
 237
 238 static HRESULT compile_unary_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op)
 239 {
 240     HRESULT hres;
 241
 242     hres = compile_expression(ctx, expr->expression);
 243     if(FAILED(hres))
 244         return hres;
 245
 246     return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
 247 }
 248
 249 /* ECMA-262 3rd Edition    11.2.1 */
 250 static HRESULT compile_member_expression(compiler_ctx_t *ctx, member_expression_t *expr)
 251 {
 252     HRESULT hres;
 253
 254     hres = compile_expression(ctx, expr->expression);
 255     if(FAILED(hres))
 256         return hres;
 257
 258     return push_instr_bstr(ctx, OP_member, expr->identifier);
 259 }
 260
 261 static inline BOOL is_memberid_expr(expression_type_t type)
 262 {
 263     return type == EXPR_IDENT || type == EXPR_MEMBER || type == EXPR_ARRAY;
 264 }
 265
 266 static HRESULT compile_memberid_expression(compiler_ctx_t *ctx, expression_t *expr, unsigned flags)
 267 {
 268     HRESULT hres = S_OK;
 269
 270     switch(expr->type) {
 271     case EXPR_IDENT: {
 272         identifier_expression_t *ident_expr = (identifier_expression_t*)expr;
 273
 274         hres = push_instr_bstr_uint(ctx, OP_identid, ident_expr->identifier, flags);
 275         break;
 276     }
 277     case EXPR_ARRAY: {
 278         binary_expression_t *array_expr = (binary_expression_t*)expr;
 279
 280         hres = compile_expression(ctx, array_expr->expression1);
 281         if(FAILED(hres))
 282             return hres;
 283
 284         hres = compile_expression(ctx, array_expr->expression2);
 285         if(FAILED(hres))
 286             return hres;
 287
 288         hres = push_instr_uint(ctx, OP_memberid, flags);
 289         break;
 290     }
 291     case EXPR_MEMBER: {
 292         member_expression_t *member_expr = (member_expression_t*)expr;
 293
 294         hres = compile_expression(ctx, member_expr->expression);
 295         if(FAILED(hres))
 296             return hres;
 297
 298         /* FIXME: Potential optimization */
 299         hres = push_instr_str(ctx, OP_str, member_expr->identifier);
 300         if(FAILED(hres))
 301             return hres;
 302
 303         hres = push_instr_uint(ctx, OP_memberid, flags);
 304         break;
 305     }
 306     default:
 307         assert(0);
 308     }
 309
 310     return hres;
 311 }
 312
 313 static HRESULT compile_increment_expression(compiler_ctx_t *ctx, unary_expression_t *expr, jsop_t op, int n)
 314 {
 315     HRESULT hres;
 316
 317     if(!is_memberid_expr(expr->expression->type)) {
 318         hres = compile_expression(ctx, expr->expression);
 319         if(FAILED(hres))
 320             return hres;
 321
 322         return push_instr_uint(ctx, OP_throw, JS_E_ILLEGAL_ASSIGN);
 323     }
 324
 325     hres = compile_memberid_expression(ctx, expr->expression, fdexNameEnsure);
 326     if(FAILED(hres))
 327         return hres;
 328
 329     return push_instr_int(ctx, op, n);
 330 }
 331
 332 /* ECMA-262 3rd Edition    11.14 */
 333 static HRESULT compile_comma_expression(compiler_ctx_t *ctx, binary_expression_t *expr)
 334 {
 335     HRESULT hres;
 336
 337     hres = compile_expression(ctx, expr->expression1);
 338     if(FAILED(hres))
 339         return hres;
 340
 341     if(push_instr(ctx, OP_pop) == -1)
 342         return E_OUTOFMEMORY;
 343
 344     return compile_expression(ctx, expr->expression2);
 345 }
 346
 347 /* ECMA-262 3rd Edition    11.11 */
 348 static HRESULT compile_logical_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 349 {
 350     unsigned instr;
 351     HRESULT hres;
 352
 353     hres = compile_expression(ctx, expr->expression1);
 354     if(FAILED(hres))
 355         return hres;
 356
 357     instr = push_instr(ctx, op);
 358     if(instr == -1)
 359         return E_OUTOFMEMORY;
 360
 361     hres = compile_expression(ctx, expr->expression2);
 362     if(FAILED(hres))
 363         return hres;
 364
 365     instr_ptr(ctx, instr)->arg1.uint = ctx->code_off;
 366     return S_OK;
 367 }
 368
 369 /* ECMA-262 3rd Edition    11.12 */
 370 static HRESULT compile_conditional_expression(compiler_ctx_t *ctx, conditional_expression_t *expr)
 371 {
 372     unsigned jmp_false, jmp_end;
 373     HRESULT hres;
 374
 375     hres = compile_expression(ctx, expr->expression);
 376     if(FAILED(hres))
 377         return hres;
 378
 379     jmp_false = push_instr(ctx, OP_jmp_z);
 380     if(jmp_false == -1)
 381         return E_OUTOFMEMORY;
 382
 383     hres = compile_expression(ctx, expr->true_expression);
 384     if(FAILED(hres))
 385         return hres;
 386
 387     jmp_end = push_instr(ctx, OP_jmp);
 388     if(jmp_end == -1)
 389         return E_OUTOFMEMORY;
 390
 391     instr_ptr(ctx, jmp_false)->arg1.uint = ctx->code_off;
 392     if(push_instr(ctx, OP_pop) == -1)
 393         return E_OUTOFMEMORY;
 394
 395     hres = compile_expression(ctx, expr->false_expression);
 396     if(FAILED(hres))
 397         return hres;
 398
 399     instr_ptr(ctx, jmp_end)->arg1.uint = ctx->code_off;
 400     return S_OK;
 401 }
 402
 403 static HRESULT compile_new_expression(compiler_ctx_t *ctx, call_expression_t *expr)
 404 {
 405     unsigned arg_cnt = 0;
 406     argument_t *arg;
 407     HRESULT hres;
 408
 409     hres = compile_expression(ctx, expr->expression);
 410     if(FAILED(hres))
 411         return hres;
 412
 413     for(arg = expr->argument_list; arg; arg = arg->next) {
 414         hres = compile_expression(ctx, arg->expr);
 415         if(FAILED(hres))
 416             return hres;
 417         arg_cnt++;
 418     }
 419
 420     return push_instr_int(ctx, OP_new, arg_cnt);
 421 }
 422
 423 static HRESULT compile_interp_fallback(compiler_ctx_t *ctx, expression_t *expr)
 424 {
 425     unsigned instr;
 426
 427     instr = push_instr(ctx, OP_tree);
 428     if(instr == -1)
 429         return E_OUTOFMEMORY;
 430
 431     instr_ptr(ctx, instr)->arg1.expr = expr;
 432     return S_OK;
 433 }
 434
 435 static HRESULT compile_call_expression(compiler_ctx_t *ctx, call_expression_t *expr, BOOL *no_ret)
 436 {
 437     unsigned arg_cnt = 0;
 438     argument_t *arg;
 439     unsigned instr;
 440     jsop_t op;
 441     HRESULT hres;
 442
 443     if(is_memberid_expr(expr->expression->type)) {
 444         op = OP_call_member;
 445         hres = compile_memberid_expression(ctx, expr->expression, 0);
 446     }else {
 447         op = OP_call;
 448         hres = compile_expression(ctx, expr->expression);
 449     }
 450
 451     if(FAILED(hres))
 452         return hres;
 453
 454     for(arg = expr->argument_list; arg; arg = arg->next) {
 455         hres = compile_expression(ctx, arg->expr);
 456         if(FAILED(hres))
 457             return hres;
 458         arg_cnt++;
 459     }
 460
 461     instr = push_instr(ctx, op);
 462     if(instr == -1)
 463         return E_OUTOFMEMORY;
 464
 465     instr_ptr(ctx, instr)->arg1.uint = arg_cnt;
 466     instr_ptr(ctx, instr)->arg2.lng = no_ret == NULL;
 467     if(no_ret)
 468         *no_ret = TRUE;
 469     return S_OK;
 470 }
 471
 472 static HRESULT compile_delete_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
 473 {
 474     HRESULT hres;
 475
 476     switch(expr->expression->type) {
 477     case EXPR_ARRAY: {
 478         binary_expression_t *array_expr = (binary_expression_t*)expr->expression;
 479
 480         hres = compile_expression(ctx, array_expr->expression1);
 481         if(FAILED(hres))
 482             return hres;
 483
 484         hres = compile_expression(ctx, array_expr->expression2);
 485         if(FAILED(hres))
 486             return hres;
 487
 488         if(push_instr(ctx, OP_delete) == -1)
 489             return E_OUTOFMEMORY;
 490         break;
 491     }
 492     case EXPR_MEMBER: {
 493         member_expression_t *member_expr = (member_expression_t*)expr->expression;
 494
 495         hres = compile_expression(ctx, member_expr->expression);
 496         if(FAILED(hres))
 497             return hres;
 498
 499         /* FIXME: Potential optimization */
 500         hres = push_instr_str(ctx, OP_str, member_expr->identifier);
 501         if(FAILED(hres))
 502             return hres;
 503
 504         if(push_instr(ctx, OP_delete) == -1)
 505             return E_OUTOFMEMORY;
 506         break;
 507     }
 508     case EXPR_IDENT:
 509         return push_instr_bstr(ctx, OP_delete_ident, ((identifier_expression_t*)expr->expression)->identifier);
 510     default: {
 511         const WCHAR fixmeW[] = {'F','I','X','M','E',0};
 512
 513         WARN("invalid delete, unimplemented exception message\n");
 514
 515         hres = compile_expression(ctx, expr->expression);
 516         if(FAILED(hres))
 517             return hres;
 518
 519         return push_instr_uint_str(ctx, OP_throw_type, JS_E_INVALID_DELETE, fixmeW);
 520     }
 521     }
 522
 523     return S_OK;
 524 }
 525
 526 static HRESULT compile_assign_expression(compiler_ctx_t *ctx, binary_expression_t *expr, jsop_t op)
 527 {
 528     HRESULT hres;
 529
 530     if(!is_memberid_expr(expr->expression1->type)) {
 531         hres = compile_expression(ctx, expr->expression1);
 532         if(FAILED(hres))
 533             return hres;
 534
 535         hres = compile_expression(ctx, expr->expression2);
 536         if(FAILED(hres))
 537             return hres;
 538
 539         if(op != OP_LAST && push_instr(ctx, op) == -1)
 540             return E_OUTOFMEMORY;
 541
 542         return push_instr_uint(ctx, OP_throw, JS_E_ILLEGAL_ASSIGN);
 543     }
 544
 545     hres = compile_memberid_expression(ctx, expr->expression1, fdexNameEnsure);
 546     if(FAILED(hres))
 547         return hres;
 548
 549     if(op != OP_LAST && push_instr(ctx, OP_refval) == -1)
 550         return E_OUTOFMEMORY;
 551
 552     hres = compile_expression(ctx, expr->expression2);
 553     if(FAILED(hres))
 554         return hres;
 555
 556     if(op != OP_LAST && push_instr(ctx, op) == -1)
 557         return E_OUTOFMEMORY;
 558
 559     if(push_instr(ctx, OP_assign) == -1)
 560         return E_OUTOFMEMORY;
 561
 562     return S_OK;
 563 }
 564
 565 static HRESULT compile_typeof_expression(compiler_ctx_t *ctx, unary_expression_t *expr)
 566 {
 567     jsop_t op;
 568     HRESULT hres;
 569
 570     if(is_memberid_expr(expr->expression->type)) {
 571         if(expr->expression->type == EXPR_IDENT)
 572             return push_instr_str(ctx, OP_typeofident, ((identifier_expression_t*)expr->expression)->identifier);
 573
 574         op = OP_typeofid;
 575         hres = compile_memberid_expression(ctx, expr->expression, 0);
 576     }else {
 577         op = OP_typeof;
 578         hres = compile_expression(ctx, expr->expression);
 579     }
 580     if(FAILED(hres))
 581         return hres;
 582
 583     return push_instr(ctx, op) == -1 ? E_OUTOFMEMORY : S_OK;
 584 }
 585
 586 static HRESULT compile_literal(compiler_ctx_t *ctx, literal_t *literal)
 587 {
 588     switch(literal->type) {
 589     case LT_BOOL:
 590         return push_instr_int(ctx, OP_bool, literal->u.bval);
 591     case LT_DOUBLE:
 592         return push_instr_double(ctx, OP_double, literal->u.dval);
 593     case LT_INT:
 594         return push_instr_int(ctx, OP_int, literal->u.lval);
 595     case LT_NULL:
 596         return push_instr(ctx, OP_null);
 597     case LT_STRING:
 598         return push_instr_str(ctx, OP_str, literal->u.wstr);
 599     case LT_REGEXP: {
 600         unsigned instr;
 601         WCHAR *str;
 602
 603         str = compiler_alloc(ctx->code, (literal->u.regexp.str_len+1)*sizeof(WCHAR));
 604         if(!str)
 605             return E_OUTOFMEMORY;
 606         memcpy(str, literal->u.regexp.str, literal->u.regexp.str_len*sizeof(WCHAR));
 607         str[literal->u.regexp.str_len] = 0;
 608
 609         instr = push_instr(ctx, OP_regexp);
 610         if(instr == -1)
 611             return E_OUTOFMEMORY;
 612
 613         instr_ptr(ctx, instr)->arg1.str = str;
 614         instr_ptr(ctx, instr)->arg2.lng = literal->u.regexp.flags;
 615         return S_OK;
 616     }
 617     default:
 618         assert(0);
 619     }
 620 }
 621
 622 static HRESULT literal_as_bstr(compiler_ctx_t *ctx, literal_t *literal, BSTR *str)
 623 {
 624     switch(literal->type) {
 625     case LT_STRING:
 626         *str = compiler_alloc_bstr(ctx, literal->u.wstr);
 627         break;
 628     case LT_INT:
 629         *str = int_to_bstr(literal->u.lval);
 630         break;
 631     case LT_DOUBLE:
 632         return double_to_bstr(literal->u.dval, str);
 633     default:
 634         assert(0);
 635     }
 636
 637     return *str ? S_OK : E_OUTOFMEMORY;
 638 }
 639
 640 static HRESULT compile_array_literal(compiler_ctx_t *ctx, array_literal_expression_t *expr)
 641 {
 642     unsigned i, elem_cnt = expr->length;
 643     array_element_t *iter;
 644     HRESULT hres;
 645
 646     for(iter = expr->element_list; iter; iter = iter->next) {
 647         elem_cnt += iter->elision+1;
 648
 649         for(i=0; i < iter->elision; i++) {
 650             if(push_instr(ctx, OP_undefined) == -1)
 651                 return E_OUTOFMEMORY;
 652         }
 653
 654         hres = compile_expression(ctx, iter->expr);
 655         if(FAILED(hres))
 656             return hres;
 657     }
 658
 659     for(i=0; i < expr->length; i++) {
 660         if(push_instr(ctx, OP_undefined) == -1)
 661             return E_OUTOFMEMORY;
 662     }
 663
 664     return push_instr_uint(ctx, OP_carray, elem_cnt);
 665 }
 666
 667 static HRESULT compile_object_literal(compiler_ctx_t *ctx, property_value_expression_t *expr)
 668 {
 669     prop_val_t *iter;
 670     unsigned instr;
 671     BSTR name;
 672     HRESULT hres;
 673
 674     if(push_instr(ctx, OP_new_obj) == -1)
 675         return E_OUTOFMEMORY;
 676
 677     for(iter = expr->property_list; iter; iter = iter->next) {
 678         hres = literal_as_bstr(ctx, iter->name, &name);
 679         if(FAILED(hres))
 680             return hres;
 681
 682         hres = compile_expression(ctx, iter->value);
 683         if(FAILED(hres))
 684             return hres;
 685
 686         instr = push_instr(ctx, OP_obj_prop);
 687         if(instr == -1)
 688             return E_OUTOFMEMORY;
 689
 690         instr_ptr(ctx, instr)->arg1.bstr = name;
 691     }
 692
 693     return S_OK;
 694 }
 695
 696 static HRESULT compile_function_expression(compiler_ctx_t *ctx, function_expression_t *expr)
 697 {
 698     unsigned instr;
 699
 700     /* FIXME: not exactly right */
 701     if(expr->identifier)
 702         return push_instr_bstr(ctx, OP_ident, expr->identifier);
 703
 704     instr = push_instr(ctx, OP_func);
 705     if(instr == -1)
 706         return E_OUTOFMEMORY;
 707
 708     instr_ptr(ctx, instr)->arg1.func = expr;
 709     return S_OK;
 710 }
 711
 712 static HRESULT compile_expression_noret(compiler_ctx_t *ctx, expression_t *expr, BOOL *no_ret)
 713 {
 714     switch(expr->type) {
 715     case EXPR_ADD:
 716         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_add);
 717     case EXPR_AND:
 718         return compile_logical_expression(ctx, (binary_expression_t*)expr, OP_jmp_z);
 719     case EXPR_ARRAY:
 720         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_array);
 721     case EXPR_ARRAYLIT:
 722         return compile_array_literal(ctx, (array_literal_expression_t*)expr);
 723     case EXPR_ASSIGN:
 724         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_LAST);
 725     case EXPR_ASSIGNADD:
 726         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_add);
 727     case EXPR_ASSIGNAND:
 728         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_and);
 729     case EXPR_ASSIGNSUB:
 730         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_sub);
 731     case EXPR_ASSIGNMUL:
 732         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mul);
 733     case EXPR_ASSIGNDIV:
 734         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_div);
 735     case EXPR_ASSIGNMOD:
 736         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_mod);
 737     case EXPR_ASSIGNOR:
 738         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_or);
 739     case EXPR_ASSIGNLSHIFT:
 740         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_lshift);
 741     case EXPR_ASSIGNRSHIFT:
 742         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift);
 743     case EXPR_ASSIGNRRSHIFT:
 744         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
 745     case EXPR_ASSIGNXOR:
 746         return compile_assign_expression(ctx, (binary_expression_t*)expr, OP_xor);
 747     case EXPR_BAND:
 748         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_and);
 749     case EXPR_BITNEG:
 750         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_bneg);
 751     case EXPR_BOR:
 752         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_or);
 753     case EXPR_CALL:
 754         return compile_call_expression(ctx, (call_expression_t*)expr, no_ret);
 755     case EXPR_COMMA:
 756         return compile_comma_expression(ctx, (binary_expression_t*)expr);
 757     case EXPR_COND:
 758         return compile_conditional_expression(ctx, (conditional_expression_t*)expr);
 759     case EXPR_DELETE:
 760         return compile_delete_expression(ctx, (unary_expression_t*)expr);
 761     case EXPR_DIV:
 762         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_div);
 763     case EXPR_EQ:
 764         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq);
 765     case EXPR_EQEQ:
 766         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_eq2);
 767     case EXPR_FUNC:
 768         return compile_function_expression(ctx, (function_expression_t*)expr);
 769     case EXPR_GREATER:
 770         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gt);
 771     case EXPR_GREATEREQ:
 772         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_gteq);
 773     case EXPR_IDENT:
 774         return push_instr_bstr(ctx, OP_ident, ((identifier_expression_t*)expr)->identifier);
 775     case EXPR_IN:
 776         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_in);
 777     case EXPR_INSTANCEOF:
 778         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_instanceof);
 779     case EXPR_LESS:
 780         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lt);
 781     case EXPR_LESSEQ:
 782         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lteq);
 783     case EXPR_LITERAL:
 784         return compile_literal(ctx, ((literal_expression_t*)expr)->literal);
 785     case EXPR_LOGNEG:
 786         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_neg);
 787     case EXPR_LSHIFT:
 788         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_lshift);
 789     case EXPR_MEMBER:
 790         return compile_member_expression(ctx, (member_expression_t*)expr);
 791     case EXPR_MINUS:
 792         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_minus);
 793     case EXPR_MOD:
 794         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mod);
 795     case EXPR_MUL:
 796         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_mul);
 797     case EXPR_NEW:
 798         return compile_new_expression(ctx, (call_expression_t*)expr);
 799     case EXPR_NOTEQ:
 800         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq);
 801     case EXPR_NOTEQEQ:
 802         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_neq2);
 803     case EXPR_OR:
 804         return compile_logical_expression(ctx, (binary_expression_t*)expr, OP_jmp_nz);
 805     case EXPR_PLUS:
 806         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_tonum);
 807     case EXPR_POSTDEC:
 808         return compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, -1);
 809     case EXPR_POSTINC:
 810         return compile_increment_expression(ctx, (unary_expression_t*)expr, OP_postinc, 1);
 811     case EXPR_PREDEC:
 812         return compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, -1);
 813     case EXPR_PREINC:
 814         return compile_increment_expression(ctx, (unary_expression_t*)expr, OP_preinc, 1);
 815     case EXPR_PROPVAL:
 816         return compile_object_literal(ctx, (property_value_expression_t*)expr);
 817     case EXPR_RSHIFT:
 818         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift);
 819     case EXPR_RRSHIFT:
 820         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_rshift2);
 821     case EXPR_SUB:
 822         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_sub);
 823     case EXPR_THIS:
 824         return push_instr(ctx, OP_this) == -1 ? E_OUTOFMEMORY : S_OK;
 825     case EXPR_TYPEOF:
 826         return compile_typeof_expression(ctx, (unary_expression_t*)expr);
 827     case EXPR_VOID:
 828         return compile_unary_expression(ctx, (unary_expression_t*)expr, OP_void);
 829     case EXPR_BXOR:
 830         return compile_binary_expression(ctx, (binary_expression_t*)expr, OP_xor);
 831     default:
 832         return compile_interp_fallback(ctx, expr);
 833     }
 834
 835     return S_OK;
 836 }
 837
 838 static HRESULT compile_expression(compiler_ctx_t *ctx, expression_t *expr)
 839 {
 840     return compile_expression_noret(ctx, expr, NULL);
 841 }
 842
 843 void release_bytecode(bytecode_t *code)
 844 {
 845     unsigned i;
 846
 847     for(i=0; i < code->bstr_cnt; i++)
 848         SysFreeString(code->bstr_pool[i]);
 849
 850     jsheap_free(&code->heap);
 851     heap_free(code->bstr_pool);
 852     heap_free(code->instrs);
 853     heap_free(code);
 854 }
 855
 856 void release_compiler(compiler_ctx_t *ctx)
 857 {
 858     heap_free(ctx);
 859 }
 860
 861 HRESULT compile_subscript(parser_ctx_t *parser, expression_t *expr, BOOL do_ret, unsigned *ret_off)
 862 {
 863     BOOL no_ret = FALSE;
 864     HRESULT hres;
 865
 866     if(!parser->code) {
 867         parser->code = heap_alloc_zero(sizeof(bytecode_t));
 868         if(!parser->code)
 869             return E_OUTOFMEMORY;
 870         jsheap_init(&parser->code->heap);
 871     }
 872
 873     if(!parser->compiler) {
 874         parser->compiler = heap_alloc_zero(sizeof(compiler_ctx_t));
 875         if(!parser->compiler)
 876             return E_OUTOFMEMORY;
 877
 878         parser->compiler->parser = parser;
 879         parser->compiler->code = parser->code;
 880     }
 881
 882     *ret_off = parser->compiler->code_off;
 883     hres = compile_expression_noret(parser->compiler, expr, do_ret ? NULL : &no_ret);
 884     if(FAILED(hres))
 885         return hres;
 886
 887     return push_instr(parser->compiler, OP_ret) == -1 ? E_OUTOFMEMORY : S_OK;
 888 }