/* * Copyright (C) 2020-2021 Jo-Philipp Wich * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include "ucode/compiler.h" #include "ucode/chunk.h" #include "ucode/vm.h" /* I_* */ #include "ucode/source.h" #include "ucode/program.h" #include "ucode/lib.h" /* uc_error_context_format() */ #ifndef NO_COMPILE static void uc_compiler_compile_unary(uc_compiler_t *compiler); static void uc_compiler_compile_binary(uc_compiler_t *compiler); static void uc_compiler_compile_delete(uc_compiler_t *compiler); static void uc_compiler_compile_paren(uc_compiler_t *compiler); static void uc_compiler_compile_call(uc_compiler_t *compiler); static void uc_compiler_compile_post_inc(uc_compiler_t *compiler); static void uc_compiler_compile_constant(uc_compiler_t *compiler); static void uc_compiler_compile_comma(uc_compiler_t *compiler); static void uc_compiler_compile_labelexpr(uc_compiler_t *compiler); static void uc_compiler_compile_function(uc_compiler_t *compiler); static void uc_compiler_compile_and(uc_compiler_t *compiler); static void uc_compiler_compile_or(uc_compiler_t *compiler); static void uc_compiler_compile_dot(uc_compiler_t *compiler); static void uc_compiler_compile_subscript(uc_compiler_t *compiler); static void uc_compiler_compile_ternary(uc_compiler_t *compiler); static void uc_compiler_compile_array(uc_compiler_t *compiler); static void uc_compiler_compile_object(uc_compiler_t *compiler); static void uc_compiler_compile_declaration(uc_compiler_t *compiler); static void uc_compiler_compile_statement(uc_compiler_t *compiler); static void uc_compiler_compile_expstmt(uc_compiler_t *compiler); static uc_parse_rule_t uc_compiler_parse_rules[TK_ERROR + 1] = { [TK_LPAREN] = { uc_compiler_compile_paren, uc_compiler_compile_call, P_CALL }, [TK_QLPAREN] = { NULL, uc_compiler_compile_call, P_CALL }, [TK_SUB] = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD }, [TK_ADD] = { uc_compiler_compile_unary, uc_compiler_compile_binary, P_ADD }, [TK_COMPL] = { uc_compiler_compile_unary, NULL, P_UNARY }, [TK_NOT] = { uc_compiler_compile_unary, NULL, P_UNARY }, [TK_DELETE] = { uc_compiler_compile_delete, NULL, P_UNARY }, [TK_INC] = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC }, [TK_DEC] = { uc_compiler_compile_unary, uc_compiler_compile_post_inc, P_INC }, [TK_DIV] = { NULL, uc_compiler_compile_binary, P_MUL }, [TK_MUL] = { NULL, uc_compiler_compile_binary, P_MUL }, [TK_MOD] = { NULL, uc_compiler_compile_binary, P_MUL }, [TK_NUMBER] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_DOUBLE] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_STRING] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_TRUE] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_FALSE] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_NULL] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_THIS] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_REGEXP] = { uc_compiler_compile_constant, NULL, P_NONE }, [TK_COMMA] = { NULL, uc_compiler_compile_comma, P_COMMA }, [TK_LABEL] = { uc_compiler_compile_labelexpr, NULL, P_NONE }, [TK_FUNC] = { uc_compiler_compile_function, NULL, P_NONE }, [TK_AND] = { NULL, uc_compiler_compile_and, P_AND }, [TK_OR] = { NULL, uc_compiler_compile_or, P_OR }, [TK_BOR] = { NULL, uc_compiler_compile_binary, P_BOR }, [TK_BXOR] = { NULL, uc_compiler_compile_binary, P_BXOR }, [TK_BAND] = { NULL, uc_compiler_compile_binary, P_BAND }, [TK_EQ] = { NULL, uc_compiler_compile_binary, P_EQUAL }, [TK_EQS] = { NULL, uc_compiler_compile_binary, P_EQUAL }, [TK_NE] = { NULL, uc_compiler_compile_binary, P_EQUAL }, [TK_NES] = { NULL, uc_compiler_compile_binary, P_EQUAL }, [TK_LT] = { NULL, uc_compiler_compile_binary, P_COMPARE }, [TK_LE] = { NULL, uc_compiler_compile_binary, P_COMPARE }, [TK_GT] = { NULL, uc_compiler_compile_binary, P_COMPARE }, [TK_GE] = { NULL, uc_compiler_compile_binary, P_COMPARE }, [TK_IN] = { NULL, uc_compiler_compile_binary, P_COMPARE }, [TK_LSHIFT] = { NULL, uc_compiler_compile_binary, P_SHIFT }, [TK_RSHIFT] = { NULL, uc_compiler_compile_binary, P_SHIFT }, [TK_DOT] = { NULL, uc_compiler_compile_dot, P_CALL }, [TK_QDOT] = { NULL, uc_compiler_compile_dot, P_CALL }, [TK_LBRACK] = { uc_compiler_compile_array, uc_compiler_compile_subscript, P_CALL }, [TK_QLBRACK] = { NULL, uc_compiler_compile_subscript, P_CALL }, [TK_QMARK] = { NULL, uc_compiler_compile_ternary, P_TERNARY }, [TK_LBRACE] = { uc_compiler_compile_object, NULL, P_NONE }, }; static ssize_t uc_compiler_declare_local(uc_compiler_t *compiler, uc_value_t *name, bool constant); static ssize_t uc_compiler_initialize_local(uc_compiler_t *compiler); static bool uc_compiler_exprstack_is(uc_compiler_t *compiler, uc_exprflag_t flag) { uc_exprstack_t *expr; for (expr = compiler->exprstack; expr; expr = expr->parent) if (expr->flags & flag) return true; return false; } static void uc_compiler_init(uc_compiler_t *compiler, const char *name, size_t srcpos, uc_program_t *program, bool strict) { uc_value_t *varname = ucv_string_new("(callee)"); uc_function_t *fn; compiler->scope_depth = 0; compiler->program = program; compiler->function = uc_program_function_new(program, name, srcpos); compiler->locals.count = 0; compiler->locals.entries = NULL; compiler->upvals.count = 0; compiler->upvals.entries = NULL; compiler->patchlist = NULL; compiler->parent = NULL; compiler->current_srcpos = srcpos; fn = (uc_function_t *)compiler->function; fn->strict = strict; /* reserve stack slot 0 */ uc_compiler_declare_local(compiler, varname, false); uc_compiler_initialize_local(compiler); ucv_put(varname); } static uc_chunk_t * uc_compiler_current_chunk(uc_compiler_t *compiler) { uc_function_t *fn = (uc_function_t *)compiler->function; return &fn->chunk; } static uc_source_t * uc_compiler_current_source(uc_compiler_t *compiler) { return compiler->program->source; } __attribute__((format(printf, 3, 0))) static void uc_compiler_syntax_error(uc_compiler_t *compiler, size_t off, const char *fmt, ...) { uc_stringbuf_t *buf = compiler->parser->error; size_t line = 0, byte = 0, len = 0; va_list ap; char *s; if (compiler->parser->synchronizing) return; compiler->parser->synchronizing = true; if (!buf) buf = compiler->parser->error = xprintbuf_new(); if (!off) off = ucv_function_srcpos(compiler->function, uc_compiler_current_chunk(compiler)->count); if (off) { byte = off; line = uc_source_get_line(uc_compiler_current_source(compiler), &byte); } va_start(ap, fmt); len = xvasprintf(&s, fmt, ap); va_end(ap); ucv_stringbuf_append(buf, "Syntax error: "); ucv_stringbuf_addstr(buf, s, len); ucv_stringbuf_append(buf, "\n"); free(s); if (line) ucv_stringbuf_printf(buf, "In line %zu, byte %zu:\n", line, byte); if (uc_error_context_format(buf, uc_compiler_current_source(compiler), NULL, off)) ucv_stringbuf_append(buf, "\n\n"); } static size_t uc_compiler_set_srcpos(uc_compiler_t *compiler, size_t srcpos) { size_t delta; /* ensure that lines counts are strictly increasing */ assert(srcpos == 0 || srcpos >= compiler->current_srcpos); delta = srcpos ? srcpos - compiler->current_srcpos : 0; compiler->current_srcpos += delta; return delta; } static void uc_compiler_parse_advance(uc_compiler_t *compiler) { ucv_put(compiler->parser->prev.uv); compiler->parser->prev = compiler->parser->curr; while (true) { compiler->parser->curr = *uc_lexer_next_token(&compiler->parser->lex); if (compiler->parser->curr.type != TK_ERROR) break; uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "%s", ucv_string_get(compiler->parser->curr.uv)); ucv_put(compiler->parser->curr.uv); compiler->parser->curr.uv = NULL; } } static void uc_compiler_parse_consume(uc_compiler_t *compiler, uc_tokentype_t type) { if (compiler->parser->curr.type == type) { uc_compiler_parse_advance(compiler); return; } uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Unexpected token\nExpecting %s", uc_tokenname(type)); } static bool uc_compiler_parse_check(uc_compiler_t *compiler, uc_tokentype_t type) { return (compiler->parser->curr.type == type); } static bool uc_compiler_parse_match(uc_compiler_t *compiler, uc_tokentype_t type) { if (!uc_compiler_parse_check(compiler, type)) return false; uc_compiler_parse_advance(compiler); return true; } static void uc_compiler_parse_synchronize(uc_compiler_t *compiler) { compiler->parser->synchronizing = false; while (compiler->parser->curr.type != TK_EOF) { if (compiler->parser->prev.type == TK_SCOL) return; switch (compiler->parser->curr.type) { case TK_IF: case TK_FOR: case TK_WHILE: case TK_SWITCH: case TK_FUNC: case TK_TRY: case TK_RETURN: case TK_BREAK: case TK_CONTINUE: case TK_LOCAL: return; default: break; } uc_compiler_parse_advance(compiler); } } static uc_parse_rule_t * uc_compiler_parse_rule(uc_tokentype_t type) { return &uc_compiler_parse_rules[type]; } static bool uc_compiler_parse_at_assignment_op(uc_compiler_t *compiler) { switch (compiler->parser->curr.type) { case TK_ASBAND: case TK_ASBXOR: case TK_ASBOR: case TK_ASLEFT: case TK_ASRIGHT: case TK_ASMUL: case TK_ASDIV: case TK_ASMOD: case TK_ASADD: case TK_ASSUB: case TK_ASSIGN: return true; default: return false; } } static void uc_compiler_parse_precedence(uc_compiler_t *compiler, uc_precedence_t precedence) { uc_parse_rule_t *rule; rule = uc_compiler_parse_rule(compiler->parser->curr.type); if (!rule->prefix) { uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting expression"); uc_compiler_parse_advance(compiler); return; } uc_compiler_exprstack_push(compiler, compiler->parser->curr.type, (precedence <= P_ASSIGN) ? F_ASSIGNABLE : 0); /* allow reserved words as property names in object literals */ if (rule->prefix == uc_compiler_compile_object) compiler->parser->lex.no_keyword = true; /* unless a sub-expression follows, treat subsequent slash as division * operator and not as beginning of regexp literal */ if (rule->prefix != uc_compiler_compile_paren && rule->prefix != uc_compiler_compile_unary && rule->prefix != uc_compiler_compile_array) compiler->parser->lex.no_regexp = true; uc_compiler_parse_advance(compiler); rule->prefix(compiler); while (precedence <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) { compiler->exprstack->token = compiler->parser->curr.type; rule = uc_compiler_parse_rule(compiler->exprstack->token); /* allow reserved words in property accessors */ if (rule->infix == uc_compiler_compile_dot) compiler->parser->lex.no_keyword = true; uc_compiler_parse_advance(compiler); rule->infix(compiler); } if (uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) && uc_compiler_parse_at_assignment_op(compiler)) uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Invalid left-hand side expression for assignment"); uc_compiler_exprstack_pop(compiler); } static size_t uc_compiler_reladdr(uc_compiler_t *compiler, size_t from, size_t to) { ssize_t delta = to - from; if (delta < -0x7fffffff || delta > 0x7fffffff) { uc_compiler_syntax_error(compiler, 0, "Jump address too far"); return 0; } return (size_t)(delta + 0x7fffffff); } static size_t uc_compiler_emit_insn(uc_compiler_t *compiler, size_t srcpos, uc_vm_insn_t insn) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); compiler->last_insn = uc_chunk_add(chunk, (uint8_t)insn, lineoff); return compiler->last_insn; } static size_t uc_compiler_emit_u8(uc_compiler_t *compiler, size_t srcpos, uint8_t n) { return uc_chunk_add( uc_compiler_current_chunk(compiler), n, uc_compiler_set_srcpos(compiler, srcpos)); } static size_t uc_compiler_emit_u16(uc_compiler_t *compiler, size_t srcpos, uint16_t n) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); uc_chunk_add(chunk, n / 0x100, lineoff); uc_chunk_add(chunk, n % 0x100, 0); return chunk->count - 2; } static size_t uc_compiler_emit_u32(uc_compiler_t *compiler, size_t srcpos, uint32_t n) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); uc_chunk_add(chunk, n / 0x1000000, lineoff); uc_chunk_add(chunk, (n / 0x10000) % 0x100, 0); uc_chunk_add(chunk, (n / 0x100) % 0x100, 0); uc_chunk_add(chunk, n % 0x100, 0); return chunk->count - 4; } static size_t uc_compiler_emit_s32(uc_compiler_t *compiler, size_t srcpos, int32_t n) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t lineoff = uc_compiler_set_srcpos(compiler, srcpos); uint32_t v; if (n <= 0) v = n + 0x7fffffff; else v = (uint32_t)n + 0x7fffffff; uc_chunk_add(chunk, v / 0x1000000, lineoff); uc_chunk_add(chunk, (v / 0x10000) % 0x100, 0); uc_chunk_add(chunk, (v / 0x100) % 0x100, 0); uc_chunk_add(chunk, v % 0x100, 0); return chunk->count - 4; } static uint32_t uc_compiler_get_u32(uc_compiler_t *compiler, size_t off) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); return chunk->entries[off + 0] * 0x1000000 + chunk->entries[off + 1] * 0x10000 + chunk->entries[off + 2] * 0x100 + chunk->entries[off + 3]; } static void uc_compiler_set_u32(uc_compiler_t *compiler, size_t off, uint32_t n) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); chunk->entries[off + 0] = n / 0x1000000; chunk->entries[off + 1] = (n / 0x10000) % 0x100; chunk->entries[off + 2] = (n / 0x100) % 0x100; chunk->entries[off + 3] = n % 0x100; } static size_t uc_compiler_emit_constant(uc_compiler_t *compiler, size_t srcpos, uc_value_t *val) { size_t cidx = uc_program_add_constant(compiler->program, val); uc_compiler_emit_insn(compiler, srcpos, I_LOAD); uc_compiler_emit_u32(compiler, 0, cidx); return cidx; } static size_t uc_compiler_emit_regexp(uc_compiler_t *compiler, size_t srcpos, uc_value_t *val) { size_t cidx = uc_program_add_constant(compiler->program, val); uc_compiler_emit_insn(compiler, srcpos, I_LREXP); uc_compiler_emit_u32(compiler, 0, cidx); return cidx; } static size_t uc_compiler_emit_jmp(uc_compiler_t *compiler, size_t srcpos) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_compiler_emit_insn(compiler, srcpos, I_JMP); uc_compiler_emit_u32(compiler, 0, 0); return chunk->count - 5; } static size_t uc_compiler_emit_jmpz(uc_compiler_t *compiler, size_t srcpos) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_compiler_emit_insn(compiler, srcpos, I_JMPZ); uc_compiler_emit_u32(compiler, 0, 0); return chunk->count - 5; } static size_t uc_compiler_emit_jmp_dest(uc_compiler_t *compiler, size_t srcpos, uint32_t dest) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_compiler_emit_insn(compiler, srcpos, I_JMP); uc_compiler_emit_u32(compiler, 0, uc_compiler_reladdr(compiler, chunk->count - 1, dest)); return chunk->count - 5; } static ssize_t uc_compiler_get_jmpaddr(uc_compiler_t *compiler, size_t off) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ); assert(off + 4 < chunk->count); return ( chunk->entries[off + 1] * 0x1000000UL + chunk->entries[off + 2] * 0x10000UL + chunk->entries[off + 3] * 0x100UL + chunk->entries[off + 4] ) - 0x7fffffff; } static void uc_compiler_set_jmpaddr(uc_compiler_t *compiler, size_t off, uint32_t dest) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t addr = uc_compiler_reladdr(compiler, off, dest); assert(chunk->entries[off] == I_JMP || chunk->entries[off] == I_JMPZ); assert(off + 4 < chunk->count); chunk->entries[off + 1] = addr / 0x1000000; chunk->entries[off + 2] = (addr / 0x10000) % 0x100; chunk->entries[off + 3] = (addr / 0x100) % 0x100; chunk->entries[off + 4] = addr % 0x100; } static uc_function_t * uc_compiler_finish(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_locals_t *locals = &compiler->locals; uc_upvals_t *upvals = &compiler->upvals; size_t i; uc_compiler_emit_insn(compiler, 0, I_LNULL); uc_compiler_emit_insn(compiler, 0, I_RETURN); for (i = 0; i < locals->count; i++) { uc_chunk_debug_add_variable(chunk, locals->entries[i].from, chunk->count, i, false, locals->entries[i].name); ucv_put(locals->entries[i].name); } for (i = 0; i < upvals->count; i++) { uc_chunk_debug_add_variable(chunk, 0, chunk->count, i, true, upvals->entries[i].name); ucv_put(upvals->entries[i].name); } uc_vector_clear(locals); uc_vector_clear(upvals); if (compiler->parser->error) { ucv_put(compiler->function); return NULL; } return (uc_function_t *)compiler->function; } static void uc_compiler_enter_scope(uc_compiler_t *compiler) { compiler->scope_depth++; } static void uc_compiler_leave_scope(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_locals_t *locals = &compiler->locals; compiler->scope_depth--; while (locals->count > 0 && locals->entries[locals->count - 1].depth > (ssize_t)compiler->scope_depth) { locals->count--; uc_chunk_debug_add_variable(chunk, locals->entries[locals->count].from, chunk->count, locals->count, false, locals->entries[locals->count].name); ucv_put(locals->entries[locals->count].name); locals->entries[locals->count].name = NULL; uc_compiler_emit_insn(compiler, 0, locals->entries[locals->count].captured ? I_CUPV : I_POP); } } static bool uc_compiler_is_strict(uc_compiler_t *compiler) { uc_function_t *fn = (uc_function_t *)compiler->function; return fn->strict; } static ssize_t uc_compiler_declare_local(uc_compiler_t *compiler, uc_value_t *name, bool constant) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_locals_t *locals = &compiler->locals; const char *str1, *str2; size_t i, len1, len2; if (locals->count >= 0x00FFFFFF) { uc_compiler_syntax_error(compiler, 0, "Too many local variables"); return -1; } str1 = ucv_string_get(name); len1 = ucv_string_length(name); for (i = locals->count; i > 0; i--) { if (locals->entries[i - 1].depth != -1 && locals->entries[i - 1].depth < (ssize_t)compiler->scope_depth) break; str2 = ucv_string_get(locals->entries[i - 1].name); len2 = ucv_string_length(locals->entries[i - 1].name); if (len1 == len2 && !strcmp(str1, str2)) { if (uc_compiler_is_strict(compiler)) { uc_compiler_syntax_error(compiler, 0, "Variable '%s' redeclared", str2); return -1; } return i - 1; } } uc_vector_grow(locals); locals->entries[locals->count].name = ucv_get(name); locals->entries[locals->count].depth = -1; locals->entries[locals->count].captured = false; locals->entries[locals->count].from = chunk->count; locals->entries[locals->count].constant = constant; locals->count++; return -1; } static ssize_t uc_compiler_initialize_local(uc_compiler_t *compiler) { uc_locals_t *locals = &compiler->locals; locals->entries[locals->count - 1].depth = compiler->scope_depth; return locals->count - 1; } static ssize_t uc_compiler_resolve_local(uc_compiler_t *compiler, uc_value_t *name, bool *constant) { uc_locals_t *locals = &compiler->locals; const char *str1, *str2; size_t i, len1, len2; str1 = ucv_string_get(name); len1 = ucv_string_length(name); for (i = locals->count; i > 0; i--) { str2 = ucv_string_get(locals->entries[i - 1].name); len2 = ucv_string_length(locals->entries[i - 1].name); if (len1 != len2 || strcmp(str1, str2)) continue; if (locals->entries[i - 1].depth == -1) { uc_compiler_syntax_error(compiler, 0, "Can't access lexical declaration '%s' before initialization", str2); return -1; } *constant = locals->entries[i - 1].constant; return i - 1; } return -1; } static ssize_t uc_compiler_add_upval(uc_compiler_t *compiler, size_t idx, bool local, uc_value_t *name, bool constant) { uc_function_t *function = (uc_function_t *)compiler->function; uc_upvals_t *upvals = &compiler->upvals; uc_upval_t *uv; size_t i; for (i = 0, uv = upvals->entries; i < upvals->count; i++, uv = upvals->entries + i) if (uv->index == idx && uv->local == local) return i; /* XXX: encoding... */ if (upvals->count >= (2 << 14)) { uc_compiler_syntax_error(compiler, 0, "Too many upvalues"); return -1; } uc_vector_grow(upvals); upvals->entries[upvals->count].local = local; upvals->entries[upvals->count].index = idx; upvals->entries[upvals->count].name = ucv_get(name); upvals->entries[upvals->count].constant = constant; function->nupvals++; return upvals->count++; } static ssize_t uc_compiler_resolve_upval(uc_compiler_t *compiler, uc_value_t *name, bool *constant) { ssize_t idx; if (!compiler->parent) return -1; idx = uc_compiler_resolve_local(compiler->parent, name, constant); if (idx > -1) { compiler->parent->locals.entries[idx].captured = true; return uc_compiler_add_upval(compiler, idx, true, name, *constant); } idx = uc_compiler_resolve_upval(compiler->parent, name, constant); if (idx > -1) return uc_compiler_add_upval(compiler, idx, false, name, *constant); return -1; } static void uc_compiler_backpatch(uc_compiler_t *compiler, size_t break_addr, size_t next_addr) { uc_patchlist_t *pl = compiler->patchlist; uc_patchlist_t *pp = pl->parent; volatile ssize_t jmpaddr; size_t i; for (i = 0; i < pl->count; i++) { jmpaddr = uc_compiler_get_jmpaddr(compiler, pl->entries[i]); switch (jmpaddr) { case TK_BREAK: /* if we have a break addr, patch instruction */ if (break_addr) { uc_compiler_set_jmpaddr(compiler, pl->entries[i], break_addr); continue; } break; case TK_CONTINUE: /* if we have a continue addr, patch instruction */ if (next_addr) { uc_compiler_set_jmpaddr(compiler, pl->entries[i], next_addr); continue; } break; } /* propagate unhandled patch instructions to parent patch list */ if (pp) { uc_vector_grow(pp); pp->entries[pp->count++] = pl->entries[i]; } } free(pl->entries); compiler->patchlist = pl->parent; } static void uc_compiler_emit_inc_dec(uc_compiler_t *compiler, uc_tokentype_t toktype, bool is_postfix) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_value_t *varname = NULL; uc_vm_insn_t type; uint32_t cidx = 0; int insn; /* determine kind of emitted load instruction and operand value (if any) */ type = chunk->entries ? chunk->entries[compiler->last_insn] : 0; if (type == I_LVAR || type == I_LLOC || type == I_LUPV) { cidx = uc_compiler_get_u32(compiler, compiler->last_insn + 1); if (type == I_LLOC && compiler->locals.entries[cidx].constant) varname = compiler->locals.entries[cidx].name; else if (type == I_LUPV && compiler->upvals.entries[cidx].constant) varname = compiler->upvals.entries[cidx].name; if (varname) uc_compiler_syntax_error(compiler, 0, "Invalid increment/decrement of constant '%s'", ucv_string_get(varname)); uc_chunk_pop(chunk); uc_chunk_pop(chunk); uc_chunk_pop(chunk); uc_chunk_pop(chunk); uc_chunk_pop(chunk); } /* if we're mutating an object or array field, pop the last lval instruction * to leave object + last field name value on stack */ else if (type == I_LVAL && !uc_compiler_exprstack_is(compiler, F_OPTCHAINING)) { uc_chunk_pop(chunk); } else { uc_compiler_syntax_error(compiler, 0, "Invalid increment/decrement operand"); return; } insn = (toktype == TK_INC) ? I_PLUS : I_MINUS; /* add / substract 1 */ uc_compiler_emit_insn(compiler, 0, I_LOAD8); uc_compiler_emit_u8(compiler, 0, 1); /* depending on variable type, emit corresponding increment instruction */ switch (type) { case I_LVAR: uc_compiler_emit_insn(compiler, 0, I_UVAR); uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx); break; case I_LLOC: uc_compiler_emit_insn(compiler, 0, I_ULOC); uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx); break; case I_LUPV: uc_compiler_emit_insn(compiler, 0, I_UUPV); uc_compiler_emit_u32(compiler, 0, (insn << 24) | cidx); break; case I_LVAL: uc_compiler_emit_insn(compiler, 0, I_UVAL); uc_compiler_emit_u8(compiler, 0, insn); break; default: break; } /* for post increment or decrement, add/substract 1 to yield final value */ if (is_postfix) { uc_compiler_emit_insn(compiler, 0, I_LOAD8); uc_compiler_emit_u8(compiler, 0, 1); uc_compiler_emit_insn(compiler, 0, (toktype == TK_INC) ? I_SUB : I_ADD); } } static void uc_compiler_compile_unary(uc_compiler_t *compiler) { uc_tokentype_t type = compiler->parser->prev.type; uc_compiler_parse_precedence(compiler, P_UNARY); switch (type) { case TK_SUB: uc_compiler_emit_insn(compiler, 0, I_MINUS); break; case TK_ADD: uc_compiler_emit_insn(compiler, 0, I_PLUS); break; case TK_NOT: uc_compiler_emit_insn(compiler, 0, I_NOT); break; case TK_COMPL: uc_compiler_emit_insn(compiler, 0, I_COMPL); break; case TK_INC: case TK_DEC: uc_compiler_emit_inc_dec(compiler, type, false); break; default: return; } } static void uc_compiler_compile_binary(uc_compiler_t *compiler) { uc_tokentype_t type = compiler->parser->prev.type; uc_compiler_parse_precedence(compiler, uc_compiler_parse_rule(type)->precedence + 1); uc_compiler_emit_insn(compiler, 0, I_BOR + (type - TK_BOR)); } static void uc_compiler_compile_delete(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_vm_insn_t type; #ifndef NO_LEGACY /* If the delete keyword is followed by an opening paren, it might be a * legacy delete(object, propname) call */ if (uc_compiler_parse_match(compiler, TK_LPAREN)) { uc_compiler_parse_precedence(compiler, P_ASSIGN); if (uc_compiler_parse_match(compiler, TK_RPAREN)) { type = chunk->entries[compiler->last_insn]; if (type != I_LVAL) uc_compiler_syntax_error(compiler, 0, "expecting a property access expression"); chunk->entries[compiler->last_insn] = I_DELETE; } else if (uc_compiler_parse_match(compiler, TK_COMMA)) { if (uc_compiler_is_strict(compiler)) { uc_compiler_syntax_error(compiler, 0, "attempt to apply 'delete' operator on non-property access expression"); } else { uc_compiler_parse_precedence(compiler, P_ASSIGN); uc_compiler_emit_insn(compiler, 0, I_DELETE); uc_compiler_parse_consume(compiler, TK_RPAREN); } } else { uc_compiler_syntax_error(compiler, 0, "expecting ')' or ','"); } } /* Otherwise compile expression, ensure that it results in a property * access (I_LVAL) and overwrite it with delete operation. */ else #endif /* NO_LEGACY */ { uc_compiler_parse_precedence(compiler, P_UNARY); type = chunk->entries[compiler->last_insn]; if (type != I_LVAL) uc_compiler_syntax_error(compiler, 0, "expecting a property access expression"); chunk->entries[compiler->last_insn] = I_DELETE; } } static uc_vm_insn_t uc_compiler_emit_variable_rw(uc_compiler_t *compiler, uc_value_t *varname, uc_tokentype_t type) { uc_vm_insn_t insn; uint32_t sub_insn; bool constant; ssize_t idx; switch (type) { case TK_ASADD: sub_insn = I_ADD; break; case TK_ASSUB: sub_insn = I_SUB; break; case TK_ASMUL: sub_insn = I_MUL; break; case TK_ASDIV: sub_insn = I_DIV; break; case TK_ASMOD: sub_insn = I_MOD; break; case TK_ASBAND: sub_insn = I_BAND; break; case TK_ASBXOR: sub_insn = I_BXOR; break; case TK_ASBOR: sub_insn = I_BOR; break; case TK_ASLEFT: sub_insn = I_LSHIFT; break; case TK_ASRIGHT: sub_insn = I_RSHIFT; break; default: sub_insn = 0; break; } if (!varname) { if (sub_insn != 0) insn = I_UVAL; else if (type == TK_QDOT || type == TK_QLBRACK) insn = I_QLVAL; else if (type != 0) insn = I_SVAL; else insn = I_LVAL; if ((insn == I_UVAL || insn == I_SVAL) && uc_compiler_exprstack_is(compiler, F_OPTCHAINING)) uc_compiler_syntax_error(compiler, 0, "Invalid left-hand side expression for assignment"); uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); if (sub_insn) uc_compiler_emit_u8(compiler, compiler->parser->prev.pos, sub_insn); } else if ((idx = uc_compiler_resolve_local(compiler, varname, &constant)) > -1) { insn = sub_insn ? I_ULOC : (type ? I_SLOC : I_LLOC); if (insn != I_LLOC && constant) uc_compiler_syntax_error(compiler, 0, "Invalid assignment to constant '%s'", ucv_string_get(varname)); uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, ((sub_insn & 0xff) << 24) | idx); } else if ((idx = uc_compiler_resolve_upval(compiler, varname, &constant)) > -1) { insn = sub_insn ? I_UUPV : (type ? I_SUPV : I_LUPV); if (insn != I_LUPV && constant) uc_compiler_syntax_error(compiler, 0, "Invalid assignment to constant '%s'", ucv_string_get(varname)); uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, ((sub_insn & 0xff) << 24) | idx); } else { idx = uc_program_add_constant(compiler->program, varname); insn = sub_insn ? I_UVAR : (type ? I_SVAR : I_LVAR); uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, insn); uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, ((sub_insn & 0xff) << 24) | idx); } return insn; } static void uc_compiler_compile_expression(uc_compiler_t *compiler) { uc_compiler_parse_precedence(compiler, P_COMMA); } static bool uc_compiler_compile_assignment(uc_compiler_t *compiler, uc_value_t *var) { uc_tokentype_t type = compiler->parser->curr.type; if (uc_compiler_parse_at_assignment_op(compiler)) { uc_compiler_parse_advance(compiler); uc_compiler_parse_precedence(compiler, P_ASSIGN); uc_compiler_emit_variable_rw(compiler, var, type); return true; } return false; } static bool uc_compiler_compile_arrowfn(uc_compiler_t *compiler, uc_value_t *args, bool restarg) { bool array = (ucv_type(args) == UC_ARRAY); uc_compiler_t fncompiler = { 0 }; size_t i, pos, load_off; uc_function_t *fn; ssize_t slot; if (!uc_compiler_parse_match(compiler, TK_ARROW)) return false; pos = compiler->parser->prev.pos; uc_compiler_init(&fncompiler, NULL, compiler->parser->prev.pos, compiler->program, uc_compiler_is_strict(compiler)); fncompiler.parent = compiler; fncompiler.parser = compiler->parser; fncompiler.exprstack = compiler->exprstack; fn = (uc_function_t *)fncompiler.function; fn->arrow = true; fn->vararg = args ? restarg : false; fn->nargs = array ? ucv_array_length(args) : !!args; uc_compiler_enter_scope(&fncompiler); /* declare local variables for arguments */ for (i = 0; i < fn->nargs; i++) { slot = uc_compiler_declare_local(&fncompiler, array ? ucv_array_get(args, i) : args, false); if (slot != -1) uc_compiler_syntax_error(&fncompiler, pos, "Duplicate argument names are not allowed in this context"); uc_compiler_initialize_local(&fncompiler); } /* parse and compile body */ if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) { while (!uc_compiler_parse_check(&fncompiler, TK_RBRACE) && !uc_compiler_parse_check(&fncompiler, TK_EOF)) uc_compiler_compile_declaration(&fncompiler); uc_compiler_parse_consume(&fncompiler, TK_RBRACE); /* overwrite last pop result with return */ if (fn->chunk.count) { uc_chunk_pop(&fn->chunk); uc_compiler_emit_insn(&fncompiler, 0, I_RETURN); } } else { uc_compiler_parse_precedence(&fncompiler, P_ASSIGN); uc_compiler_emit_insn(&fncompiler, 0, I_RETURN); } /* emit load instruction for function value */ uc_compiler_emit_insn(compiler, pos, I_ARFN); load_off = uc_compiler_emit_u32(compiler, 0, 0); /* encode upvalue information */ for (i = 0; i < fn->nupvals; i++) uc_compiler_emit_s32(compiler, 0, fncompiler.upvals.entries[i].local ? -(fncompiler.upvals.entries[i].index + 1) : fncompiler.upvals.entries[i].index); /* finalize function compiler */ fn = uc_compiler_finish(&fncompiler); if (fn) uc_compiler_set_u32(compiler, load_off, uc_program_add_constant(compiler->program, &fn->header)); return true; } static uc_tokentype_t uc_compiler_compile_var_or_arrowfn(uc_compiler_t *compiler, uc_value_t *name) { uc_tokentype_t rv; if (uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) && uc_compiler_compile_assignment(compiler, name)) { rv = TK_ASSIGN; } else if (uc_compiler_compile_arrowfn(compiler, name, false)) { rv = TK_ARROW; } else { uc_compiler_emit_variable_rw(compiler, name, 0); rv = TK_LABEL; } return rv; } static void uc_compiler_compile_paren(uc_compiler_t *compiler) { uc_value_t *varnames = NULL, *varname; bool maybe_arrowfn = false; bool restarg = false; /* First try to parse a complete parameter expression and remember the * consumed label tokens as we go. */ while (true) { if (uc_compiler_parse_check(compiler, TK_LABEL)) { if (!varnames) varnames = ucv_array_new(NULL); ucv_array_push(varnames, ucv_get(compiler->parser->curr.uv)); /* A subsequent slash cannot be a regular expression literal */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_advance(compiler); } else if (uc_compiler_parse_match(compiler, TK_ELLIP)) { uc_compiler_parse_consume(compiler, TK_LABEL); if (!varnames) varnames = ucv_array_new(NULL); ucv_array_push(varnames, ucv_get(compiler->parser->prev.uv)); /* A subsequent slash cannot be a regular expression literal */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_consume(compiler, TK_RPAREN); maybe_arrowfn = true; restarg = true; break; } else if (uc_compiler_parse_check(compiler, TK_COMMA)) { /* Reject consecutive commas */ if (compiler->parser->prev.type == TK_COMMA) uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting expression"); uc_compiler_parse_advance(compiler); continue; } else { maybe_arrowfn = uc_compiler_parse_check(compiler, TK_RPAREN); if (maybe_arrowfn) { /* A subsequent slash cannot be a regular expression literal */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_advance(compiler); } /* If we encouter a dot, treat potential subsequent keyword as label */ if (uc_compiler_parse_check(compiler, TK_DOT) || uc_compiler_parse_check(compiler, TK_QDOT)) compiler->parser->lex.no_keyword = true; break; } } /* The lhs we parsed so far is elligible for an arrow function arg list, * try to continue compiling into arrow function... */ if (maybe_arrowfn) { /* If we can parse the remainder as arrow function, we're done */ if (uc_compiler_compile_arrowfn(compiler, varnames, restarg)) goto out; /* ... otherwise disallow the `...` spread operator and empty * parenthesized expressions */ if (restarg || !varnames) { uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Expecting '=>' after parameter list"); goto out; } } /* If we reach this, the expression we parsed so far cannot be a parameter * list for an arrow function and we might have consumed one or multiple * consecutive labels. */ if (varnames) { /* Get last variable name */ varname = ucv_array_get(varnames, ucv_array_length(varnames) - 1); /* If we consumed the right paren, the expression is complete and we * only need to emit a variable read operation for the last parsed * label since previous read operations are shadowed by subsequent ones * in comma expressions and since pure variable reads are without * side effects. */ if (maybe_arrowfn) { uc_compiler_emit_variable_rw(compiler, varname, 0); goto out; } /* ... otherwise if the last token was a label, try continue parsing as * assignment or arrow function expression and if that fails, as * relational one */ if (compiler->parser->prev.type == TK_LABEL) { uc_compiler_exprstack_push(compiler, TK_LABEL, F_ASSIGNABLE); if (uc_compiler_compile_var_or_arrowfn(compiler, varname) == TK_LABEL) { /* parse operand and rhs */ while (P_TERNARY <= uc_compiler_parse_rule(compiler->parser->curr.type)->precedence) { uc_compiler_parse_advance(compiler); uc_compiler_parse_rule(compiler->parser->prev.type)->infix(compiler); } } /* If we're not at the end of the expression, we require a comma. * Also pop intermediate result in this case. */ if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { uc_compiler_emit_insn(compiler, 0, I_POP); uc_compiler_parse_consume(compiler, TK_COMMA); } uc_compiler_exprstack_pop(compiler); } } /* When we reach this point, all already complete expression possibilities * have been eliminated and we either need to compile the next, non-label * expression or reached the closing paren. If neither applies, we have a * syntax error. */ if (!uc_compiler_parse_check(compiler, TK_RPAREN)) uc_compiler_compile_expression(compiler); /* A subsequent slash cannot be a regular expression literal */ compiler->parser->lex.no_regexp = true; /* At this point we expect the end of the parenthesized expression, anything * else is a syntax error */ uc_compiler_parse_consume(compiler, TK_RPAREN); out: ucv_put(varnames); } static void uc_compiler_compile_call(uc_compiler_t *compiler) { bool optional_chaining = (compiler->parser->prev.type == TK_QLPAREN); uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_jmplist_t spreads = { 0 }; uc_vm_insn_t type; size_t i, nargs = 0; /* flag optional chaining usage in current expression */ compiler->exprstack->flags |= optional_chaining ? F_OPTCHAINING : 0; /* determine the kind of the lhs */ type = chunk->entries[compiler->last_insn]; /* if lhs is a dot or bracket expression, pop the LVAL instruction */ if (type == I_LVAL || type == I_QLVAL) uc_chunk_pop(chunk); /* compile arguments */ if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { do { /* if this is a spread arg, remember the argument index */ if (uc_compiler_parse_match(compiler, TK_ELLIP)) { uc_vector_grow(&spreads); spreads.entries[spreads.count++] = nargs; } /* compile argument expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); nargs++; } while (uc_compiler_parse_match(compiler, TK_COMMA)); } /* after a function call expression, no regexp literal can follow */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_consume(compiler, TK_RPAREN); /* if lhs is a dot or bracket expression, emit a method call */ if (type == I_LVAL || type == I_QLVAL) uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, optional_chaining ? I_QMCALL : I_MCALL); /* else ordinary call */ else uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, optional_chaining ? I_QCALL : I_CALL); if (nargs > 0xffff || spreads.count > 0xffff) uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Too many function call arguments"); /* encode ordinary (low 16 bit) and spread argument (high 16 bit) count */ uc_compiler_emit_u32(compiler, 0, ((spreads.count & 0xffff) << 16) | nargs); /* encode spread arg positions */ for (i = 0; i < spreads.count; i++) uc_compiler_emit_u16(compiler, 0, nargs - spreads.entries[i] - 1); uc_vector_clear(&spreads); } static void uc_compiler_compile_post_inc(uc_compiler_t *compiler) { uc_compiler_emit_inc_dec(compiler, compiler->parser->prev.type, true); } static bool uc_compiler_is_use_strict_pragma(uc_compiler_t *compiler) { uc_value_t *v; if (uc_compiler_current_chunk(compiler)->count > 0) return false; if (compiler->parser->lex.block != STATEMENTS) return false; v = compiler->parser->prev.uv; return (strcmp(ucv_string_get(v), "use strict") == 0); } static void uc_compiler_compile_constant(uc_compiler_t *compiler) { uc_function_t *fn; uint64_t u; switch (compiler->parser->prev.type) { case TK_THIS: uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LTHIS); break; case TK_NULL: uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); break; case TK_TRUE: uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LTRUE); break; case TK_FALSE: uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LFALSE); break; case TK_STRING: if (uc_compiler_is_use_strict_pragma(compiler)) { fn = (uc_function_t *)compiler->function; fn->strict = true; } /* fall through */ case TK_DOUBLE: uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); break; case TK_REGEXP: uc_compiler_emit_regexp(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); break; case TK_NUMBER: u = ucv_uint64_get(compiler->parser->prev.uv); assert(errno == 0); if (u <= 0xff) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD8); uc_compiler_emit_u8(compiler, compiler->parser->prev.pos, u); } else if (u <= 0xffff) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD16); uc_compiler_emit_u16(compiler, compiler->parser->prev.pos, u); } else if (u <= 0xffffffff) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LOAD32); uc_compiler_emit_u32(compiler, compiler->parser->prev.pos, u); } else { uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); } break; default: break; } } static void uc_compiler_compile_comma(uc_compiler_t *compiler) { uc_compiler_emit_insn(compiler, 0, I_POP); uc_compiler_parse_precedence(compiler, P_ASSIGN); } static void uc_compiler_compile_labelexpr(uc_compiler_t *compiler) { uc_value_t *label = ucv_get(compiler->parser->prev.uv); uc_compiler_compile_var_or_arrowfn(compiler, label); ucv_put(label); } static bool uc_compiler_compile_delimitted_block(uc_compiler_t *compiler, uc_tokentype_t endtype) { while (!uc_compiler_parse_check(compiler, endtype) && !uc_compiler_parse_check(compiler, TK_EOF)) uc_compiler_compile_declaration(compiler); return uc_compiler_parse_check(compiler, endtype); } static void uc_compiler_compile_function(uc_compiler_t *compiler) { uc_compiler_t fncompiler = { 0 }; uc_value_t *name = NULL; ssize_t slot = -1, pos; uc_tokentype_t type; size_t i, load_off; uc_function_t *fn; pos = compiler->parser->prev.pos; type = compiler->parser->prev.type; if (uc_compiler_parse_match(compiler, TK_LABEL)) { name = compiler->parser->prev.uv; /* Named functions are syntactic sugar for local variable declaration * with function value assignment. If a name token was encountered, * initialize a local variable for it... */ slot = uc_compiler_declare_local(compiler, name, false); if (slot == -1) uc_compiler_initialize_local(compiler); } uc_compiler_init(&fncompiler, name ? ucv_string_get(name) : NULL, compiler->parser->prev.pos, compiler->program, uc_compiler_is_strict(compiler)); fncompiler.parent = compiler; fncompiler.parser = compiler->parser; fncompiler.exprstack = compiler->exprstack; fn = (uc_function_t *)fncompiler.function; uc_compiler_parse_consume(&fncompiler, TK_LPAREN); uc_compiler_enter_scope(&fncompiler); /* compile argument specification */ while (true) { if (uc_compiler_parse_check(&fncompiler, TK_RPAREN)) break; if (uc_compiler_parse_match(&fncompiler, TK_ELLIP)) fn->vararg = true; if (uc_compiler_parse_match(&fncompiler, TK_LABEL)) { fn->nargs++; uc_compiler_declare_local(&fncompiler, fncompiler.parser->prev.uv, false); uc_compiler_initialize_local(&fncompiler); if (fn->vararg || !uc_compiler_parse_match(&fncompiler, TK_COMMA)) break; } else { uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos, "Expecting Label"); return; } } uc_compiler_parse_consume(&fncompiler, TK_RPAREN); /* parse and compile function body */ if (uc_compiler_parse_match(&fncompiler, TK_COLON)) { uc_compiler_compile_delimitted_block(&fncompiler, TK_ENDFUNC); uc_compiler_parse_consume(&fncompiler, TK_ENDFUNC); } else if (uc_compiler_parse_match(&fncompiler, TK_LBRACE)) { uc_compiler_compile_delimitted_block(&fncompiler, TK_RBRACE); uc_compiler_parse_consume(&fncompiler, TK_RBRACE); } else { uc_compiler_syntax_error(&fncompiler, fncompiler.parser->curr.pos, "Expecting '{' or ':' after function parameters"); } /* emit load instruction for function value */ uc_compiler_emit_insn(compiler, pos, (type == TK_ARROW) ? I_ARFN : I_CLFN); load_off = uc_compiler_emit_u32(compiler, 0, 0); /* encode upvalue information */ for (i = 0; i < fn->nupvals; i++) uc_compiler_emit_s32(compiler, 0, fncompiler.upvals.entries[i].local ? -(fncompiler.upvals.entries[i].index + 1) : fncompiler.upvals.entries[i].index); /* finalize function compiler */ fn = uc_compiler_finish(&fncompiler); if (fn) uc_compiler_set_u32(compiler, load_off, uc_program_add_constant(compiler->program, &fn->header)); /* if a local variable of the same name already existed, overwrite its value * with the compiled function here */ if (slot != -1) { uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, slot); uc_compiler_emit_insn(compiler, 0, I_POP); } } static void uc_compiler_compile_and(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t jmpz_off; uc_compiler_emit_insn(compiler, 0, I_COPY); uc_compiler_emit_u8(compiler, 0, 0); jmpz_off = uc_compiler_emit_jmpz(compiler, 0); uc_compiler_emit_insn(compiler, 0, I_POP); uc_compiler_parse_precedence(compiler, P_AND); uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); } static void uc_compiler_compile_or(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t jmpz_off, jmp_off; uc_compiler_emit_insn(compiler, 0, I_COPY); uc_compiler_emit_u8(compiler, 0, 0); jmpz_off = uc_compiler_emit_jmpz(compiler, 0); jmp_off = uc_compiler_emit_jmp(compiler, 0); uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); uc_compiler_emit_insn(compiler, 0, I_POP); uc_compiler_parse_precedence(compiler, P_OR); uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); } static void uc_compiler_compile_dot(uc_compiler_t *compiler) { bool optional_chaining = (compiler->parser->prev.type == TK_QDOT); /* flag optional chaining usage in current expression */ compiler->exprstack->flags |= optional_chaining ? F_OPTCHAINING : 0; /* no regexp literal possible after property access */ compiler->parser->lex.no_regexp = true; /* parse label lhs */ uc_compiler_parse_consume(compiler, TK_LABEL); uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */ if (!uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) || !uc_compiler_compile_assignment(compiler, NULL)) uc_compiler_emit_variable_rw(compiler, NULL, optional_chaining ? TK_QDOT : 0); } static void uc_compiler_compile_subscript(uc_compiler_t *compiler) { bool optional_chaining = (compiler->parser->prev.type == TK_QLBRACK); /* flag optional chaining usage in current expression */ compiler->exprstack->flags |= optional_chaining ? F_OPTCHAINING : 0; /* compile lhs */ uc_compiler_compile_expression(compiler); /* no regexp literal possible after computed property access */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_consume(compiler, TK_RBRACK); /* depending on context, compile into I_UVAL, I_SVAL or I_LVAL operation */ if (!uc_compiler_exprstack_is(compiler, F_ASSIGNABLE) || !uc_compiler_compile_assignment(compiler, NULL)) uc_compiler_emit_variable_rw(compiler, NULL, optional_chaining ? TK_QLBRACK : 0); } static void uc_compiler_compile_ternary(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t jmpz_off, jmp_off; /* jump to false branch */ jmpz_off = uc_compiler_emit_jmpz(compiler, 0); /* compile true branch */ uc_compiler_parse_precedence(compiler, P_ASSIGN); /* jump after false branch */ jmp_off = uc_compiler_emit_jmp(compiler, 0); uc_compiler_parse_consume(compiler, TK_COLON); /* compile false branch */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); uc_compiler_parse_precedence(compiler, P_TERNARY); uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); } static void uc_compiler_compile_array(uc_compiler_t *compiler) { size_t hint_off, hint_count = 0, len = 0; /* create empty array on stack */ uc_compiler_emit_insn(compiler, 0, I_NARR); hint_off = uc_compiler_emit_u32(compiler, 0, 0); /* parse initializer values */ do { if (uc_compiler_parse_check(compiler, TK_RBRACK)) { break; } else if (uc_compiler_parse_match(compiler, TK_ELLIP)) { /* push items on stack so far... */ if (len > 0) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); uc_compiler_emit_u32(compiler, 0, len); len = 0; } /* compile spread value expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); /* emit merge operation */ uc_compiler_emit_insn(compiler, 0, I_MARR); } else { /* push items on stack so far... */ if (len >= 0xffffffff) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); uc_compiler_emit_u32(compiler, 0, len); len = 0; } /* compile item value expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); hint_count++; len++; } } while (uc_compiler_parse_match(compiler, TK_COMMA)); /* no regexp literal possible after array literal */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_consume(compiler, TK_RBRACK); /* push items on stack */ if (len > 0) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_PARR); uc_compiler_emit_u32(compiler, 0, len); } /* set initial size hint */ uc_compiler_set_u32(compiler, hint_off, hint_count); } static void uc_compiler_compile_object(uc_compiler_t *compiler) { size_t hint_off, hint_count = 0, len = 0; /* create empty object on stack */ uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_NOBJ); hint_off = uc_compiler_emit_u32(compiler, 0, 0); /* parse initializer values */ do { /* End of object literal */ if (uc_compiler_parse_check(compiler, TK_RBRACE)) break; /* Spread operator */ if (uc_compiler_parse_match(compiler, TK_ELLIP)) { /* set items on stack so far... */ if (len > 0) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); uc_compiler_emit_u32(compiler, 0, len); len = 0; } /* compile spread value expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); /* emit merge operation */ uc_compiler_emit_insn(compiler, 0, I_MOBJ); continue; } /* Computed property name */ if (uc_compiler_parse_match(compiler, TK_LBRACK)) { /* parse property name expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); /* cosume closing bracket and colon */ uc_compiler_parse_consume(compiler, TK_RBRACK); uc_compiler_parse_consume(compiler, TK_COLON); /* parse value expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); } /* Property/value tuple or property shorthand */ else { /* parse key expression */ if (!uc_compiler_parse_match(compiler, TK_LABEL) && !uc_compiler_parse_match(compiler, TK_STRING)) uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting label"); /* load label */ uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); /* If the property name is a plain label followed by a comma or * closing curly brace, treat it as ES2015 property shorthand * notation... */ if (compiler->parser->prev.type == TK_LABEL && (uc_compiler_parse_check(compiler, TK_COMMA) || uc_compiler_parse_check(compiler, TK_RBRACE))) { /* disallow keywords in this case */ if (uc_lexer_is_keyword(compiler->parser->prev.uv)) uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Invalid identifier"); uc_compiler_emit_variable_rw(compiler, compiler->parser->prev.uv, 0); } /* ... otherwise treat it as ordinary `key: value` tuple */ else { uc_compiler_parse_consume(compiler, TK_COLON); /* parse value expression */ uc_compiler_parse_precedence(compiler, P_ASSIGN); } } /* set items on stack so far... */ if (len >= 0xfffffffe) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); uc_compiler_emit_u32(compiler, 0, len); len = 0; } hint_count += 2; len += 2; compiler->parser->lex.no_keyword = true; } while (uc_compiler_parse_match(compiler, TK_COMMA)); /* no regexp literal possible after object literal */ compiler->parser->lex.no_regexp = true; uc_compiler_parse_consume(compiler, TK_RBRACE); /* set items on stack */ if (len > 0) { uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_SOBJ); uc_compiler_emit_u32(compiler, 0, len); } /* set initial size hint */ uc_compiler_set_u32(compiler, hint_off, hint_count); } static void uc_compiler_declare_local_null(uc_compiler_t *compiler, size_t srcpos, uc_value_t *varname) { ssize_t existing_slot = uc_compiler_declare_local(compiler, varname, false); uc_compiler_emit_insn(compiler, srcpos, I_LNULL); if (existing_slot == -1) { uc_compiler_initialize_local(compiler); } else { uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, existing_slot); uc_compiler_emit_insn(compiler, 0, I_POP); } } static size_t uc_compiler_declare_internal(uc_compiler_t *compiler, size_t srcpos, const char *name) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_locals_t *locals = &compiler->locals; uc_vector_grow(locals); locals->entries[locals->count].name = ucv_string_new(name); locals->entries[locals->count].depth = compiler->scope_depth; locals->entries[locals->count].captured = false; locals->entries[locals->count].from = chunk->count; return locals->count++; } static void uc_compiler_compile_declexpr(uc_compiler_t *compiler, bool constant) { ssize_t slot; do { /* parse variable name */ if (!uc_compiler_parse_match(compiler, TK_LABEL)) { uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting variable name"); return; } /* declare local variable */ slot = uc_compiler_declare_local(compiler, compiler->parser->prev.uv, constant); /* if followed by '=', parse initializer expression */ if (uc_compiler_parse_match(compiler, TK_ASSIGN)) uc_compiler_parse_precedence(compiler, P_ASSIGN); /* otherwise, for writable variables, load implicit null */ else if (!constant) uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); /* for constant variables, a missing initializer is a syntax error */ else uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "Expecting initializer expression"); /* initialize local */ if (slot == -1) { uc_compiler_initialize_local(compiler); } /* if the variable was redeclared, overwrite it */ else { uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, slot); uc_compiler_emit_insn(compiler, 0, I_POP); } } while (uc_compiler_parse_match(compiler, TK_COMMA)); } static void uc_compiler_compile_local(uc_compiler_t *compiler) { uc_compiler_compile_declexpr(compiler, false); uc_compiler_parse_consume(compiler, TK_SCOL); } static void uc_compiler_compile_const(uc_compiler_t *compiler) { uc_compiler_compile_declexpr(compiler, true); uc_compiler_parse_consume(compiler, TK_SCOL); } static uc_tokentype_t uc_compiler_compile_altifblock(uc_compiler_t *compiler) { uc_compiler_enter_scope(compiler); while (true) { switch (compiler->parser->curr.type) { case TK_ELIF: case TK_ELSE: case TK_ENDIF: case TK_EOF: uc_compiler_leave_scope(compiler); return compiler->parser->curr.type; default: uc_compiler_compile_declaration(compiler); break; } } return 0; } static void uc_compiler_compile_if(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t jmpz_off, jmp_off, i; bool expect_endif = false; uc_jmplist_t elifs = { 0 }; uc_tokentype_t type; /* parse & compile condition expression */ uc_compiler_parse_consume(compiler, TK_LPAREN); uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); /* conditional jump to else/elif branch */ jmpz_off = uc_compiler_emit_jmpz(compiler, 0); if (uc_compiler_parse_match(compiler, TK_COLON)) { compiler->exprstack->flags |= F_ALTBLOCKMODE; while (true) { /* compile elsif or else branch */ type = uc_compiler_compile_altifblock(compiler); /* we just compiled an elsif block */ if (!expect_endif && type == TK_ELIF) { /* emit jump to skip to the end */ uc_vector_grow(&elifs); elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0); /* point previous conditional jump to beginning of branch */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); /* parse & compile elsif condition */ uc_compiler_parse_advance(compiler); uc_compiler_parse_consume(compiler, TK_LPAREN); uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); uc_compiler_parse_consume(compiler, TK_COLON); /* conditional jump to else/elif branch */ jmpz_off = uc_compiler_emit_jmpz(compiler, 0); } else if (!expect_endif && type == TK_ELSE) { /* emit jump to skip to the end */ uc_vector_grow(&elifs); elifs.entries[elifs.count++] = uc_compiler_emit_jmp(compiler, 0); /* point previous conditional jump to beginning of branch */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); jmpz_off = 0; /* skip "else" keyword */ uc_compiler_parse_advance(compiler); expect_endif = true; } else if (type == TK_ENDIF) { /* if no else clause, point previous conditional jump after block */ if (jmpz_off) uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); /* patch the elif branch jumps to point here after the else */ for (i = 0; i < elifs.count; i++) uc_compiler_set_jmpaddr(compiler, elifs.entries[i], chunk->count); /* skip the "endif" keyword */ uc_compiler_parse_advance(compiler); break; } else { uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, expect_endif ? "Expecting 'endif'" : "Expecting 'elif', 'else' or 'endif'"); break; } } uc_vector_clear(&elifs); } else { /* compile true branch */ uc_compiler_compile_statement(compiler); /* ... when present, handle false branch */ if (uc_compiler_parse_match(compiler, TK_ELSE)) { /* jump to skip else branch */ jmp_off = uc_compiler_emit_jmp(compiler, 0); /* set conditional jump address */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); /* compile false branch */ uc_compiler_compile_statement(compiler); /* set else skip jump address */ uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); } /* ... otherwise point the conditional jump after the true branch */ else { uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); } } } static void uc_compiler_compile_while(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_patchlist_t p = { .depth = compiler->scope_depth }; size_t cond_off, jmpz_off, end_off; p.parent = compiler->patchlist; compiler->patchlist = &p; cond_off = chunk->count; /* parse & compile loop condition */ uc_compiler_parse_consume(compiler, TK_LPAREN); uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); /* conditional jump to end */ jmpz_off = uc_compiler_emit_jmpz(compiler, 0); /* compile loop body */ if (uc_compiler_parse_match(compiler, TK_COLON)) { uc_compiler_enter_scope(compiler); if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDWHILE)) uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting 'endwhile'"); else uc_compiler_parse_advance(compiler); uc_compiler_leave_scope(compiler); } else { uc_compiler_compile_statement(compiler); } end_off = chunk->count; /* jump back to condition */ uc_compiler_emit_jmp_dest(compiler, 0, cond_off); /* set conditional jump target */ uc_compiler_set_jmpaddr(compiler, jmpz_off, chunk->count); /* patch up break/continue */ uc_compiler_backpatch(compiler, chunk->count, end_off); } static void uc_compiler_compile_for_in(uc_compiler_t *compiler, bool local, uc_token_t *kvar, uc_token_t *vvar) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_patchlist_t p = { .depth = compiler->scope_depth + 1 }; size_t skip_jmp, test_jmp, key_slot, val_slot; p.parent = compiler->patchlist; compiler->patchlist = &p; uc_compiler_enter_scope(compiler); /* declare internal loop variables */ uc_compiler_emit_insn(compiler, 0, I_LNULL); key_slot = uc_compiler_declare_internal(compiler, 0, "(for in key)"); uc_compiler_emit_insn(compiler, 0, I_LNULL); val_slot = uc_compiler_declare_internal(compiler, 0, "(for in value)"); /* declare loop variables */ if (local) { uc_compiler_declare_local_null(compiler, kvar->pos, kvar->uv); if (vvar) uc_compiler_declare_local_null(compiler, vvar->pos, vvar->uv); } /* value to iterate */ uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, val_slot); /* initial key value */ uc_compiler_emit_insn(compiler, 0, I_LNULL); uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, key_slot); /* jump over variable read for first cycle */ skip_jmp = uc_compiler_emit_jmp(compiler, 0); /* read value */ uc_compiler_emit_insn(compiler, 0, I_LLOC); uc_compiler_emit_u32(compiler, 0, val_slot); /* read key */ uc_compiler_emit_insn(compiler, 0, I_LLOC); uc_compiler_emit_u32(compiler, 0, key_slot); /* backpatch skip jump */ uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count); /* load loop variable and get next key from object */ uc_compiler_emit_insn(compiler, 0, vvar ? I_NEXTKV : I_NEXTK); /* set internal key variable */ uc_compiler_emit_insn(compiler, 0, I_SLOC); uc_compiler_emit_u32(compiler, 0, key_slot); /* test for != null */ uc_compiler_emit_insn(compiler, 0, I_LNULL); uc_compiler_emit_insn(compiler, 0, I_NES); /* jump after loop body if no next key */ test_jmp = uc_compiler_emit_jmpz(compiler, 0); /* set key and value variables */ if (vvar) { uc_compiler_emit_variable_rw(compiler, vvar->uv, TK_ASSIGN); uc_compiler_emit_insn(compiler, 0, I_POP); } /* set key variable */ uc_compiler_emit_variable_rw(compiler, kvar->uv, TK_ASSIGN); uc_compiler_emit_insn(compiler, 0, I_POP); /* compile loop body */ if (uc_compiler_parse_match(compiler, TK_COLON)) { uc_compiler_enter_scope(compiler); if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR)) uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting 'endfor'"); else uc_compiler_parse_advance(compiler); uc_compiler_leave_scope(compiler); } else { uc_compiler_compile_statement(compiler); } /* jump back to retrieve next key */ uc_compiler_emit_jmp_dest(compiler, 0, skip_jmp + 5); /* back patch conditional jump */ uc_compiler_set_jmpaddr(compiler, test_jmp, chunk->count); /* pop loop variables */ uc_compiler_emit_insn(compiler, 0, I_POP); if (vvar) uc_compiler_emit_insn(compiler, 0, I_POP); uc_compiler_leave_scope(compiler); /* patch up break/continue */ uc_compiler_backpatch(compiler, chunk->count, skip_jmp + 5); } static void uc_compiler_compile_for_count(uc_compiler_t *compiler, bool local, uc_token_t *var) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t test_off = 0, incr_off, skip_off, cond_off = 0; uc_patchlist_t p = { .depth = compiler->scope_depth + 1 }; p.parent = compiler->patchlist; compiler->patchlist = &p; uc_compiler_enter_scope(compiler); /* Initializer ---------------------------------------------------------- */ /* If we parsed at least one label, try continue parsing as variable * expression... */ if (var) { /* We parsed a `local x` or `local x, y` expression, so (re)declare * last label as local initializer variable */ if (local) uc_compiler_declare_local_null(compiler, var->pos, var->uv); uc_compiler_exprstack_push(compiler, TK_FOR, F_ASSIGNABLE); uc_compiler_compile_labelexpr(compiler); uc_compiler_emit_insn(compiler, 0, I_POP); /* If followed by a comma, continue parsing expression */ if (uc_compiler_parse_match(compiler, TK_COMMA)) { /* Is a continuation of a declaration list... */ if (local) { uc_compiler_compile_declexpr(compiler, false); } /* ... otherwise an unrelated expression */ else { uc_compiler_compile_expression(compiler); uc_compiler_emit_insn(compiler, 0, I_POP); } } uc_compiler_exprstack_pop(compiler); } /* ... otherwise try parsing an entire expression (which might be absent) */ else if (!uc_compiler_parse_check(compiler, TK_SCOL)) { uc_compiler_compile_expression(compiler); uc_compiler_emit_insn(compiler, 0, I_POP); } uc_compiler_parse_consume(compiler, TK_SCOL); /* Condition ------------------------------------------------------------ */ if (!uc_compiler_parse_check(compiler, TK_SCOL)) { cond_off = chunk->count; uc_compiler_compile_expression(compiler); test_off = uc_compiler_emit_jmpz(compiler, 0); } uc_compiler_parse_consume(compiler, TK_SCOL); /* jump over incrementer */ skip_off = uc_compiler_emit_jmp(compiler, 0); /* Incrementer ---------------------------------------------------------- */ incr_off = chunk->count; if (!uc_compiler_parse_check(compiler, TK_RPAREN)) { uc_compiler_compile_expression(compiler); uc_compiler_emit_insn(compiler, 0, I_POP); } uc_compiler_parse_consume(compiler, TK_RPAREN); /* if we have a condition, jump back to it, else continue to the loop body */ if (cond_off) uc_compiler_emit_jmp_dest(compiler, 0, cond_off); /* back patch skip address */ uc_compiler_set_jmpaddr(compiler, skip_off, chunk->count); /* Body ----------------------------------------------------------------- */ if (uc_compiler_parse_match(compiler, TK_COLON)) { uc_compiler_enter_scope(compiler); if (!uc_compiler_compile_delimitted_block(compiler, TK_ENDFOR)) uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting 'endfor'"); else uc_compiler_parse_advance(compiler); uc_compiler_leave_scope(compiler); } else { uc_compiler_compile_statement(compiler); } /* jump back to incrementer */ uc_compiler_emit_jmp_dest(compiler, 0, incr_off); /* back patch conditional jump */ if (test_off) uc_compiler_set_jmpaddr(compiler, test_off, chunk->count); uc_compiler_leave_scope(compiler); /* patch up break/continue */ uc_compiler_backpatch(compiler, chunk->count, incr_off); } static void uc_compiler_compile_for(uc_compiler_t *compiler) { uc_token_t keyvar = { 0 }, valvar = { 0 }; bool local; uc_compiler_parse_consume(compiler, TK_LPAREN); /* check the next few tokens and see if we have either a * `let x in` / `let x, y` expression or an ordinary initializer * statement */ local = uc_compiler_parse_match(compiler, TK_LOCAL); if (uc_compiler_parse_match(compiler, TK_LABEL)) { keyvar = compiler->parser->prev; ucv_get(keyvar.uv); if (uc_compiler_parse_match(compiler, TK_COMMA)) { uc_compiler_parse_consume(compiler, TK_LABEL); valvar = compiler->parser->prev; ucv_get(valvar.uv); } /* is a for-in loop */ if (uc_compiler_parse_match(compiler, TK_IN)) { uc_compiler_compile_for_in(compiler, local, &keyvar, valvar.type ? &valvar : NULL); goto out; } } else if (local) { uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting label after 'local'"); goto out; } /* * The previous expression ruled out a for-in loop, so continue parsing * as counting for loop... */ uc_compiler_compile_for_count(compiler, local, valvar.uv ? &valvar : (keyvar.uv ? &keyvar : NULL)); out: ucv_put(keyvar.uv); ucv_put(valvar.uv); } static void uc_compiler_compile_switch(uc_compiler_t *compiler) { size_t i, test_jmp, skip_jmp, next_jmp, value_slot, default_off = 0; uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_patchlist_t p = { .depth = compiler->scope_depth }; uc_locals_t *locals = &compiler->locals; uc_jmplist_t cases = { 0 }; p.parent = compiler->patchlist; compiler->patchlist = &p; uc_compiler_enter_scope(compiler); /* parse and compile match value */ uc_compiler_parse_consume(compiler, TK_LPAREN); uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); uc_compiler_parse_consume(compiler, TK_LBRACE); value_slot = uc_compiler_declare_internal(compiler, 0, "(switch value)"); /* jump to branch tests */ test_jmp = uc_compiler_emit_jmp(compiler, 0); /* parse and compile case matches */ while (!uc_compiler_parse_check(compiler, TK_RBRACE) && !uc_compiler_parse_check(compiler, TK_EOF)) { /* handle `default:` */ if (uc_compiler_parse_match(compiler, TK_DEFAULT)) { if (default_off) { uc_vector_clear(&cases); uc_compiler_syntax_error(compiler, compiler->parser->prev.pos, "more than one switch default case"); return; } uc_compiler_parse_consume(compiler, TK_COLON); /* remember address of default branch */ default_off = chunk->count; /* Store three values in case offset list: * 1) amount of local variables declared so far * 2) beginning of condition expression * 3) end of condition expression * For the `default` case, beginning and end offsets of the * condition expression are equal. */ uc_vector_grow(&cases); cases.entries[cases.count++] = (locals->count - 1) - value_slot; uc_vector_grow(&cases); cases.entries[cases.count++] = chunk->count; uc_vector_grow(&cases); cases.entries[cases.count++] = chunk->count; } /* handle `case …:` */ else if (uc_compiler_parse_match(compiler, TK_CASE)) { /* jump over `case …:` label expression */ skip_jmp = uc_compiler_emit_jmp(compiler, 0); /* compile case value expression */ uc_compiler_compile_expression(compiler); uc_compiler_parse_consume(compiler, TK_COLON); /* Store three values in case offset list: * 1) amount of local variables declared so far * 2) beginning of condition expression * 3) end of condition expression */ uc_vector_grow(&cases); cases.entries[cases.count++] = (locals->count - 1) - value_slot; uc_vector_grow(&cases); cases.entries[cases.count++] = skip_jmp + 5; uc_vector_grow(&cases); cases.entries[cases.count++] = uc_compiler_emit_jmp(compiler, 0); /* patch jump skipping over the case value */ uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count); } /* handle interleaved statement */ else if (cases.count) { uc_compiler_compile_declaration(compiler); } /* a statement or expression preceeding any `default` or `case` is a * syntax error */ else { uc_compiler_syntax_error(compiler, compiler->parser->curr.pos, "Expecting 'case' or 'default'"); return; } } uc_compiler_parse_consume(compiler, TK_RBRACE); /* evaluate case matches */ if (cases.count) { skip_jmp = uc_compiler_emit_jmp(compiler, 0); uc_compiler_set_jmpaddr(compiler, test_jmp, chunk->count); for (i = 0, default_off = cases.count; i < cases.count; i += 3) { /* remember and skip default case */ if (cases.entries[i + 1] == cases.entries[i + 2]) { default_off = i; continue; } /* read switch match value */ uc_compiler_emit_insn(compiler, 0, I_LLOC); uc_compiler_emit_u32(compiler, 0, value_slot); /* jump to case value expression code */ uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[i + 1]); /* patch final case value expression jump back here */ uc_compiler_set_jmpaddr(compiler, cases.entries[i + 2], chunk->count); /* strict equal test */ uc_compiler_emit_insn(compiler, 0, I_EQS); /* conditional jump to next match */ next_jmp = uc_compiler_emit_jmpz(compiler, 0); /* fill local slots */ while (cases.entries[i + 0] > 0) { uc_compiler_emit_insn(compiler, 0, I_LNULL); cases.entries[i + 0]--; } /* jump to target code */ uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[i + 2] + 5); /* patch next jump */ uc_compiler_set_jmpaddr(compiler, next_jmp, chunk->count); } /* handle default case (if any) */ if (default_off < cases.count) { /* fill local slots */ while (cases.entries[default_off + 0] > 0) { uc_compiler_emit_insn(compiler, 0, I_LNULL); cases.entries[default_off + 0]--; } /* jump to target */ uc_compiler_emit_jmp_dest(compiler, 0, cases.entries[default_off + 2]); } uc_compiler_set_jmpaddr(compiler, skip_jmp, chunk->count); } else { uc_compiler_set_jmpaddr(compiler, test_jmp, test_jmp + 5); } uc_vector_clear(&cases); uc_compiler_leave_scope(compiler); uc_compiler_backpatch(compiler, chunk->count, 0); } static void uc_compiler_compile_try(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t try_from = 0, try_to = 0, jmp_off = 0, ehvar_slot = 0; uc_ehranges_t *ranges = &chunk->ehranges; try_from = chunk->count; ehvar_slot = compiler->locals.count; /* Try block ------------------------------------------------------------ */ uc_compiler_enter_scope(compiler); uc_compiler_parse_consume(compiler, TK_LBRACE); while (!uc_compiler_parse_check(compiler, TK_RBRACE) && !uc_compiler_parse_check(compiler, TK_EOF)) uc_compiler_compile_declaration(compiler); uc_compiler_parse_consume(compiler, TK_RBRACE); uc_compiler_leave_scope(compiler); /* jump beyond catch branch */ try_to = chunk->count; jmp_off = uc_compiler_emit_jmp(compiler, 0); /* Catch block ---------------------------------------------------------- */ if (try_to > try_from) { uc_vector_grow(ranges); ranges->entries[ranges->count].from = try_from; ranges->entries[ranges->count].to = try_to; ranges->entries[ranges->count].target = chunk->count; ranges->entries[ranges->count].slot = ehvar_slot; ranges->count++; } uc_compiler_enter_scope(compiler); uc_compiler_parse_consume(compiler, TK_CATCH); /* have exception variable */ if (uc_compiler_parse_match(compiler, TK_LPAREN)) { uc_compiler_parse_consume(compiler, TK_LABEL); uc_compiler_declare_local(compiler, compiler->parser->prev.uv, false); uc_compiler_initialize_local(compiler); uc_compiler_parse_consume(compiler, TK_RPAREN); } /* ... else pop exception object from stack */ else { uc_compiler_emit_insn(compiler, 0, I_POP); } uc_compiler_parse_consume(compiler, TK_LBRACE); while (!uc_compiler_parse_check(compiler, TK_RBRACE) && !uc_compiler_parse_check(compiler, TK_EOF)) uc_compiler_compile_declaration(compiler); uc_compiler_parse_consume(compiler, TK_RBRACE); uc_compiler_leave_scope(compiler); uc_compiler_set_jmpaddr(compiler, jmp_off, chunk->count); } static void uc_compiler_compile_control(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); uc_tokentype_t type = compiler->parser->prev.type; uc_patchlist_t *p = compiler->patchlist; uc_locals_t *locals = &compiler->locals; size_t i, pos = compiler->parser->prev.pos; if (!p) { uc_compiler_syntax_error(compiler, pos, (type == TK_BREAK) ? "break must be inside loop or switch" : "continue must be inside loop"); return; } /* pop locals in scope up to this point */ for (i = locals->count; i > 0 && (size_t)locals->entries[i - 1].depth > p->depth; i--) uc_compiler_emit_insn(compiler, 0, I_POP); uc_vector_grow(p); p->entries[p->count++] = uc_compiler_emit_jmp_dest(compiler, pos, chunk->count + type); uc_compiler_parse_consume(compiler, TK_SCOL); } static void uc_compiler_compile_return(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t off = chunk->count; uc_compiler_compile_expstmt(compiler); /* if we compiled an empty expression statement (`;`), load implicit null */ if (chunk->count == off) uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_LNULL); /* otherwise overwrite the final I_POP instruction with I_RETURN */ else uc_chunk_pop(chunk); uc_compiler_emit_insn(compiler, compiler->parser->prev.pos, I_RETURN); } static void uc_compiler_compile_tplexp(uc_compiler_t *compiler) { uc_chunk_t *chunk = uc_compiler_current_chunk(compiler); size_t off = chunk->count; uc_compiler_compile_expression(compiler); /* XXX: the lexer currently emits a superfluous trailing semicolon... */ uc_compiler_parse_match(compiler, TK_SCOL); uc_compiler_parse_consume(compiler, TK_REXP); if (chunk->count > off) uc_compiler_emit_insn(compiler, 0, I_PRINT); } static void uc_compiler_compile_text(uc_compiler_t *compiler) { uc_compiler_emit_constant(compiler, compiler->parser->prev.pos, compiler->parser->prev.uv); uc_compiler_emit_insn(compiler, 0, I_PRINT); } static void uc_compiler_compile_block(uc_compiler_t *compiler) { uc_compiler_enter_scope(compiler); while (!uc_compiler_parse_check(compiler, TK_RBRACE) && !uc_compiler_parse_check(compiler, TK_EOF)) uc_compiler_compile_declaration(compiler); uc_compiler_parse_consume(compiler, TK_RBRACE); uc_compiler_leave_scope(compiler); } static void uc_compiler_compile_expstmt(uc_compiler_t *compiler) { /* empty statement */ if (uc_compiler_parse_match(compiler, TK_SCOL)) return; uc_compiler_compile_expression(compiler); /* allow omitting final semicolon */ switch (compiler->parser->curr.type) { case TK_RBRACE: case TK_ELIF: case TK_ENDIF: case TK_ENDFOR: case TK_ENDWHILE: case TK_ENDFUNC: case TK_EOF: break; case TK_ELSE: if (!uc_compiler_exprstack_is(compiler, F_ALTBLOCKMODE)) uc_compiler_parse_consume(compiler, TK_SCOL); break; default: uc_compiler_parse_consume(compiler, TK_SCOL); break; } uc_compiler_emit_insn(compiler, 0, I_POP); } static void uc_compiler_compile_statement(uc_compiler_t *compiler) { uc_exprstack_t expr = { .token = compiler->parser->curr.type, .parent = compiler->exprstack }; compiler->exprstack = &expr; if (uc_compiler_parse_match(compiler, TK_IF)) uc_compiler_compile_if(compiler); else if (uc_compiler_parse_match(compiler, TK_WHILE)) uc_compiler_compile_while(compiler); else if (uc_compiler_parse_match(compiler, TK_FOR)) uc_compiler_compile_for(compiler); else if (uc_compiler_parse_match(compiler, TK_SWITCH)) uc_compiler_compile_switch(compiler); else if (uc_compiler_parse_match(compiler, TK_TRY)) uc_compiler_compile_try(compiler); else if (uc_compiler_parse_match(compiler, TK_FUNC)) uc_compiler_compile_function(compiler); else if (uc_compiler_parse_match(compiler, TK_BREAK)) uc_compiler_compile_control(compiler); else if (uc_compiler_parse_match(compiler, TK_CONTINUE)) uc_compiler_compile_control(compiler); else if (uc_compiler_parse_match(compiler, TK_RETURN)) uc_compiler_compile_return(compiler); else if (uc_compiler_parse_match(compiler, TK_TEXT)) uc_compiler_compile_text(compiler); else if (uc_compiler_parse_match(compiler, TK_LEXP)) uc_compiler_compile_tplexp(compiler); else if (uc_compiler_parse_match(compiler, TK_LBRACE)) uc_compiler_compile_block(compiler); else uc_compiler_compile_expstmt(compiler); compiler->exprstack = expr.parent; } static void uc_compiler_compile_declaration(uc_compiler_t *compiler) { if (uc_compiler_parse_match(compiler, TK_LOCAL)) uc_compiler_compile_local(compiler); else if (uc_compiler_parse_match(compiler, TK_CONST)) uc_compiler_compile_const(compiler); else uc_compiler_compile_statement(compiler); if (compiler->parser->synchronizing) uc_compiler_parse_synchronize(compiler); } #endif /* NO_COMPILE */ static uc_function_t * uc_compile_from_source(uc_parse_config_t *config, uc_source_t *source, char **errp) { #ifdef NO_COMPILE if (errp) xasprintf(errp, "Source code compilation not supported\n"); return NULL; #else uc_function_t *fn = NULL; uc_exprstack_t expr = { .token = TK_EOF }; uc_parser_t parser = { .config = config }; uc_compiler_t compiler = { .parser = &parser, .exprstack = &expr }; uc_program_t *prog; prog = uc_program_new(source); uc_lexer_init(&parser.lex, config, source); uc_compiler_init(&compiler, "main", 0, prog, config && config->strict_declarations); uc_compiler_parse_advance(&compiler); while (!uc_compiler_parse_match(&compiler, TK_EOF)) uc_compiler_compile_declaration(&compiler); fn = uc_compiler_finish(&compiler); if (errp) { *errp = parser.error ? parser.error->buf : NULL; free(parser.error); } else { printbuf_free(parser.error); } uc_lexer_free(&parser.lex); return fn; #endif } static uc_function_t * uc_compile_from_bytecode(uc_parse_config_t *config, uc_source_t *source, char **errp) { uc_function_t *fn = NULL; uc_program_t *prog; prog = uc_program_from_file(source->fp, errp); if (prog) { fn = uc_program_entry(prog); if (!fn) { if (errp) xasprintf(errp, "Program file contains no entry function\n"); uc_program_free(prog); } } return fn; } uc_function_t * uc_compile(uc_parse_config_t *config, uc_source_t *source, char **errp) { uc_function_t *fn = NULL; switch (uc_source_type_test(source)) { case UC_SOURCE_TYPE_PLAIN: fn = uc_compile_from_source(config, source, errp); break; case UC_SOURCE_TYPE_PRECOMPILED: fn = uc_compile_from_bytecode(config, source, errp); break; default: if (errp) xasprintf(errp, "Unrecognized source type\n"); break; } return fn; }