Page MenuHomePhorge
Files F2916110

compiler.c
No OneTemporary
Actions

Size
125 KB
Referenced Files
None
Subscribers
None

compiler.c
View Options

#include "silver/ast.h"
#include "silver/engine.h"
#include "silver/compiler.h"
#include "silver/directives.h"
#include "internal.h"
#include "tokens.h"
#include "runtime.h"
#include "ops/coercion.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
typedef struct {
const char *name;
uint32_t name_len;
int depth;
bool is_const;
bool captured;
bool is_tdz;
} sv_local_t;
typedef struct {
int *offsets;
int count;
int cap;
} sv_patch_list_t;
typedef struct {
int loop_start;
sv_patch_list_t breaks;
sv_patch_list_t continues;
int scope_depth;
const char *label;
uint32_t label_len;
} sv_loop_t;
typedef struct {
const char *name;
uint32_t len;
} sv_deferred_export_t;
typedef struct sv_compiler {
ant_t *js;
const char *source;
jsoff_t source_len;
uint8_t *code;
int code_len;
int code_cap;
jsval_t *constants;
int const_count;
int const_cap;
sv_atom_t *atoms;
int atom_count;
int atom_cap;
sv_local_t *locals;
int local_count;
int local_cap;
int max_local_count;
int scope_depth;
int param_locals;
sv_upval_desc_t *upval_descs;
int upvalue_count;
int upvalue_cap;
sv_loop_t *loops;
int loop_count;
int loop_cap;
struct sv_compiler *enclosing;
sv_ast_t **field_inits;
int field_init_count;
int *computed_key_locals;
int param_count;
bool is_arrow;
bool is_strict;
sv_compile_mode_t mode;
bool is_tla;
int try_depth;
int with_depth;
int strict_args_local;
int new_target_local;
int super_local;
const char *pending_label;
uint32_t pending_label_len;
const char *inferred_name;
uint32_t inferred_name_len;
sv_srcpos_t *srcpos;
int srcpos_count;
int srcpos_cap;
uint32_t last_srcpos_off;
uint32_t last_srcpos_end;
sv_deferred_export_t *deferred_exports;
int deferred_export_count;
int deferred_export_cap;
} sv_compiler_t;
static sv_func_t *compile_function_body(
sv_compiler_t *enclosing,
sv_ast_t *node, sv_compile_mode_t mode
);
static void compile_expr(sv_compiler_t *c, sv_ast_t *node);
static void compile_stmt(sv_compiler_t *c, sv_ast_t *node);
static void compile_stmts(sv_compiler_t *c, sv_ast_list_t *list);
static void compile_binary(sv_compiler_t *c, sv_ast_t *node);
static void compile_unary(sv_compiler_t *c, sv_ast_t *node);
static void compile_update(sv_compiler_t *c, sv_ast_t *node);
static void compile_assign(sv_compiler_t *c, sv_ast_t *node);
static void compile_lhs_set(sv_compiler_t *c, sv_ast_t *target, bool keep);
static void compile_ternary(sv_compiler_t *c, sv_ast_t *node);
static void compile_tail_return_expr(sv_compiler_t *c, sv_ast_t *expr);
static void compile_typeof(sv_compiler_t *c, sv_ast_t *node);
static void compile_delete(sv_compiler_t *c, sv_ast_t *node);
static void compile_template(sv_compiler_t *c, sv_ast_t *node);
static void compile_call(sv_compiler_t *c, sv_ast_t *node);
static void compile_new(sv_compiler_t *c, sv_ast_t *node);
static void compile_member(sv_compiler_t *c, sv_ast_t *node);
static void compile_optional(sv_compiler_t *c, sv_ast_t *node);
static void compile_optional_get(sv_compiler_t *c, sv_ast_t *node);
static void compile_array(sv_compiler_t *c, sv_ast_t *node);
static void compile_object(sv_compiler_t *c, sv_ast_t *node);
static void compile_func_expr(sv_compiler_t *c, sv_ast_t *node);
static void compile_array_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep);
static void compile_object_destructure(sv_compiler_t *c, sv_ast_t *pat, bool keep);
static void compile_var_decl(sv_compiler_t *c, sv_ast_t *node);
static void compile_import_decl(sv_compiler_t *c, sv_ast_t *node);
static void compile_export_decl(sv_compiler_t *c, sv_ast_t *node);
static void compile_destructure_binding(sv_compiler_t *c, sv_ast_t *pat, sv_var_kind_t kind);
static void compile_if(sv_compiler_t *c, sv_ast_t *node);
static void compile_while(sv_compiler_t *c, sv_ast_t *node);
static void compile_do_while(sv_compiler_t *c, sv_ast_t *node);
static void compile_for(sv_compiler_t *c, sv_ast_t *node);
static void compile_for_in(sv_compiler_t *c, sv_ast_t *node);
static void compile_for_of(sv_compiler_t *c, sv_ast_t *node);
static void compile_break(sv_compiler_t *c, sv_ast_t *node);
static void compile_continue(sv_compiler_t *c, sv_ast_t *node);
static void compile_try(sv_compiler_t *c, sv_ast_t *node);
static void compile_switch(sv_compiler_t *c, sv_ast_t *node);
static void compile_label(sv_compiler_t *c, sv_ast_t *node);
static void compile_class(sv_compiler_t *c, sv_ast_t *node);
static const char *pin_source_text(const char *source, jsoff_t source_len) {
if (!source || source_len <= 0) return source;
const char *pinned = code_arena_alloc(source, (size_t)source_len);
return pinned ? pinned : source;
}
static void emit(sv_compiler_t *c, uint8_t byte) {
if (c->code_len >= c->code_cap) {
c->code_cap = c->code_cap ? c->code_cap * 2 : 256;
c->code = realloc(c->code, (size_t)c->code_cap);
}
c->code[c->code_len++] = byte;
}
static void emit_u16(sv_compiler_t *c, uint16_t val) {
emit(c, (uint8_t)(val & 0xFF));
emit(c, (uint8_t)(val >> 8));
}
static void emit_u32(sv_compiler_t *c, uint32_t val) {
emit(c, (uint8_t)(val & 0xFF));
emit(c, (uint8_t)((val >> 8) & 0xFF));
emit(c, (uint8_t)((val >> 16) & 0xFF));
emit(c, (uint8_t)((val >> 24) & 0xFF));
}
static void emit_i32(sv_compiler_t *c, int32_t val) {
uint32_t u;
memcpy(&u, &val, 4);
emit_u32(c, u);
}
static void emit_op(sv_compiler_t *c, sv_op_t op) {
emit(c, (uint8_t)op);
}
static void emit_srcpos(sv_compiler_t *c, sv_ast_t *node) {
if (!node) return;
const char *code = c->source;
jsoff_t clen = c->source_len;
if (!code || clen <= 0) return;
uint32_t off = node->src_off;
if (off > clen) off = (uint32_t)clen;
uint32_t end = node->src_end;
if (end > clen) end = (uint32_t)clen;
if (end < off) end = off;
if (end == off && off < (uint32_t)clen) end = off + 1;
if (end == off) return;
uint32_t line = 1, col = 1;
for (uint32_t i = 0; i < off; i++) {
if (code[i] == '\n') { line++; col = 1; }
else col++;
}
if (c->srcpos_count > 0 && c->last_srcpos_off == off && c->last_srcpos_end == end) return;
if (c->srcpos_count >= c->srcpos_cap) {
c->srcpos_cap = c->srcpos_cap ? c->srcpos_cap * 2 : 32;
c->srcpos = realloc(c->srcpos, (size_t)c->srcpos_cap * sizeof(sv_srcpos_t));
}
c->srcpos[c->srcpos_count++] = (sv_srcpos_t){
.bc_offset = (uint32_t)c->code_len,
.line = line,
.col = col,
.src_off = off,
.src_end = end,
};
c->last_srcpos_off = off;
c->last_srcpos_end = end;
}
static void patch_u32(sv_compiler_t *c, int offset, uint32_t val) {
c->code[offset] = (uint8_t)(val & 0xFF);
c->code[offset + 1] = (uint8_t)((val >> 8) & 0xFF);
c->code[offset + 2] = (uint8_t)((val >> 16) & 0xFF);
c->code[offset + 3] = (uint8_t)((val >> 24) & 0xFF);
}
static int add_constant(sv_compiler_t *c, jsval_t val) {
if (c->const_count >= c->const_cap) {
c->const_cap = c->const_cap ? c->const_cap * 2 : 16;
c->constants = realloc(c->constants, (size_t)c->const_cap * sizeof(jsval_t));
}
c->constants[c->const_count] = val;
return c->const_count++;
}
static void emit_constant(sv_compiler_t *c, jsval_t val) {
int idx = add_constant(c, val);
if (idx <= 255) {
emit_op(c, OP_CONST8);
emit(c, (uint8_t)idx);
} else {
emit_op(c, OP_CONST);
emit_u32(c, (uint32_t)idx);
}
}
static void emit_number(sv_compiler_t *c, double num) {
if (num >= -128 && num <= 127 && num == (int)num && num != -0.0) {
emit_op(c, OP_CONST_I8);
emit(c, (uint8_t)(int8_t)num);
} else emit_constant(c, tov(num));
}
static inline bool is_quoted_ident_key(const sv_ast_t *node) {
if (!node || node->type != N_IDENT || !node->str || node->len < 2) return false;
char open = node->str[0];
char close = node->str[node->len - 1];
return ((open == '\'' && close == '\'') || (open == '"' && close == '"'));
}
static inline bool is_invalid_cooked_string(const sv_ast_t *node) {
return node && (node->flags & FN_INVALID_COOKED);
}
static inline jsval_t ast_string_const(sv_compiler_t *c, const sv_ast_t *node) {
if (!node || !node->str) return js_mkstr(c->js, "", 0);
return js_mkstr(c->js, node->str, node->len);
}
static inline void compile_static_property_key(sv_compiler_t *c, sv_ast_t *key) {
if (!key) {
emit_op(c, OP_UNDEF);
return;
}
if (key->type == N_STRING) {
emit_constant(c, ast_string_const(c, key));
return;
}
if (key->type == N_NUMBER) {
char buf[32];
int n = snprintf(buf, sizeof(buf), "%g", key->num);
emit_constant(c, js_mkstr(c->js, buf, (size_t)n));
return;
}
if (key->type == N_IDENT) {
if (is_quoted_ident_key(key))
emit_constant(c, js_mkstr(c->js, key->str + 1, key->len - 2));
else
emit_constant(c, js_mkstr(c->js, key->str, key->len));
return;
}
compile_expr(c, key);
}
static int add_atom(sv_compiler_t *c, const char *str, uint32_t len) {
for (int i = 0; i < c->atom_count; i++) {
if (c->atoms[i].len == len && memcmp(c->atoms[i].str, str, len) == 0)
return i;
}
if (c->atom_count >= c->atom_cap) {
c->atom_cap = c->atom_cap ? c->atom_cap * 2 : 16;
c->atoms = realloc(c->atoms, (size_t)c->atom_cap * sizeof(sv_atom_t));
}
char *copy = code_arena_bump(len);
memcpy(copy, str, len);
c->atoms[c->atom_count] = (sv_atom_t){ .str = copy, .len = len };
return c->atom_count++;
}
static void emit_atom_op(sv_compiler_t *c, sv_op_t op, const char *str, uint32_t len) {
int idx = add_atom(c, str, len);
emit_op(c, op);
emit_u32(c, (uint32_t)idx);
}
static inline void emit_set_function_name(
sv_compiler_t *c,
const char *name, uint32_t len
) {
if (!name) { name = ""; len = 0; }
emit_atom_op(c, OP_SET_NAME, name, len);
}
static void emit_const_assign_error(sv_compiler_t *c, const char *name, uint32_t len) {
static const char prefix[] = "Assignment to constant variable '";
static const char suffix[] = "'";
uint32_t mlen = (uint32_t)(sizeof(prefix) - 1 + len + sizeof(suffix) - 1);
char *buf = code_arena_bump(mlen);
memcpy(buf, prefix, sizeof(prefix) - 1);
memcpy(buf + sizeof(prefix) - 1, name, len);
memcpy(buf + sizeof(prefix) - 1 + len, suffix, sizeof(suffix) - 1);
int atom = add_atom(c, buf, mlen);
emit_op(c, OP_THROW_ERROR);
emit_u32(c, (uint32_t)atom);
emit(c, (uint8_t)JS_ERR_TYPE);
}
static inline bool is_ident_str(
const char *name, uint32_t len,
const char *lit, uint32_t lit_len
) {
return len == lit_len && memcmp(name, lit, lit_len) == 0;
}
static inline bool is_strict_restricted_ident(const char *name, uint32_t len) {
return
is_ident_str(name, len, "eval", 4) ||
is_ident_str(name, len, "arguments", 9);
}
static inline bool is_repl_top_level(const sv_compiler_t *c) {
return
c->mode == SV_COMPILE_REPL && c->scope_depth == 0 &&
c->enclosing && !c->enclosing->enclosing &&
!c->is_strict;
}
static inline bool has_completion_value(const sv_compiler_t *c) {
return c && (c->mode == SV_COMPILE_EVAL || c->mode == SV_COMPILE_REPL);
}
static inline bool has_implicit_arguments_obj(const sv_compiler_t *c) {
return c && !c->is_arrow && c->enclosing;
}
static int resolve_local(sv_compiler_t *c, const char *name, uint32_t len) {
for (int i = c->local_count - 1; i >= 0; i--) {
sv_local_t *loc = &c->locals[i];
if (loc->name_len == len && memcmp(loc->name, name, len) == 0)
return i;
}
return -1;
}
static int add_local(
sv_compiler_t *c, const char *name, uint32_t len,
bool is_const, int depth
) {
if (c->local_count >= c->local_cap) {
c->local_cap = c->local_cap ? c->local_cap * 2 : 16;
c->locals = realloc(c->locals, (size_t)c->local_cap * sizeof(sv_local_t));
}
int idx = c->local_count++;
if (c->local_count > c->max_local_count)
c->max_local_count = c->local_count;
c->locals[idx] = (sv_local_t){
.name = name, .name_len = len,
.depth = depth, .is_const = is_const, .captured = false,
};
return idx;
}
static int ensure_local_at_depth(
sv_compiler_t *c, const char *name, uint32_t len,
bool is_const, int depth
) {
int local = resolve_local(c, name, len);
if (local != -1 && c->locals[local].depth == depth)
return local;
return add_local(c, name, len, is_const, depth);
}
static int local_to_frame_slot(sv_compiler_t *c, int local_idx) {
if (c->locals[local_idx].depth == -1) return local_idx;
return c->param_count + (local_idx - c->param_locals);
}
static int resolve_local_slot(sv_compiler_t *c, const char *name, uint32_t len) {
int local = resolve_local(c, name, len);
if (local == -1 || c->locals[local].depth == -1) return -1;
int slot = local - c->param_locals;
return (slot >= 0 && slot <= 255) ? slot : -1;
}
static int add_upvalue(sv_compiler_t *c, uint16_t index, bool is_local, bool is_const) {
for (int i = 0; i < c->upvalue_count; i++) {
if (c->upval_descs[i].index == index &&
c->upval_descs[i].is_local == is_local)
return i;
}
if (c->upvalue_count >= c->upvalue_cap) {
c->upvalue_cap = c->upvalue_cap ? c->upvalue_cap * 2 : 8;
c->upval_descs = realloc(
c->upval_descs,
(size_t)c->upvalue_cap * sizeof(sv_upval_desc_t));
}
int idx = c->upvalue_count++;
c->upval_descs[idx] = (sv_upval_desc_t){
.index = index, .is_local = is_local, .is_const = is_const,
};
return idx;
}
static int resolve_super_upvalue(sv_compiler_t *c) {
if (!c->enclosing) return -1;
sv_compiler_t *enc = c->enclosing;
if (!enc->is_arrow) {
if (enc->super_local < 0) return -1;
enc->locals[enc->super_local].captured = true;
uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->super_local);
return add_upvalue(c, slot, true, false);
}
int upvalue = resolve_super_upvalue(enc);
if (upvalue == -1) return -1;
return add_upvalue(c, (uint16_t)upvalue, false, false);
}
static int resolve_arguments_upvalue(sv_compiler_t *c) {
if (!c->enclosing) return -1;
sv_compiler_t *enc = c->enclosing;
if (!enc->is_arrow) {
if (enc->strict_args_local < 0) return -1;
enc->locals[enc->strict_args_local].captured = true;
uint16_t slot = (uint16_t)local_to_frame_slot(enc, enc->strict_args_local);
return add_upvalue(c, slot, true, false);
}
int upvalue = resolve_arguments_upvalue(enc);
if (upvalue == -1) return -1;
return add_upvalue(c, (uint16_t)upvalue, false, false);
}
static int resolve_upvalue(sv_compiler_t *c, const char *name, uint32_t len) {
if (!c->enclosing) return -1;
int local = resolve_local(c->enclosing, name, len);
if (local != -1) {
c->enclosing->locals[local].captured = true;
uint16_t slot = (uint16_t)local_to_frame_slot(c->enclosing, local);
return add_upvalue(c, slot, true, c->enclosing->locals[local].is_const);
}
int upvalue = resolve_upvalue(c->enclosing, name, len);
if (upvalue != -1) {
bool uv_const = c->enclosing->upval_descs[upvalue].is_const;
return add_upvalue(c, (uint16_t)upvalue, false, uv_const);
}
return -1;
}
static int emit_jump(sv_compiler_t *c, sv_op_t op) {
emit_op(c, op);
int offset = c->code_len;
emit_i32(c, 0);
return offset;
}
static void patch_jump(sv_compiler_t *c, int offset) {
int32_t delta = (int32_t)(c->code_len - offset - 4);
patch_u32(c, offset, (uint32_t)delta);
}
static void emit_loop(sv_compiler_t *c, int loop_start) {
emit_op(c, OP_JMP);
int32_t delta = (int32_t)(loop_start - c->code_len - 4);
emit_i32(c, delta);
}
static void patch_list_add(sv_patch_list_t *pl, int offset) {
if (pl->count >= pl->cap) {
pl->cap = pl->cap ? pl->cap * 2 : 4;
pl->offsets = realloc(pl->offsets, (size_t)pl->cap * sizeof(int));
}
pl->offsets[pl->count++] = offset;
}
static void patch_list_resolve(sv_compiler_t *c, sv_patch_list_t *pl) {
for (int i = 0; i < pl->count; i++)
patch_jump(c, pl->offsets[i]);
free(pl->offsets);
*pl = (sv_patch_list_t){0};
}
static void push_loop(
sv_compiler_t *c, int loop_start,
const char *label, uint32_t label_len
) {
if (c->loop_count >= c->loop_cap) {
c->loop_cap = c->loop_cap ? c->loop_cap * 2 : 4;
c->loops = realloc(c->loops, (size_t)c->loop_cap * sizeof(sv_loop_t));
}
if (!label && c->pending_label) {
label = c->pending_label;
label_len = c->pending_label_len;
c->pending_label = NULL;
c->pending_label_len = 0;
}
c->loops[c->loop_count++] = (sv_loop_t){
.loop_start = loop_start,
.scope_depth = c->scope_depth,
.label = label, .label_len = label_len,
};
}
static void pop_loop(sv_compiler_t *c) {
sv_loop_t *loop = &c->loops[--c->loop_count];
patch_list_resolve(c, &loop->breaks);
free(loop->continues.offsets);
}
static void begin_scope(sv_compiler_t *c) {
c->scope_depth++;
}
static void end_scope(sv_compiler_t *c) {
while (
c->local_count > 0 &&
c->locals[c->local_count - 1].depth >= c->scope_depth
) {
sv_local_t *loc = &c->locals[c->local_count - 1];
if (loc->captured) {
int frame_slot = local_to_frame_slot(c, c->local_count - 1);
emit_op(c, OP_CLOSE_UPVAL);
emit_u16(c, (uint16_t)frame_slot);
}
c->local_count--;
}
c->scope_depth--;
}
static void emit_close_upvals(sv_compiler_t *c) {
for (int i = 0; i < c->local_count; i++) {
if (c->locals[i].captured) {
int frame_slot = local_to_frame_slot(c, i);
emit_op(c, OP_CLOSE_UPVAL);
emit_u16(c, (uint16_t)frame_slot);
return;
}}
}
static void emit_with_get(
sv_compiler_t *c, const char *name, uint32_t len,
uint8_t fb_kind, uint16_t fb_idx
) {
int atom = add_atom(c, name, len);
emit_op(c, OP_WITH_GET_VAR);
emit_u32(c, (uint32_t)atom);
emit(c, fb_kind);
emit_u16(c, fb_idx);
}
static void emit_with_put(
sv_compiler_t *c, const char *name, uint32_t len,
uint8_t fb_kind, uint16_t fb_idx
) {
int atom = add_atom(c, name, len);
emit_op(c, OP_WITH_PUT_VAR);
emit_u32(c, (uint32_t)atom);
emit(c, fb_kind);
emit_u16(c, fb_idx);
}
static void emit_get_local(sv_compiler_t *c, int local_idx);
static void emit_put_local(sv_compiler_t *c, int local_idx);
static void emit_get_var(sv_compiler_t *c, const char *name, uint32_t len) {
int local = resolve_local(c, name, len);
if (local != -1) {
if (c->with_depth > 0) {
uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
uint16_t idx = kind == WITH_FB_ARG
? (uint16_t)local
: (uint16_t)(local - c->param_locals);
emit_with_get(c, name, len, kind, idx);
return;
}
if (c->locals[local].depth == -1) {
emit_op(c, OP_GET_ARG);
emit_u16(c, (uint16_t)local);
} else {
int slot = local - c->param_locals;
if (c->locals[local].is_tdz) {
int ai = add_atom(c, name, len);
emit_op(c, OP_GET_LOCAL_CHK);
emit_u16(c, (uint16_t)slot);
emit_u32(c, (uint32_t)ai);
} else if (slot <= 255) {
emit_op(c, OP_GET_LOCAL8);
emit(c, (uint8_t)slot);
} else {
emit_op(c, OP_GET_LOCAL);
emit_u16(c, (uint16_t)slot);
}
}
return;
}
int upval = resolve_upvalue(c, name, len);
if (upval != -1) {
if (c->with_depth > 0) {
emit_with_get(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
return;
}
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)upval);
return;
}
if (is_ident_str(name, len, "arguments", 9)) {
if (has_implicit_arguments_obj(c)) {
if (c->strict_args_local >= 0) {
emit_get_local(c, c->strict_args_local);
} else {
emit_op(c, OP_SPECIAL_OBJ);
emit(c, 0);
}
return;
}
if (c->is_arrow) {
int args_upval = resolve_arguments_upvalue(c);
if (args_upval != -1) {
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)args_upval);
return;
}
}
}
if (c->is_arrow && is_ident_str(name, len, "super", 5)) {
int super_upval = resolve_super_upvalue(c);
if (super_upval != -1) {
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)super_upval);
return;
}
}
if (c->with_depth > 0)
emit_with_get(c, name, len, WITH_FB_GLOBAL, 0);
else
emit_atom_op(c, OP_GET_GLOBAL, name, len);
}
static void emit_set_var(sv_compiler_t *c, const char *name, uint32_t len, bool keep) {
int local = resolve_local(c, name, len);
if (local != -1) {
if (c->locals[local].is_const) {
emit_const_assign_error(c, name, len);
return;
}
if (c->with_depth > 0) {
uint8_t kind = c->locals[local].depth == -1 ? WITH_FB_ARG : WITH_FB_LOCAL;
uint16_t idx = kind == WITH_FB_ARG
? (uint16_t)local
: (uint16_t)(local - c->param_locals);
if (keep) emit_op(c, OP_DUP);
emit_with_put(c, name, len, kind, idx);
return;
}
if (c->locals[local].depth == -1) {
emit_op(c, keep ? OP_SET_ARG : OP_PUT_ARG);
emit_u16(c, (uint16_t)local);
} else {
int slot = local - c->param_locals;
sv_op_t op = keep
? (slot <= 255 ? OP_SET_LOCAL8 : OP_SET_LOCAL)
: (slot <= 255 ? OP_PUT_LOCAL8 : OP_PUT_LOCAL);
emit_op(c, op);
if (slot <= 255) emit(c, (uint8_t)slot);
else emit_u16(c, (uint16_t)slot);
}
return;
}
int upval = resolve_upvalue(c, name, len);
if (upval != -1) {
if (c->upval_descs[upval].is_const) {
emit_const_assign_error(c, name, len);
return;
}
if (c->with_depth > 0) {
if (keep) emit_op(c, OP_DUP);
emit_with_put(c, name, len, WITH_FB_UPVAL, (uint16_t)upval);
return;
}
emit_op(c, keep ? OP_SET_UPVAL : OP_PUT_UPVAL);
emit_u16(c, (uint16_t)upval);
return;
}
if (c->with_depth > 0) {
if (keep) emit_op(c, OP_DUP);
emit_with_put(c, name, len, WITH_FB_GLOBAL, 0);
} else {
if (keep) {
emit_op(c, OP_DUP);
emit_atom_op(c, OP_PUT_GLOBAL, name, len);
} else emit_atom_op(c, OP_PUT_GLOBAL, name, len);
}
}
static void emit_put_local(sv_compiler_t *c, int local_idx) {
int slot = local_idx - c->param_locals;
if (slot <= 255) { emit_op(c, OP_PUT_LOCAL8); emit(c, (uint8_t)slot); }
else { emit_op(c, OP_PUT_LOCAL); emit_u16(c, (uint16_t)slot); }
}
static void emit_get_local(sv_compiler_t *c, int local_idx) {
int slot = local_idx - c->param_locals;
if (slot <= 255) { emit_op(c, OP_GET_LOCAL8); emit(c, (uint8_t)slot); }
else { emit_op(c, OP_GET_LOCAL); emit_u16(c, (uint16_t)slot); }
}
static inline bool is_ident_name(sv_ast_t *node, const char *name) {
size_t n = strlen(name);
return node
&& node->type == N_IDENT && node->len == (uint32_t)n
&& memcmp(node->str, name, n) == 0;
}
static void hoist_var_pattern(sv_compiler_t *c, sv_ast_t *pat) {
if (!pat) return;
switch (pat->type) {
case N_IDENT:
if (resolve_local(c, pat->str, pat->len) == -1)
add_local(c, pat->str, pat->len, false, 0);
break;
case N_ARRAY: case N_ARRAY_PAT:
for (int i = 0; i < pat->args.count; i++)
hoist_var_pattern(c, pat->args.items[i]);
break;
case N_OBJECT: case N_OBJECT_PAT:
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_PROPERTY)
hoist_var_pattern(c, prop->right);
else if (prop->type == N_REST || prop->type == N_SPREAD)
hoist_var_pattern(c, prop->right);
}
break;
case N_ASSIGN_PAT:
hoist_var_pattern(c, pat->left);
break;
case N_ASSIGN:
hoist_var_pattern(c, pat->left);
break;
case N_REST: case N_SPREAD:
hoist_var_pattern(c, pat->right);
break;
default:
break;
}
}
static void hoist_var_decls(sv_compiler_t *c, sv_ast_t *node) {
if (!node) return;
switch (node->type) {
case N_VAR:
if (node->var_kind == VAR_VAR) {
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *decl = node->args.items[i];
if (decl->type == N_VARDECL && decl->left)
hoist_var_pattern(c, decl->left);
}
}
break;
case N_BLOCK:
for (int i = 0; i < node->args.count; i++)
hoist_var_decls(c, node->args.items[i]);
break;
case N_IF:
hoist_var_decls(c, node->left);
hoist_var_decls(c, node->right);
break;
case N_WHILE: case N_DO_WHILE: case N_LABEL:
hoist_var_decls(c, node->body);
break;
case N_FOR:
hoist_var_decls(c, node->init);
hoist_var_decls(c, node->body);
break;
case N_FOR_IN: case N_FOR_OF: case N_FOR_AWAIT_OF:
hoist_var_decls(c, node->left);
hoist_var_decls(c, node->body);
break;
case N_SWITCH:
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *cas = node->args.items[i];
for (int j = 0; j < cas->args.count; j++)
hoist_var_decls(c, cas->args.items[j]);
}
break;
case N_TRY:
hoist_var_decls(c, node->body);
hoist_var_decls(c, node->catch_body);
hoist_var_decls(c, node->finally_body);
break;
case N_EXPORT:
hoist_var_decls(c, node->left);
break;
default: break;
}
}
static void hoist_lexical_pattern(sv_compiler_t *c, sv_ast_t *pat,
bool is_const) {
if (!pat) return;
switch (pat->type) {
case N_IDENT:
ensure_local_at_depth(c, pat->str, pat->len, is_const, c->scope_depth);
break;
case N_ASSIGN_PAT:
hoist_lexical_pattern(c, pat->left, is_const);
break;
case N_REST:
case N_SPREAD:
hoist_lexical_pattern(c, pat->right, is_const);
break;
case N_ARRAY:
case N_ARRAY_PAT:
for (int i = 0; i < pat->args.count; i++)
hoist_lexical_pattern(c, pat->args.items[i], is_const);
break;
case N_OBJECT:
case N_OBJECT_PAT:
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_PROPERTY)
hoist_lexical_pattern(c, prop->right, is_const);
}
break;
default:
break;
}
}
static void annex_b_collect_funcs(sv_ast_t *node, sv_ast_list_t *out) {
if (!node) return;
if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
sv_ast_list_push(out, node);
return;
}
if (node->type == N_IF) {
annex_b_collect_funcs(node->left, out);
annex_b_collect_funcs(node->right, out);
} else if (node->type == N_LABEL) annex_b_collect_funcs(node->body, out);
}
static void hoist_lexical_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
for (int i = 0; i < stmts->count; i++) {
sv_ast_t *node = stmts->items[i];
if (!node) continue;
sv_ast_t *decl_node = (node->type == N_EXPORT) ? node->left : node;
if (!decl_node) continue;
if (decl_node->type == N_VAR && decl_node->var_kind != VAR_VAR) {
bool is_const = (decl_node->var_kind == VAR_CONST);
int lb = c->local_count;
for (int j = 0; j < decl_node->args.count; j++) {
sv_ast_t *decl = decl_node->args.items[j];
if (!decl || decl->type != N_VARDECL || !decl->left) continue;
hoist_lexical_pattern(c, decl->left, is_const);
}
for (int j = lb; j < c->local_count; j++) {
c->locals[j].is_tdz = true;
int slot = j - c->param_locals;
emit_op(c, OP_SET_LOCAL_UNDEF);
emit_u16(c, (uint16_t)slot);
}
} else if (decl_node->type == N_IMPORT_DECL) {
for (int j = 0; j < decl_node->args.count; j++) {
sv_ast_t *spec = decl_node->args.items[j];
if (!spec || spec->type != N_IMPORT_SPEC ||
!spec->right || spec->right->type != N_IDENT)
continue;
ensure_local_at_depth(c, spec->right->str, spec->right->len, true, c->scope_depth);
}
} else if (decl_node->type == N_CLASS && decl_node->str) {
int lb = c->local_count;
ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
if (c->local_count > lb) {
c->locals[c->local_count - 1].is_tdz = true;
int slot = (c->local_count - 1) - c->param_locals;
emit_op(c, OP_SET_LOCAL_UNDEF);
emit_u16(c, (uint16_t)slot);
}
} else if (decl_node->type == N_FUNC && decl_node->str && !(decl_node->flags & FN_ARROW)) {
ensure_local_at_depth(c, decl_node->str, decl_node->len, false, c->scope_depth);
}
if (!c->is_strict && (decl_node->type == N_IF || decl_node->type == N_LABEL)) {
sv_ast_list_t funcs = {0};
annex_b_collect_funcs(decl_node, &funcs);
for (int j = 0; j < funcs.count; j++) {
sv_ast_t *fn = funcs.items[j];
if (resolve_local(c, fn->str, fn->len) == -1)
add_local(c, fn->str, fn->len, false, c->scope_depth);
}
}
}
}
static void hoist_one_func(sv_compiler_t *c, sv_ast_t *node) {
sv_func_t *fn = compile_function_body(c, node, SV_COMPILE_SCRIPT);
if (!fn) return;
int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
emit_op(c, OP_CLOSURE);
emit_u32(c, (uint32_t)idx);
emit_set_function_name(c, node->str, node->len);
if (is_repl_top_level(c)) {
emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
} else {
int local = resolve_local(c, node->str, node->len);
emit_put_local(c, local);
}
}
static void hoist_func_decls(sv_compiler_t *c, sv_ast_list_t *stmts) {
for (int i = 0; i < stmts->count; i++) {
sv_ast_t *node = stmts->items[i];
if (node && node->type == N_EXPORT && node->left)
node = node->left;
if (!node) continue;
if (node->type == N_FUNC && node->str && !(node->flags & FN_ARROW)) {
hoist_one_func(c, node);
}
if (!c->is_strict && (node->type == N_IF || node->type == N_LABEL)) {
sv_ast_list_t funcs = {0};
annex_b_collect_funcs(node, &funcs);
for (int j = 0; j < funcs.count; j++)
hoist_one_func(c, funcs.items[j]);
}
}
}
static void compile_expr(sv_compiler_t *c, sv_ast_t *node) {
if (!node) { emit_op(c, OP_UNDEF); return; }
emit_srcpos(c, node);
switch (node->type) {
case N_NUMBER:
emit_number(c, node->num);
break;
case N_STRING: {
emit_constant(c, ast_string_const(c, node));
break;
}
case N_BIGINT: {
bool neg = false;
const char *digits = node->str;
uint32_t dlen = node->len;
if (dlen > 0 && digits[0] == '-') {
neg = true; digits++; dlen--;
}
if (dlen > 0 && digits[dlen - 1] == 'n') dlen--;
jsval_t bi = js_mkbigint(c->js, digits, dlen, neg);
emit_constant(c, bi);
break;
}
case N_BOOL:
emit_op(c, node->num != 0.0 ? OP_TRUE : OP_FALSE);
break;
case N_NULL:
emit_op(c, OP_NULL);
break;
case N_UNDEF:
emit_op(c, OP_UNDEF);
break;
case N_THIS:
emit_op(c, OP_THIS);
break;
case N_GLOBAL_THIS:
emit_op(c, OP_GLOBAL);
break;
case N_NEW_TARGET: {
static const char nt_name[] = "\x01new.target";
int local = resolve_local(c, nt_name, sizeof(nt_name) - 1);
if (local >= 0) {
emit_get_local(c, local);
} else {
int upval = resolve_upvalue(c, nt_name, sizeof(nt_name) - 1);
if (upval >= 0) {
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)upval);
} else {
emit_op(c, OP_UNDEF);
}
}
break;
}
case N_IDENT:
emit_get_var(c, node->str, node->len);
break;
case N_BINARY:
compile_binary(c, node);
break;
case N_UNARY:
compile_unary(c, node);
break;
case N_UPDATE:
compile_update(c, node);
break;
case N_ASSIGN:
compile_assign(c, node);
break;
case N_TERNARY:
compile_ternary(c, node);
break;
case N_CALL:
compile_call(c, node);
break;
case N_NEW:
compile_new(c, node);
break;
case N_MEMBER:
compile_member(c, node);
break;
case N_OPTIONAL:
compile_optional(c, node);
break;
case N_ARRAY:
compile_array(c, node);
break;
case N_OBJECT:
compile_object(c, node);
break;
case N_FUNC:
compile_func_expr(c, node);
break;
case N_CLASS:
compile_class(c, node);
break;
case N_SEQUENCE:
compile_expr(c, node->left);
emit_op(c, OP_POP);
compile_expr(c, node->right);
break;
case N_TYPEOF:
compile_typeof(c, node);
break;
case N_VOID:
compile_expr(c, node->right);
emit_op(c, OP_VOID);
break;
case N_DELETE:
compile_delete(c, node);
break;
case N_SPREAD:
compile_expr(c, node->right);
break;
case N_TEMPLATE:
compile_template(c, node);
break;
case N_AWAIT:
compile_expr(c, node->right);
emit_op(c, OP_AWAIT);
if (c->enclosing && !c->enclosing->enclosing)
c->is_tla = true;
break;
case N_YIELD:
if (node->right) compile_expr(c, node->right);
else emit_op(c, OP_UNDEF);
emit_op(c, node->flags ? OP_YIELD_STAR : OP_YIELD);
break;
case N_TAGGED_TEMPLATE: {
compile_expr(c, node->left);
sv_ast_t *tpl = node->right;
int n = tpl->args.count;
int n_strings = 0, n_exprs = 0;
for (int i = 0; i < n; i++) {
if (tpl->args.items[i]->type == N_STRING) n_strings++;
else n_exprs++;
}
int cache_idx = add_constant(c, js_mkundef());
emit_op(c, OP_CONST);
emit_u32(c, (uint32_t)cache_idx);
int skip_jump = emit_jump(c, OP_JMP_TRUE_PEEK);
emit_op(c, OP_POP);
for (int i = 0; i < n; i++) {
sv_ast_t *item = tpl->args.items[i];
if (item->type != N_STRING) continue;
if (is_invalid_cooked_string(item))
emit_op(c, OP_UNDEF);
else emit_constant(c, ast_string_const(c, item));
}
emit_op(c, OP_ARRAY);
emit_u16(c, (uint16_t)n_strings);
for (int i = 0; i < n; i++) {
sv_ast_t *item = tpl->args.items[i];
if (item->type != N_STRING) continue;
const char *raw = item->aux ? item->aux : item->str;
uint32_t raw_len = item->aux ? item->aux_len : item->len;
emit_constant(c, js_mkstr(c->js, raw ? raw : "", raw_len));
}
emit_op(c, OP_ARRAY);
emit_u16(c, (uint16_t)n_strings);
emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
emit_op(c, OP_ROT3L);
emit_op(c, OP_CALL_METHOD);
emit_u16(c, 1);
emit_atom_op(c, OP_DEFINE_FIELD, "raw", 3);
emit_atom_op(c, OP_GET_GLOBAL, "Object", 6);
emit_atom_op(c, OP_GET_FIELD2, "freeze", 6);
emit_op(c, OP_ROT3L);
emit_op(c, OP_CALL_METHOD);
emit_u16(c, 1);
emit_op(c, OP_DUP);
emit_op(c, OP_PUT_CONST);
emit_u32(c, (uint32_t)cache_idx);
patch_jump(c, skip_jump);
for (int i = 0; i < n; i++) {
sv_ast_t *item = tpl->args.items[i];
if (item->type == N_STRING) continue;
compile_expr(c, item);
}
emit_op(c, OP_CALL);
emit_u16(c, (uint16_t)(1 + n_exprs));
break;
}
case N_IMPORT:
compile_expr(c, node->right);
emit_op(c, OP_IMPORT);
break;
case N_REGEXP:
emit_constant(c, js_mkstr(c->js, node->str ? node->str : "", node->len));
emit_constant(c, js_mkstr(c->js, node->aux ? node->aux : "", node->aux_len));
emit_op(c, OP_REGEXP);
break;
default:
emit_op(c, OP_UNDEF);
break;
}
}
static void compile_binary(sv_compiler_t *c, sv_ast_t *node) {
uint8_t op = node->op;
if (op == TOK_LAND) {
compile_expr(c, node->left);
int jump = emit_jump(c, OP_JMP_FALSE_PEEK);
emit_op(c, OP_POP);
compile_expr(c, node->right);
patch_jump(c, jump);
return;
}
if (op == TOK_LOR) {
compile_expr(c, node->left);
int jump = emit_jump(c, OP_JMP_TRUE_PEEK);
emit_op(c, OP_POP);
compile_expr(c, node->right);
patch_jump(c, jump);
return;
}
if (op == TOK_NULLISH) {
compile_expr(c, node->left);
int jump = emit_jump(c, OP_JMP_NOT_NULLISH);
emit_op(c, OP_POP);
compile_expr(c, node->right);
patch_jump(c, jump);
return;
}
if (op == TOK_IN && node->left->type == N_IDENT &&
node->left->len > 0 && node->left->str[0] == '#') {
emit_constant(c, js_mkstr(c->js, node->left->str, node->left->len));
compile_expr(c, node->right);
emit_op(c, OP_IN);
return;
}
compile_expr(c, node->left);
compile_expr(c, node->right);
switch (op) {
case TOK_PLUS: emit_op(c, OP_ADD); break;
case TOK_MINUS: emit_op(c, OP_SUB); break;
case TOK_MUL: emit_op(c, OP_MUL); break;
case TOK_DIV: emit_op(c, OP_DIV); break;
case TOK_REM: emit_op(c, OP_MOD); break;
case TOK_EXP: emit_op(c, OP_EXP); break;
case TOK_LT: emit_op(c, OP_LT); break;
case TOK_LE: emit_op(c, OP_LE); break;
case TOK_GT: emit_op(c, OP_GT); break;
case TOK_GE: emit_op(c, OP_GE); break;
case TOK_EQ: emit_op(c, OP_EQ); break;
case TOK_NE: emit_op(c, OP_NE); break;
case TOK_SEQ: emit_op(c, OP_SEQ); break;
case TOK_SNE: emit_op(c, OP_SNE); break;
case TOK_AND: emit_op(c, OP_BAND); break;
case TOK_OR: emit_op(c, OP_BOR); break;
case TOK_XOR: emit_op(c, OP_BXOR); break;
case TOK_SHL: emit_op(c, OP_SHL); break;
case TOK_SHR: emit_op(c, OP_SHR); break;
case TOK_ZSHR: emit_op(c, OP_USHR); break;
case TOK_INSTANCEOF: emit_op(c, OP_INSTANCEOF); break;
case TOK_IN: emit_op(c, OP_IN); break;
default: emit_op(c, OP_UNDEF); break;
}
}
static void compile_unary(sv_compiler_t *c, sv_ast_t *node) {
compile_expr(c, node->right);
switch (node->op) {
case TOK_NOT: emit_op(c, OP_NOT); break;
case TOK_TILDA: emit_op(c, OP_BNOT); break;
case TOK_UPLUS: emit_op(c, OP_UPLUS); break;
case TOK_UMINUS: emit_op(c, OP_NEG); break;
default: break;
}
}
static void compile_update(sv_compiler_t *c, sv_ast_t *node) {
bool prefix = (node->flags & 1);
bool is_inc = (node->op == TOK_POSTINC);
sv_ast_t *target = node->right;
if (target->type == N_IDENT) {
if (prefix) {
emit_get_var(c, target->str, target->len);
emit_op(c, is_inc ? OP_INC : OP_DEC);
emit_set_var(c, target->str, target->len, true);
} else {
emit_get_var(c, target->str, target->len);
emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
emit_set_var(c, target->str, target->len, false);
}
} else if (target->type == N_MEMBER && !(target->flags & 1)) {
compile_expr(c, target->left);
emit_op(c, OP_DUP);
int atom = add_atom(c, target->right->str, target->right->len);
emit_op(c, OP_GET_FIELD);
emit_u32(c, (uint32_t)atom);
if (prefix) {
emit_op(c, is_inc ? OP_INC : OP_DEC);
emit_op(c, OP_INSERT2);
emit_op(c, OP_PUT_FIELD);
emit_u32(c, (uint32_t)atom);
} else {
emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
emit_op(c, OP_SWAP_UNDER);
emit_op(c, OP_PUT_FIELD);
emit_u32(c, (uint32_t)atom);
}
} else if (target->type == N_MEMBER && (target->flags & 1)) {
compile_expr(c, target->left);
compile_expr(c, target->right);
emit_op(c, OP_DUP2);
emit_op(c, OP_GET_ELEM);
if (prefix) {
emit_op(c, is_inc ? OP_INC : OP_DEC);
emit_op(c, OP_INSERT3);
emit_op(c, OP_PUT_ELEM);
} else {
emit_op(c, is_inc ? OP_POST_INC : OP_POST_DEC);
emit_op(c, OP_ROT4_UNDER);
emit_op(c, OP_PUT_ELEM);
}
} else {
emit_op(c, OP_UNDEF);
}
}
static void compile_assign(sv_compiler_t *c, sv_ast_t *node) {
sv_ast_t *target = node->left;
uint8_t op = node->op;
if (op == TOK_ASSIGN) {
if (target->type == N_MEMBER && !(target->flags & 1)) {
int atom = add_atom(c, target->right->str, target->right->len);
compile_expr(c, target->left);
compile_expr(c, node->right);
emit_op(c, OP_INSERT2);
emit_op(c, OP_PUT_FIELD);
emit_u32(c, (uint32_t)atom);
return;
}
if (target->type == N_MEMBER && (target->flags & 1)) {
compile_expr(c, target->left);
compile_expr(c, target->right);
compile_expr(c, node->right);
emit_op(c, OP_INSERT3);
emit_op(c, OP_PUT_ELEM);
return;
}
compile_expr(c, node->right);
compile_lhs_set(c, target, true);
return;
}
if (target->type == N_IDENT) {
if (op == TOK_PLUS_ASSIGN) {
int slot = resolve_local_slot(c, target->str, target->len);
if (slot >= 0 && !c->locals[slot + c->param_locals].is_const) {
sv_ast_t *rhs = node->right;
bool rhs_pure = rhs && (
rhs->type == N_NUMBER || rhs->type == N_STRING ||
rhs->type == N_BOOL || rhs->type == N_NULL ||
rhs->type == N_UNDEF || rhs->type == N_IDENT
);
if (rhs_pure) {
compile_expr(c, rhs);
emit_op(c, OP_ADD_LOCAL);
emit(c, (uint8_t)slot);
emit_get_local(c, c->param_locals + slot);
return;
}
}
}
if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
op == TOK_NULLISH_ASSIGN) {
emit_get_var(c, target->str, target->len);
int skip = emit_jump(c,
op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
emit_op(c, OP_POP);
compile_expr(c, node->right);
emit_set_var(c, target->str, target->len, true);
patch_jump(c, skip);
return;
}
emit_get_var(c, target->str, target->len);
compile_expr(c, node->right);
switch (op) {
case TOK_PLUS_ASSIGN: emit_op(c, OP_ADD); break;
case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
case TOK_MUL_ASSIGN: emit_op(c, OP_MUL); break;
case TOK_DIV_ASSIGN: emit_op(c, OP_DIV); break;
case TOK_REM_ASSIGN: emit_op(c, OP_MOD); break;
case TOK_SHL_ASSIGN: emit_op(c, OP_SHL); break;
case TOK_SHR_ASSIGN: emit_op(c, OP_SHR); break;
case TOK_ZSHR_ASSIGN: emit_op(c, OP_USHR); break;
case TOK_AND_ASSIGN: emit_op(c, OP_BAND); break;
case TOK_XOR_ASSIGN: emit_op(c, OP_BXOR); break;
case TOK_OR_ASSIGN: emit_op(c, OP_BOR); break;
case TOK_EXP_ASSIGN: emit_op(c, OP_EXP); break;
default: break;
}
emit_set_var(c, target->str, target->len, true);
} else if (target->type == N_MEMBER && !(target->flags & 1)) {
int atom = add_atom(c, target->right->str, target->right->len);
if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
op == TOK_NULLISH_ASSIGN) {
compile_expr(c, target->left);
emit_op(c, OP_DUP);
emit_op(c, OP_GET_FIELD);
emit_u32(c, (uint32_t)atom);
int skip = emit_jump(c,
op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
emit_op(c, OP_POP);
compile_expr(c, node->right);
emit_op(c, OP_INSERT2);
emit_op(c, OP_PUT_FIELD);
emit_u32(c, (uint32_t)atom);
int end = emit_jump(c, OP_JMP);
patch_jump(c, skip);
emit_op(c, OP_NIP);
patch_jump(c, end);
return;
}
compile_expr(c, target->left);
emit_op(c, OP_DUP);
emit_op(c, OP_GET_FIELD);
emit_u32(c, (uint32_t)atom);
compile_expr(c, node->right);
switch (op) {
case TOK_PLUS_ASSIGN: emit_op(c, OP_ADD); break;
case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
case TOK_MUL_ASSIGN: emit_op(c, OP_MUL); break;
case TOK_DIV_ASSIGN: emit_op(c, OP_DIV); break;
case TOK_REM_ASSIGN: emit_op(c, OP_MOD); break;
case TOK_SHL_ASSIGN: emit_op(c, OP_SHL); break;
case TOK_SHR_ASSIGN: emit_op(c, OP_SHR); break;
case TOK_ZSHR_ASSIGN: emit_op(c, OP_USHR); break;
case TOK_AND_ASSIGN: emit_op(c, OP_BAND); break;
case TOK_XOR_ASSIGN: emit_op(c, OP_BXOR); break;
case TOK_OR_ASSIGN: emit_op(c, OP_BOR); break;
case TOK_EXP_ASSIGN: emit_op(c, OP_EXP); break;
default: break;
}
emit_op(c, OP_INSERT2);
emit_op(c, OP_PUT_FIELD);
emit_u32(c, (uint32_t)atom);
} else if (target->type == N_MEMBER && (target->flags & 1)) {
if (op == TOK_LOR_ASSIGN || op == TOK_LAND_ASSIGN ||
op == TOK_NULLISH_ASSIGN) {
compile_expr(c, target->left);
compile_expr(c, target->right);
emit_op(c, OP_DUP2);
emit_op(c, OP_GET_ELEM);
int skip = emit_jump(c,
op == TOK_LOR_ASSIGN ? OP_JMP_TRUE_PEEK :
op == TOK_LAND_ASSIGN ? OP_JMP_FALSE_PEEK : OP_JMP_NOT_NULLISH);
emit_op(c, OP_POP);
compile_expr(c, node->right);
emit_op(c, OP_INSERT3);
emit_op(c, OP_PUT_ELEM);
int end = emit_jump(c, OP_JMP);
patch_jump(c, skip);
emit_op(c, OP_NIP2);
patch_jump(c, end);
return;
}
compile_expr(c, target->left);
compile_expr(c, target->right);
emit_op(c, OP_DUP2);
emit_op(c, OP_GET_ELEM);
compile_expr(c, node->right);
switch (op) {
case TOK_PLUS_ASSIGN: emit_op(c, OP_ADD); break;
case TOK_MINUS_ASSIGN: emit_op(c, OP_SUB); break;
case TOK_MUL_ASSIGN: emit_op(c, OP_MUL); break;
case TOK_DIV_ASSIGN: emit_op(c, OP_DIV); break;
case TOK_REM_ASSIGN: emit_op(c, OP_MOD); break;
case TOK_SHL_ASSIGN: emit_op(c, OP_SHL); break;
case TOK_SHR_ASSIGN: emit_op(c, OP_SHR); break;
case TOK_ZSHR_ASSIGN: emit_op(c, OP_USHR); break;
case TOK_AND_ASSIGN: emit_op(c, OP_BAND); break;
case TOK_XOR_ASSIGN: emit_op(c, OP_BXOR); break;
case TOK_OR_ASSIGN: emit_op(c, OP_BOR); break;
case TOK_EXP_ASSIGN: emit_op(c, OP_EXP); break;
default: break;
}
emit_op(c, OP_INSERT3);
emit_op(c, OP_PUT_ELEM);
} else {
compile_expr(c, node->right);
}
}
static void compile_lhs_set(sv_compiler_t *c, sv_ast_t *target, bool keep) {
if (target->type == N_IDENT) {
emit_set_var(c, target->str, target->len, keep);
} else if (target->type == N_MEMBER && !(target->flags & 1)) {
if (keep) emit_op(c, OP_DUP);
compile_expr(c, target->left);
emit_op(c, OP_SWAP);
emit_atom_op(c, OP_PUT_FIELD, target->right->str, target->right->len);
} else if (target->type == N_MEMBER && (target->flags & 1)) {
if (keep) emit_op(c, OP_DUP);
compile_expr(c, target->left);
compile_expr(c, target->right);
emit_op(c, OP_ROT3L);
emit_op(c, OP_PUT_ELEM);
} else if (target->type == N_ARRAY_PAT || target->type == N_ARRAY) {
compile_array_destructure(c, target, keep);
} else if (target->type == N_OBJECT_PAT || target->type == N_OBJECT) {
compile_object_destructure(c, target, keep);
}
}
static void compile_ternary(sv_compiler_t *c, sv_ast_t *node) {
compile_expr(c, node->cond);
int else_jump = emit_jump(c, OP_JMP_FALSE);
compile_expr(c, node->left);
int end_jump = emit_jump(c, OP_JMP);
patch_jump(c, else_jump);
compile_expr(c, node->right);
patch_jump(c, end_jump);
}
static void compile_typeof(sv_compiler_t *c, sv_ast_t *node) {
sv_ast_t *arg = node->right;
if (arg->type == N_IDENT) {
int local = resolve_local(c, arg->str, arg->len);
if (local != -1) {
emit_get_var(c, arg->str, arg->len);
} else {
int upval = resolve_upvalue(c, arg->str, arg->len);
if (upval != -1) {
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)upval);
} else if (
has_implicit_arguments_obj(c) &&
is_ident_str(arg->str, arg->len, "arguments", 9)
) {
if (c->strict_args_local >= 0) {
emit_get_local(c, c->strict_args_local);
} else {
emit_op(c, OP_SPECIAL_OBJ);
emit(c, 0);
}
} else emit_atom_op(c, OP_GET_GLOBAL_UNDEF, arg->str, arg->len);
}
} else compile_expr(c, arg);
emit_op(c, OP_TYPEOF);
}
static void compile_delete(sv_compiler_t *c, sv_ast_t *node) {
sv_ast_t *arg = node->right;
if (arg->type == N_MEMBER && !(arg->flags & 1)) {
compile_expr(c, arg->left);
jsval_t key = js_mkstr(c->js, arg->right->str, arg->right->len);
emit_constant(c, key);
emit_op(c, OP_DELETE);
} else if (arg->type == N_MEMBER && (arg->flags & 1)) {
compile_expr(c, arg->left);
compile_expr(c, arg->right);
emit_op(c, OP_DELETE);
} else if (arg->type == N_IDENT) {
emit_atom_op(c, OP_DELETE_VAR, arg->str, arg->len);
} else {
compile_expr(c, arg);
emit_op(c, OP_POP);
emit_op(c, OP_TRUE);
}
}
static void compile_template(sv_compiler_t *c, sv_ast_t *node) {
int n = node->args.count;
if (n == 0) {
emit_constant(c, js_mkstr(c->js, "", 0));
return;
}
for (int i = 0; i < n; i++) {
sv_ast_t *item = node->args.items[i];
if (item->type == N_STRING && is_invalid_cooked_string(item)) {
static const char msg[] = "Invalid or unexpected token";
int atom = add_atom(c, msg, sizeof(msg) - 1);
emit_op(c, OP_THROW_ERROR);
emit_u32(c, (uint32_t)atom);
emit(c, (uint8_t)JS_ERR_SYNTAX);
return;
}
}
compile_expr(c, node->args.items[0]);
if (node->args.items[0]->type != N_STRING)
emit_op(c, OP_TO_PROPKEY);
for (int i = 1; i < n; i++) {
compile_expr(c, node->args.items[i]);
if (node->args.items[i]->type != N_STRING)
emit_op(c, OP_TO_PROPKEY);
emit_op(c, OP_ADD);
}
}
static bool call_has_spread_arg(const sv_ast_t *node) {
if (!node) return false;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *arg = node->args.items[i];
if (arg && arg->type == N_SPREAD) return true;
}
return false;
}
static void compile_push_arg_to_array(sv_compiler_t *c, sv_ast_t *arg) {
emit_op(c, OP_DUP);
emit_op(c, OP_DUP);
emit_atom_op(c, OP_GET_FIELD, "push", 4);
compile_expr(c, arg);
emit_op(c, OP_CALL_METHOD);
emit_u16(c, 1);
emit_op(c, OP_POP);
}
static void compile_concat_spread_to_array(sv_compiler_t *c, sv_ast_t *spread_arg) {
compile_expr(c, spread_arg->right);
emit_op(c, OP_SPREAD);
}
static void compile_call_args_array(sv_compiler_t *c, sv_ast_t *call_node) {
emit_op(c, OP_ARRAY);
emit_u16(c, 0);
for (int i = 0; i < call_node->args.count; i++) {
sv_ast_t *arg = call_node->args.items[i];
if (arg && arg->type == N_SPREAD) compile_concat_spread_to_array(c, arg);
else compile_push_arg_to_array(c, arg);
}
}
typedef enum {
SV_CALL_DIRECT = 0,
SV_CALL_METHOD = 1,
} sv_call_kind_t;
static void compile_receiver_property_get(sv_compiler_t *c, sv_ast_t *node) {
emit_op(c, OP_DUP);
if (node->flags & 1) {
compile_expr(c, node->right);
emit_op(c, OP_GET_ELEM);
} else {
emit_srcpos(c, node->right);
emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
}
}
static void compile_call_emit_invoke(
sv_compiler_t *c, sv_ast_t *node,
sv_call_kind_t kind, bool has_spread
) {
int argc = node->args.count;
if (has_spread) {
if (kind == SV_CALL_METHOD) emit_op(c, OP_SWAP);
else emit_op(c, OP_GLOBAL);
compile_call_args_array(c, node);
emit_op(c, OP_APPLY);
emit_u16(c, 1);
return;
}
for (int i = 0; i < argc; i++)
compile_expr(c, node->args.items[i]);
emit_op(c, kind == SV_CALL_METHOD ? OP_CALL_METHOD : OP_CALL);
emit_u16(c, (uint16_t)argc);
}
static sv_call_kind_t compile_call_setup_non_optional(sv_compiler_t *c, sv_ast_t *callee) {
if (is_ident_name(callee, "super")) {
emit_op(c, OP_THIS);
emit_get_var(c, "super", 5);
return SV_CALL_METHOD;
}
if (callee->type == N_MEMBER && is_ident_name(callee->left, "super")) {
emit_op(c, OP_THIS);
emit_op(c, OP_THIS);
emit_get_var(c, "super", 5);
if (callee->flags & 1)
compile_expr(c, callee->right);
else
emit_constant(c, js_mkstr(c->js, callee->right->str, callee->right->len));
emit_op(c, OP_GET_SUPER_VAL);
return SV_CALL_METHOD;
}
if (callee->type == N_MEMBER) {
compile_expr(c, callee->left);
compile_receiver_property_get(c, callee);
return SV_CALL_METHOD;
}
compile_expr(c, callee);
return SV_CALL_DIRECT;
}
static void compile_optional_call_after_setup(
sv_compiler_t *c, sv_ast_t *call_node,
sv_call_kind_t kind, bool has_spread
) {
emit_op(c, OP_DUP);
emit_op(c, OP_IS_UNDEF_OR_NULL);
int j_do_call = emit_jump(c, OP_JMP_FALSE);
emit_op(c, OP_POP);
if (kind == SV_CALL_METHOD)
emit_op(c, OP_POP);
emit_op(c, OP_UNDEF);
int j_end = emit_jump(c, OP_JMP);
patch_jump(c, j_do_call);
compile_call_emit_invoke(c, call_node, kind, has_spread);
patch_jump(c, j_end);
}
static void compile_call_optional(
sv_compiler_t *c, sv_ast_t *node,
sv_ast_t *opt_callee, bool has_spread
) {
if (opt_callee->right) {
compile_expr(c, opt_callee->left);
emit_op(c, OP_DUP);
emit_op(c, OP_IS_UNDEF_OR_NULL);
int j_have_obj = emit_jump(c, OP_JMP_FALSE);
emit_op(c, OP_POP);
emit_op(c, OP_UNDEF);
int j_end = emit_jump(c, OP_JMP);
patch_jump(c, j_have_obj);
compile_receiver_property_get(c, opt_callee);
compile_call_emit_invoke(c, node, SV_CALL_METHOD, has_spread);
patch_jump(c, j_end);
return;
}
sv_ast_t *target = opt_callee->left;
if (target && target->type == N_OPTIONAL && target->right) {
compile_expr(c, target->left);
emit_op(c, OP_DUP);
emit_op(c, OP_IS_UNDEF_OR_NULL);
int j_have_obj = emit_jump(c, OP_JMP_FALSE);
emit_op(c, OP_POP);
emit_op(c, OP_UNDEF);
int j_end = emit_jump(c, OP_JMP);
patch_jump(c, j_have_obj);
compile_receiver_property_get(c, target);
compile_optional_call_after_setup(c, node, SV_CALL_METHOD, has_spread);
patch_jump(c, j_end);
return;
}
sv_call_kind_t kind = compile_call_setup_non_optional(c, target);
compile_optional_call_after_setup(c, node, kind, has_spread);
}
static void compile_call(sv_compiler_t *c, sv_ast_t *node) {
sv_ast_t *callee = node->left;
bool has_spread = call_has_spread_arg(node);
if (callee->type == N_OPTIONAL) {
compile_call_optional(c, node, callee, has_spread);
return;
}
if (!has_spread && is_ident_name(callee, "eval")) {
if (node->args.count > 0)
compile_expr(c, node->args.items[0]);
else
emit_op(c, OP_UNDEF);
for (int i = 1; i < node->args.count; i++) {
compile_expr(c, node->args.items[i]);
emit_op(c, OP_POP);
}
emit_op(c, OP_EVAL);
emit_u32(c, 0);
return;
}
sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
compile_call_emit_invoke(c, node, kind, has_spread);
}
static void compile_new(sv_compiler_t *c, sv_ast_t *node) {
compile_expr(c, node->left);
emit_op(c, OP_DUP);
int argc = node->args.count;
for (int i = 0; i < argc; i++)
compile_expr(c, node->args.items[i]);
emit_op(c, OP_NEW);
emit_u16(c, (uint16_t)argc);
}
static bool sv_node_has_optional_base(sv_ast_t *n) {
while (n) {
if (n->type == N_OPTIONAL) return true;
if (n->type == N_MEMBER || n->type == N_CALL) n = n->left;
else break;
}
return false;
}
static void compile_member(sv_compiler_t *c, sv_ast_t *node) {
if (is_ident_name(node->left, "super")) {
emit_op(c, OP_THIS);
emit_get_var(c, "super", 5);
if (node->flags & 1)
compile_expr(c, node->right);
else
emit_constant(c, js_mkstr(c->js, node->right->str, node->right->len));
emit_op(c, OP_GET_SUPER_VAL);
return;
}
compile_expr(c, node->left);
int ok_jump = -1, end_jump = -1;
if (sv_node_has_optional_base(node->left)) {
ok_jump = emit_jump(c, OP_JMP_NOT_NULLISH);
end_jump = emit_jump(c, OP_JMP);
patch_jump(c, ok_jump);
}
if (node->flags & 1) {
compile_expr(c, node->right);
emit_op(c, OP_GET_ELEM);
} else {
if (node->right->len == 6 && memcmp(node->right->str, "length", 6) == 0)
emit_op(c, OP_GET_LENGTH);
else {
emit_srcpos(c, node->right);
emit_atom_op(c, OP_GET_FIELD, node->right->str, node->right->len);
}
}
if (end_jump >= 0) patch_jump(c, end_jump);
}
static void compile_optional_get(sv_compiler_t *c, sv_ast_t *node) {
if (node->flags & 1) {
compile_expr(c, node->right);
emit_op(c, OP_GET_ELEM_OPT);
} else {
emit_srcpos(c, node->right);
emit_atom_op(c, OP_GET_FIELD_OPT, node->right->str, node->right->len);
}
}
static void compile_optional(sv_compiler_t *c, sv_ast_t *node) {
compile_expr(c, node->left);
compile_optional_get(c, node);
}
static void compile_array(sv_compiler_t *c, sv_ast_t *node) {
int count = node->args.count;
bool has_spread = false;
for (int i = 0; i < count; i++) {
sv_ast_t *elem = node->args.items[i];
if (elem && elem->type == N_SPREAD) {
has_spread = true;
break;
}
}
if (!has_spread) {
for (int i = 0; i < count; i++) {
sv_ast_t *elem = node->args.items[i];
if (elem && elem->type == N_EMPTY)
emit_op(c, OP_EMPTY);
else
compile_expr(c, elem);
}
emit_op(c, OP_ARRAY);
emit_u16(c, (uint16_t)count);
return;
}
emit_op(c, OP_ARRAY);
emit_u16(c, 0);
for (int i = 0; i < count; i++) {
sv_ast_t *elem = node->args.items[i];
if (elem && elem->type == N_SPREAD) compile_concat_spread_to_array(c, elem);
else compile_push_arg_to_array(c, elem);
}
}
static void compile_object(sv_compiler_t *c, sv_ast_t *node) {
emit_op(c, OP_OBJECT);
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *prop = node->args.items[i];
if (prop->type == N_SPREAD) {
compile_expr(c, prop->right);
emit_op(c, OP_COPY_DATA_PROPS);
emit(c, 0);
emit_op(c, OP_POP);
continue;
}
if (prop->type != N_PROPERTY) continue;
if (prop->flags & FN_GETTER || prop->flags & FN_SETTER) {
compile_expr(c, prop->right);
uint8_t flags = 0;
if (prop->flags & FN_GETTER) flags |= 1;
if (prop->flags & FN_SETTER) flags |= 2;
if (prop->flags & FN_COMPUTED) compile_expr(c, prop->left);
else compile_static_property_key(c, prop->left);
emit_op(c, OP_SWAP);
emit_op(c, OP_DEFINE_METHOD_COMP);
emit(c, flags);
} else if (prop->flags & FN_COMPUTED) {
compile_expr(c, prop->left);
compile_expr(c, prop->right);
emit_op(c, OP_DEFINE_METHOD_COMP);
emit(c, 0);
} else {
if (prop->right && (prop->right->type == N_FUNC || prop->right->type == N_CLASS) &&
(!prop->right->str || prop->right->len == 0) &&
prop->left && prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
c->inferred_name = prop->left->str;
c->inferred_name_len = prop->left->len;
}
compile_expr(c, prop->right);
if ((prop->flags & FN_COLON) &&
prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left) &&
is_ident_str(prop->left->str, prop->left->len, "__proto__", 9)) {
emit_op(c, OP_SET_PROTO);
continue;
}
if (prop->left->type == N_IDENT && !is_quoted_ident_key(prop->left)) {
emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
} else if (is_quoted_ident_key(prop->left)) {
emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str + 1, prop->left->len - 2);
} else if (prop->left->type == N_STRING) {
emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str ? prop->left->str : "", prop->left->len);
} else if (prop->left->type == N_NUMBER) {
char buf[32];
int n = snprintf(buf, sizeof(buf), "%g", prop->left->num);
emit_atom_op(c, OP_DEFINE_FIELD, buf, (uint32_t)n);
} else emit_atom_op(c, OP_DEFINE_FIELD, prop->left->str, prop->left->len);
}
}
}
static void compile_func_expr(sv_compiler_t *c, sv_ast_t *node) {
bool has_name = node->str && node->len > 0 && !(node->flags & FN_ARROW);
int name_local = -1;
if (has_name) {
begin_scope(c);
name_local = add_local(c, node->str, node->len, true, c->scope_depth);
emit_op(c, OP_UNDEF);
emit_put_local(c, name_local);
}
sv_func_t *fn = compile_function_body(c, node, SV_COMPILE_SCRIPT);
if (!fn) {
emit_op(c, OP_UNDEF);
if (has_name) end_scope(c);
return;
}
int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
emit_op(c, OP_CLOSURE);
emit_u32(c, (uint32_t)idx);
if (node->str && node->len > 0) {
emit_set_function_name(c, node->str, node->len);
} else if (c->inferred_name) {
emit_set_function_name(c, c->inferred_name, c->inferred_name_len);
c->inferred_name = NULL;
c->inferred_name_len = 0;
} else {
emit_set_function_name(c, NULL, 0);
}
if (has_name) {
emit_op(c, OP_DUP);
emit_put_local(c, name_local);
end_scope(c);
}
}
typedef enum {
DESTRUCTURE_ASSIGN = 0,
DESTRUCTURE_BIND = 1,
} sv_destructure_mode_t;
static void emit_build_object_rest(sv_compiler_t *c) {
emit_op(c, OP_DUP);
emit_op(c, OP_OBJECT);
emit_op(c, OP_SWAP);
emit_op(c, OP_COPY_DATA_PROPS);
emit(c, 0);
emit_op(c, OP_POP);
}
static void emit_delete_rest_key(sv_compiler_t *c, sv_ast_t *key) {
emit_op(c, OP_DUP);
if (key->type == N_IDENT) {
emit_constant(c, js_mkstr(c->js, key->str, key->len));
} else if (key->type == N_STRING) {
emit_constant(c, ast_string_const(c, key));
} else if (key->type == N_NUMBER) {
emit_number(c, key->num);
} else {
compile_expr(c, key);
}
emit_op(c, OP_DELETE);
emit_op(c, OP_POP);
}
static bool is_destructure_pattern_node(sv_ast_t *node) {
return node && (node->type == N_ARRAY_PAT || node->type == N_ARRAY ||
node->type == N_OBJECT_PAT || node->type == N_OBJECT);
}
static void compile_destructure_pattern(sv_compiler_t *c, sv_ast_t *pat,
bool keep, bool consume_source,
sv_destructure_mode_t mode,
sv_var_kind_t kind);
static void compile_destructure_store(sv_compiler_t *c, sv_ast_t *target,
sv_destructure_mode_t mode,
sv_var_kind_t kind) {
if (!target) return;
if (mode == DESTRUCTURE_ASSIGN) {
compile_lhs_set(c, target, false);
return;
}
if (target->type == N_IDENT) {
bool is_const = (kind == VAR_CONST);
int idx = ensure_local_at_depth(c, target->str, target->len,
is_const, c->scope_depth);
emit_put_local(c, idx);
return;
}
if (is_destructure_pattern_node(target)) {
compile_destructure_pattern(c, target, false, true, mode, kind);
return;
}
compile_lhs_set(c, target, false);
}
static void compile_destructure_pattern(sv_compiler_t *c, sv_ast_t *pat,
bool keep, bool consume_source,
sv_destructure_mode_t mode,
sv_var_kind_t kind) {
if (!pat) return;
if (keep) emit_op(c, OP_DUP);
if (pat->type == N_ARRAY_PAT || pat->type == N_ARRAY) {
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *elem = pat->args.items[i];
if (!elem || elem->type == N_EMPTY) continue;
if (elem->type == N_REST || elem->type == N_SPREAD) {
emit_op(c, OP_DUP);
emit_op(c, OP_DUP);
emit_atom_op(c, OP_GET_FIELD, "slice", 5);
emit_number(c, (double)i);
emit_op(c, OP_CALL_METHOD);
emit_u16(c, 1);
compile_destructure_store(c, elem->right, mode, kind);
continue;
}
sv_ast_t *target = elem;
sv_ast_t *default_val = NULL;
if (elem->type == N_ASSIGN_PAT ||
(elem->type == N_ASSIGN && elem->op == TOK_ASSIGN)) {
target = elem->left;
default_val = elem->right;
}
emit_op(c, OP_DUP);
emit_number(c, (double)i);
emit_op(c, OP_GET_ELEM);
if (default_val) {
emit_op(c, OP_DUP);
emit_op(c, OP_IS_UNDEF);
int skip = emit_jump(c, OP_JMP_FALSE);
emit_op(c, OP_POP);
compile_expr(c, default_val);
patch_jump(c, skip);
}
compile_destructure_store(c, target, mode, kind);
}
} else if (pat->type == N_OBJECT_PAT || pat->type == N_OBJECT) {
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_REST || prop->type == N_SPREAD) {
emit_build_object_rest(c);
for (int j = 0; j < i; j++) {
sv_ast_t *prev = pat->args.items[j];
if (!prev || prev->type != N_PROPERTY || !prev->left) continue;
emit_delete_rest_key(c, prev->left);
}
compile_destructure_store(c, prop->right, mode, kind);
continue;
}
if (prop->type != N_PROPERTY) continue;
sv_ast_t *key = prop->left;
sv_ast_t *value = prop->right;
sv_ast_t *default_val = NULL;
if (value && (value->type == N_ASSIGN_PAT ||
(value->type == N_ASSIGN && value->op == TOK_ASSIGN))) {
default_val = value->right;
value = value->left;
}
emit_op(c, OP_DUP);
if ((prop->flags & FN_COMPUTED)) {
compile_expr(c, key);
emit_op(c, OP_GET_ELEM);
} else if (key->type == N_IDENT) {
emit_atom_op(c, OP_GET_FIELD, key->str, key->len);
} else {
compile_expr(c, key);
emit_op(c, OP_GET_ELEM);
}
if (default_val) {
emit_op(c, OP_DUP);
emit_op(c, OP_IS_UNDEF);
int skip = emit_jump(c, OP_JMP_FALSE);
emit_op(c, OP_POP);
compile_expr(c, default_val);
patch_jump(c, skip);
}
compile_destructure_store(c, value, mode, kind);
}
}
if (consume_source) emit_op(c, OP_POP);
}
static void compile_array_destructure(sv_compiler_t *c, sv_ast_t *pat,
bool keep) {
compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, VAR_LET);
}
static void compile_object_destructure(sv_compiler_t *c, sv_ast_t *pat,
bool keep) {
compile_destructure_pattern(c, pat, keep, true, DESTRUCTURE_ASSIGN, VAR_LET);
}
static bool is_tail_callable(sv_compiler_t *c, sv_ast_t *node) {
if (c->try_depth > 0) return false;
if (node->type != N_CALL) return false;
if (call_has_spread_arg(node)) return false;
sv_ast_t *callee = node->left;
if (callee->type == N_IDENT && callee->len == 5 && memcmp(callee->str, "super", 5) == 0) return false;
return true;
}
static void compile_tail_call(sv_compiler_t *c, sv_ast_t *node) {
sv_ast_t *callee = node->left;
if (callee->type == N_OPTIONAL) {
compile_call(c, node);
emit_close_upvals(c);
emit_op(c, OP_RETURN);
return;
}
sv_call_kind_t kind = compile_call_setup_non_optional(c, callee);
int argc = node->args.count;
for (int i = 0; i < argc; i++)
compile_expr(c, node->args.items[i]);
emit_close_upvals(c);
emit_op(c, kind == SV_CALL_METHOD ? OP_TAIL_CALL_METHOD : OP_TAIL_CALL);
emit_u16(c, (uint16_t)argc);
}
static void compile_tail_return_expr(sv_compiler_t *c, sv_ast_t *expr) {
if (expr->type == N_TERNARY) {
compile_expr(c, expr->cond);
int else_jump = emit_jump(c, OP_JMP_FALSE);
compile_tail_return_expr(c, expr->left);
patch_jump(c, else_jump);
compile_tail_return_expr(c, expr->right);
return;
}
if (is_tail_callable(c, expr)) {
compile_tail_call(c, expr);
return;
}
compile_expr(c, expr);
emit_close_upvals(c);
emit_op(c, OP_RETURN);
}
static void compile_stmts(sv_compiler_t *c, sv_ast_list_t *list) {
for (int i = 0; i < list->count; i++)
compile_stmt(c, list->items[i]);
}
static void compile_stmt(sv_compiler_t *c, sv_ast_t *node) {
if (!node) return;
emit_srcpos(c, node);
switch (node->type) {
case N_EMPTY:
case N_DEBUGGER:
break;
case N_BLOCK:
begin_scope(c);
hoist_lexical_decls(c, &node->args);
hoist_func_decls(c, &node->args);
compile_stmts(c, &node->args);
end_scope(c);
break;
case N_VAR:
compile_var_decl(c, node);
break;
case N_IMPORT_DECL:
compile_import_decl(c, node);
break;
case N_EXPORT:
compile_export_decl(c, node);
break;
case N_IF:
compile_if(c, node);
break;
case N_WHILE:
compile_while(c, node);
break;
case N_DO_WHILE:
compile_do_while(c, node);
break;
case N_FOR:
compile_for(c, node);
break;
case N_FOR_IN:
compile_for_in(c, node);
break;
case N_FOR_OF:
case N_FOR_AWAIT_OF:
compile_for_of(c, node);
break;
case N_RETURN:
if (node->right) {
compile_tail_return_expr(c, node->right);
} else {
emit_close_upvals(c);
emit_op(c, OP_RETURN_UNDEF);
}
break;
case N_THROW:
compile_expr(c, node->right);
emit_op(c, OP_THROW);
break;
case N_BREAK:
compile_break(c, node);
break;
case N_CONTINUE:
compile_continue(c, node);
break;
case N_TRY:
compile_try(c, node);
break;
case N_SWITCH:
compile_switch(c, node);
break;
case N_LABEL:
compile_label(c, node);
break;
case N_FUNC:
if (node->str && !(node->flags & FN_ARROW)) break;
compile_expr(c, node);
emit_op(c, OP_POP);
break;
case N_CLASS:
compile_class(c, node);
emit_op(c, OP_POP);
break;
case N_WITH:
compile_expr(c, node->left);
emit_op(c, OP_ENTER_WITH);
c->with_depth++;
compile_stmt(c, node->body);
c->with_depth--;
emit_op(c, OP_EXIT_WITH);
break;
default:
compile_expr(c, node);
emit_op(c, OP_POP);
break;
}
}
enum {
IMPORT_BIND_DEFAULT = 1 << 0,
IMPORT_BIND_NAMESPACE = 1 << 1,
};
static void compile_import_decl(sv_compiler_t *c, sv_ast_t *node) {
if (!node->right) return;
bool repl_top = is_repl_top_level(c);
compile_expr(c, node->right);
emit_op(c, OP_IMPORT_SYNC);
if (node->args.count == 0) {
emit_op(c, OP_POP);
return;
}
int ns_local = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, ns_local);
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *spec = node->args.items[i];
if (!spec || spec->type != N_IMPORT_SPEC ||
!spec->right || spec->right->type != N_IDENT)
continue;
emit_get_local(c, ns_local);
if (!(spec->flags & IMPORT_BIND_NAMESPACE)) {
if ((spec->flags & IMPORT_BIND_DEFAULT) ||
!spec->left || spec->left->type != N_IDENT) {
emit_op(c, OP_IMPORT_DEFAULT);
} else {
emit_atom_op(c, OP_GET_FIELD, spec->left->str, spec->left->len);
}
}
if (repl_top) {
emit_atom_op(c, OP_PUT_GLOBAL, spec->right->str, spec->right->len);
} else {
int idx = ensure_local_at_depth(c, spec->right->str, spec->right->len,
true, c->scope_depth);
emit_put_local(c, idx);
}
}
}
static void compile_export_emit(sv_compiler_t *c, const char *name, uint32_t len) {
emit_get_var(c, name, len);
emit_atom_op(c, OP_EXPORT, name, len);
}
static void defer_export(sv_compiler_t *c, const char *name, uint32_t len) {
if (c->deferred_export_count >= c->deferred_export_cap) {
int cap = c->deferred_export_cap ? c->deferred_export_cap * 2 : 8;
c->deferred_exports = realloc(c->deferred_exports, cap * sizeof(sv_deferred_export_t));
c->deferred_export_cap = cap;
}
c->deferred_exports[c->deferred_export_count++] =
(sv_deferred_export_t){ .name = name, .len = len };
}
static void defer_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
if (!pat) return;
switch (pat->type) {
case N_IDENT:
defer_export(c, pat->str, pat->len);
break;
case N_ASSIGN_PAT:
defer_export_pattern(c, pat->left);
break;
case N_REST:
case N_SPREAD:
defer_export_pattern(c, pat->right);
break;
case N_ARRAY:
case N_ARRAY_PAT:
for (int i = 0; i < pat->args.count; i++)
defer_export_pattern(c, pat->args.items[i]);
break;
case N_OBJECT:
case N_OBJECT_PAT:
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_PROPERTY) defer_export_pattern(c, prop->right);
else defer_export_pattern(c, prop);
}
break;
default:
break;
}
}
static void compile_export_pattern(sv_compiler_t *c, sv_ast_t *pat) {
if (!pat) return;
switch (pat->type) {
case N_IDENT:
compile_export_emit(c, pat->str, pat->len);
break;
case N_ASSIGN_PAT:
compile_export_pattern(c, pat->left);
break;
case N_REST:
case N_SPREAD:
compile_export_pattern(c, pat->right);
break;
case N_ARRAY:
case N_ARRAY_PAT:
for (int i = 0; i < pat->args.count; i++)
compile_export_pattern(c, pat->args.items[i]);
break;
case N_OBJECT:
case N_OBJECT_PAT:
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_PROPERTY) compile_export_pattern(c, prop->right);
else compile_export_pattern(c, prop);
}
break;
default:
break;
}
}
static void compile_export_decl(sv_compiler_t *c, sv_ast_t *node) {
if (!node) return;
if (node->flags & EX_DEFAULT) {
if (node->left) compile_expr(c, node->left);
else emit_op(c, OP_UNDEF);
emit_atom_op(c, OP_EXPORT, "default", 7);
return;
}
if ((node->flags & EX_DECL) && node->left) {
sv_ast_t *decl = node->left;
if (decl->type == N_VAR) {
compile_var_decl(c, decl);
bool is_var = decl->var_kind == VAR_VAR;
for (int i = 0; i < decl->args.count; i++) {
sv_ast_t *var = decl->args.items[i];
if (!var || var->type != N_VARDECL) continue;
if (is_var && c->mode == SV_COMPILE_MODULE)
defer_export_pattern(c, var->left);
else
compile_export_pattern(c, var->left);
}
return;
}
compile_stmt(c, decl);
if ((decl->type == N_FUNC || decl->type == N_CLASS) &&
decl->str && decl->len > 0) {
compile_export_emit(c, decl->str, decl->len);
}
return;
}
if ((node->flags & EX_STAR) && (node->flags & EX_FROM) && node->right) {
compile_expr(c, node->right);
emit_op(c, OP_IMPORT_SYNC);
if (node->flags & EX_NAMESPACE) {
if (node->args.count > 0) {
sv_ast_t *spec = node->args.items[0];
if (spec && spec->type == N_IMPORT_SPEC &&
spec->right && spec->right->type == N_IDENT) {
emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
return;
}
}
emit_op(c, OP_POP);
return;
}
emit_op(c, OP_EXPORT_ALL);
return;
}
if (!(node->flags & EX_NAMED) || node->args.count == 0) return;
int ns_local = -1;
if (node->flags & EX_FROM) {
if (!node->right) return;
compile_expr(c, node->right);
emit_op(c, OP_IMPORT_SYNC);
ns_local = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, ns_local);
}
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *spec = node->args.items[i];
if (!spec || spec->type != N_IMPORT_SPEC || !spec->left || !spec->right ||
spec->left->type != N_IDENT || spec->right->type != N_IDENT)
continue;
if (node->flags & EX_FROM) {
emit_get_local(c, ns_local);
if (spec->left->len == 7 && memcmp(spec->left->str, "default", 7) == 0)
emit_op(c, OP_IMPORT_DEFAULT);
else
emit_atom_op(c, OP_GET_FIELD, spec->left->str, spec->left->len);
emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
} else {
emit_get_var(c, spec->left->str, spec->left->len);
emit_atom_op(c, OP_EXPORT, spec->right->str, spec->right->len);
}
}
}
static void compile_var_decl(sv_compiler_t *c, sv_ast_t *node) {
sv_var_kind_t kind = node->var_kind;
bool is_const = (kind == VAR_CONST);
bool repl_top = is_repl_top_level(c);
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *decl = node->args.items[i];
if (decl->type != N_VARDECL) continue;
sv_ast_t *target = decl->left;
if (repl_top) {
if (!decl->right && kind == VAR_VAR) continue;
if (decl->right) {
compile_expr(c, decl->right);
} else {
emit_op(c, OP_UNDEF);
}
if (target->type == N_IDENT) {
emit_atom_op(c, OP_PUT_GLOBAL, target->str, target->len);
} else {
compile_destructure_pattern(c, target, false, true,
DESTRUCTURE_ASSIGN, kind);
}
} else if (kind == VAR_VAR) {
if (decl->right) {
compile_expr(c, decl->right);
compile_lhs_set(c, target, false);
}
} else {
if (target->type == N_IDENT) {
int idx = ensure_local_at_depth(c, target->str, target->len,
is_const, c->scope_depth);
if (decl->right) {
compile_expr(c, decl->right);
} else if (!is_const) {
emit_op(c, OP_UNDEF);
}
if (decl->right || !is_const) {
emit_put_local(c, idx);
c->locals[idx].is_tdz = false;
}
} else {
if (decl->right) {
compile_expr(c, decl->right);
compile_destructure_binding(c, target, kind);
emit_op(c, OP_POP);
}
}
}
}
}
static void compile_destructure_binding(sv_compiler_t *c, sv_ast_t *pat,
sv_var_kind_t kind) {
compile_destructure_pattern(c, pat, false, false, DESTRUCTURE_BIND, kind);
}
static void compile_if(sv_compiler_t *c, sv_ast_t *node) {
compile_expr(c, node->cond);
int else_jump = emit_jump(c, OP_JMP_FALSE);
compile_stmt(c, node->left);
if (node->right) {
int end_jump = emit_jump(c, OP_JMP);
patch_jump(c, else_jump);
compile_stmt(c, node->right);
patch_jump(c, end_jump);
} else {
patch_jump(c, else_jump);
}
}
static void compile_while(sv_compiler_t *c, sv_ast_t *node) {
int loop_start = c->code_len;
push_loop(c, loop_start, NULL, 0);
compile_expr(c, node->cond);
int exit_jump = emit_jump(c, OP_JMP_FALSE);
compile_stmt(c, node->body);
sv_loop_t *loop = &c->loops[c->loop_count - 1];
for (int i = 0; i < loop->continues.count; i++)
patch_jump(c, loop->continues.offsets[i]);
emit_loop(c, loop_start);
patch_jump(c, exit_jump);
pop_loop(c);
}
static void compile_do_while(sv_compiler_t *c, sv_ast_t *node) {
int loop_start = c->code_len;
push_loop(c, loop_start, NULL, 0);
compile_stmt(c, node->body);
sv_loop_t *loop = &c->loops[c->loop_count - 1];
int cond_start = c->code_len;
for (int i = 0; i < loop->continues.count; i++)
patch_jump(c, loop->continues.offsets[i]);
compile_expr(c, node->cond);
int exit_jump = emit_jump(c, OP_JMP_FALSE);
emit_loop(c, loop_start);
patch_jump(c, exit_jump);
pop_loop(c);
(void)cond_start;
}
static void for_add_slot_unique(int **slots, int *count, int *cap, int slot) {
if (slot < 0) return;
for (int i = 0; i < *count; i++) {
if ((*slots)[i] == slot) return;
}
if (*count >= *cap) {
int new_cap = (*cap > 0) ? (*cap * 2) : 8;
int *new_slots = realloc(*slots, (size_t)new_cap * sizeof(int));
if (!new_slots) return;
*slots = new_slots;
*cap = new_cap;
}
(*slots)[(*count)++] = slot;
}
static void for_collect_pattern_slots(sv_compiler_t *c, sv_ast_t *pat,
int **slots, int *count, int *cap) {
if (!pat) return;
switch (pat->type) {
case N_IDENT: {
int slot = resolve_local(c, pat->str, pat->len);
for_add_slot_unique(slots, count, cap, slot);
break;
}
case N_ASSIGN_PAT:
for_collect_pattern_slots(c, pat->left, slots, count, cap);
break;
case N_REST:
case N_SPREAD:
for_collect_pattern_slots(c, pat->right, slots, count, cap);
break;
case N_ARRAY:
case N_ARRAY_PAT:
for (int i = 0; i < pat->args.count; i++)
for_collect_pattern_slots(c, pat->args.items[i], slots, count, cap);
break;
case N_OBJECT:
case N_OBJECT_PAT:
for (int i = 0; i < pat->args.count; i++) {
sv_ast_t *prop = pat->args.items[i];
if (!prop) continue;
if (prop->type == N_PROPERTY)
for_collect_pattern_slots(c, prop->right, slots, count, cap);
else
for_collect_pattern_slots(c, prop, slots, count, cap);
}
break;
default:
break;
}
}
static void for_collect_var_decl_slots(sv_compiler_t *c, sv_ast_t *init_var,
int **slots, int *count, int *cap) {
if (!init_var || init_var->type != N_VAR) return;
for (int i = 0; i < init_var->args.count; i++) {
sv_ast_t *decl = init_var->args.items[i];
if (!decl || decl->type != N_VARDECL || !decl->left) continue;
for_collect_pattern_slots(c, decl->left, slots, count, cap);
}
}
static void compile_for(sv_compiler_t *c, sv_ast_t *node) {
begin_scope(c);
int *iter_slots = NULL;
int iter_count = 0;
int iter_cap = 0;
if (node->init) {
if (node->init->type == N_VAR) {
sv_var_kind_t kind = node->init->var_kind;
compile_var_decl(c, node->init);
if (kind == VAR_LET || kind == VAR_CONST)
for_collect_var_decl_slots(c, node->init, &iter_slots, &iter_count, &iter_cap);
} else {
compile_expr(c, node->init);
emit_op(c, OP_POP);
}
}
int loop_start = c->code_len;
push_loop(c, loop_start, NULL, 0);
int exit_jump = -1;
if (node->cond) {
compile_expr(c, node->cond);
exit_jump = emit_jump(c, OP_JMP_FALSE);
}
int iter_inner_start = -1;
if (iter_count > 0) {
begin_scope(c);
iter_inner_start = c->local_count;
for (int i = 0; i < iter_count; i++) {
int outer_idx = iter_slots[i];
sv_local_t outer = c->locals[outer_idx];
emit_get_local(c, outer_idx);
int inner_idx = add_local(c, outer.name, outer.name_len,
outer.is_const, c->scope_depth);
emit_put_local(c, inner_idx);
}
}
compile_stmt(c, node->body);
sv_loop_t *loop = &c->loops[c->loop_count - 1];
for (int i = 0; i < loop->continues.count; i++)
patch_jump(c, loop->continues.offsets[i]);
int break_close_slot = -1;
if (iter_count > 0) {
for (int i = 0; i < iter_count; i++) {
int inner_idx = iter_inner_start + i;
if (!c->locals[inner_idx].captured) continue;
int slot = local_to_frame_slot(c, inner_idx);
if (break_close_slot < 0 || slot < break_close_slot)
break_close_slot = slot;
}
for (int i = 0; i < iter_count; i++) {
emit_get_local(c, iter_inner_start + i);
emit_put_local(c, iter_slots[i]);
}
end_scope(c);
}
if (node->update) {
sv_ast_t *upd = node->update;
int slot;
if (upd->type == N_UPDATE && upd->right && upd->right->type == N_IDENT &&
(slot = resolve_local_slot(c, upd->right->str, upd->right->len)) >= 0) {
emit_op(c, upd->op == TOK_POSTINC ? OP_INC_LOCAL : OP_DEC_LOCAL);
emit(c, (uint8_t)slot);
} else {
compile_expr(c, upd);
emit_op(c, OP_POP);
}
}
emit_loop(c, loop_start);
if (exit_jump >= 0) patch_jump(c, exit_jump);
int skip_break_cleanup = -1;
if (break_close_slot >= 0)
skip_break_cleanup = emit_jump(c, OP_JMP);
pop_loop(c);
if (break_close_slot >= 0) {
emit_op(c, OP_CLOSE_UPVAL);
emit_u16(c, (uint16_t)break_close_slot);
patch_jump(c, skip_break_cleanup);
}
free(iter_slots);
end_scope(c);
}
static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of);
static void compile_for_in(sv_compiler_t *c, sv_ast_t *node) {
compile_for_each(c, node, false);
}
static void compile_for_of(sv_compiler_t *c, sv_ast_t *node) {
compile_for_each(c, node, true);
}
static void compile_for_each_assign_target(sv_compiler_t *c, sv_ast_t *lhs) {
if (!lhs) return;
if (lhs->type == N_VAR && lhs->args.count > 0) {
sv_ast_t *decl = lhs->args.items[0];
sv_ast_t *target = decl->left ? decl->left : decl;
if (target->type == N_IDENT) {
int loc = resolve_local(c, target->str, target->len);
if (loc == -1) {
bool is_const = (lhs->var_kind == VAR_CONST);
loc = add_local(c, target->str, target->len, is_const, c->scope_depth);
}
emit_put_local(c, loc);
} else {
if (lhs->var_kind == VAR_VAR) {
compile_lhs_set(c, target, false);
} else {
compile_destructure_binding(c, target, lhs->var_kind);
emit_op(c, OP_POP);
}
}
return;
}
if (lhs->type == N_IDENT) {
emit_set_var(c, lhs->str, lhs->len, false);
return;
}
compile_lhs_set(c, lhs, false);
}
static void compile_for_each(sv_compiler_t *c, sv_ast_t *node, bool is_for_of) {
begin_scope(c);
int *iter_slots = NULL;
int iter_count = 0;
int iter_cap = 0;
if (node->left && node->left->type == N_VAR &&
node->left->var_kind != VAR_VAR) {
bool is_const = (node->left->var_kind == VAR_CONST);
int lb = c->local_count;
for (int i = 0; i < node->left->args.count; i++) {
sv_ast_t *decl = node->left->args.items[i];
if (!decl || decl->type != N_VARDECL || !decl->left) continue;
hoist_lexical_pattern(c, decl->left, is_const);
}
for (int i = lb; i < c->local_count; i++) {
c->locals[i].is_tdz = true;
int slot = i - c->param_locals;
emit_op(c, OP_SET_LOCAL_UNDEF);
emit_u16(c, (uint16_t)slot);
}
for_collect_var_decl_slots(c, node->left, &iter_slots, &iter_count, &iter_cap);
}
if (!is_for_of && node->left && node->left->type == N_VAR &&
node->left->var_kind == VAR_VAR && node->left->args.count > 0) {
sv_ast_t *decl = node->left->args.items[0];
if (decl && decl->right) {
compile_expr(c, decl->right);
sv_ast_t *target = decl->left ? decl->left : decl;
if (target->type == N_IDENT) {
int loc = resolve_local(c, target->str, target->len);
if (loc == -1)
loc = add_local(c, target->str, target->len, false, c->scope_depth);
emit_put_local(c, loc);
} else {
compile_lhs_set(c, target, false);
}
}
}
int iter_local = -1;
int idx_local = -1;
int exit_jump = -1;
int try_jump_for_of = -1;
int iter_err_local = -1;
int break_close_slot = -1;
int iter_inner_start = -1;
bool is_for_await = (node->type == N_FOR_AWAIT_OF);
compile_expr(c, node->right);
if (is_for_of) {
emit_op(c, is_for_await ? OP_FOR_AWAIT_OF : OP_FOR_OF);
iter_err_local = add_local(c, "", 0, false, c->scope_depth);
try_jump_for_of = emit_jump(c, OP_TRY_PUSH);
c->try_depth++;
} else {
emit_op(c, OP_FOR_IN);
iter_local = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, iter_local);
emit_number(c, 0);
idx_local = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, idx_local);
}
int loop_start = c->code_len;
push_loop(c, loop_start, NULL, 0);
if (is_for_of) {
emit_op(c, is_for_await ? OP_AWAIT_ITER_NEXT : OP_ITER_NEXT);
exit_jump = emit_jump(c, OP_JMP_TRUE);
} else {
emit_get_local(c, idx_local);
emit_get_local(c, iter_local);
emit_op(c, OP_GET_LENGTH);
emit_op(c, OP_LT);
exit_jump = emit_jump(c, OP_JMP_FALSE);
emit_get_local(c, iter_local);
emit_get_local(c, idx_local);
emit_op(c, OP_GET_ELEM);
}
compile_for_each_assign_target(c, node->left);
if (iter_count > 0) {
begin_scope(c);
iter_inner_start = c->local_count;
for (int i = 0; i < iter_count; i++) {
int outer_idx = iter_slots[i];
sv_local_t outer = c->locals[outer_idx];
emit_get_local(c, outer_idx);
int inner_idx = add_local(c, outer.name, outer.name_len,
outer.is_const, c->scope_depth);
emit_put_local(c, inner_idx);
}
}
compile_stmt(c, node->body);
sv_loop_t *loop = &c->loops[c->loop_count - 1];
for (int i = 0; i < loop->continues.count; i++)
patch_jump(c, loop->continues.offsets[i]);
if (iter_count > 0) {
for (int i = 0; i < iter_count; i++) {
int inner_idx = iter_inner_start + i;
if (!c->locals[inner_idx].captured) continue;
int slot = local_to_frame_slot(c, inner_idx);
if (break_close_slot < 0 || slot < break_close_slot)
break_close_slot = slot;
}
end_scope(c);
}
if (!is_for_of) {
emit_get_local(c, idx_local);
emit_op(c, OP_INC);
emit_put_local(c, idx_local);
}
emit_loop(c, loop_start);
patch_jump(c, exit_jump);
int skip_break_cleanup = -1;
if (break_close_slot >= 0)
skip_break_cleanup = emit_jump(c, OP_JMP);
if (is_for_of) {
emit_op(c, OP_POP);
emit_op(c, OP_TRY_POP);
pop_loop(c);
if (break_close_slot >= 0) {
emit_op(c, OP_CLOSE_UPVAL);
emit_u16(c, (uint16_t)break_close_slot);
patch_jump(c, skip_break_cleanup);
}
emit_op(c, OP_TRY_POP);
emit_op(c, OP_ITER_CLOSE);
int end_jump = emit_jump(c, OP_JMP);
patch_jump(c, try_jump_for_of);
int catch_tag = emit_jump(c, OP_CATCH);
emit_put_local(c, iter_err_local);
emit_op(c, OP_ITER_CLOSE);
emit_get_local(c, iter_err_local);
emit_op(c, OP_THROW);
patch_jump(c, catch_tag);
patch_jump(c, end_jump);
c->try_depth--;
} else {
pop_loop(c);
if (break_close_slot >= 0) {
emit_op(c, OP_CLOSE_UPVAL);
emit_u16(c, (uint16_t)break_close_slot);
patch_jump(c, skip_break_cleanup);
}
}
free(iter_slots);
end_scope(c);
}
static void compile_break(sv_compiler_t *c, sv_ast_t *node) {
if (c->loop_count == 0) return;
int target = c->loop_count - 1;
if (node->str) {
for (int i = c->loop_count - 1; i >= 0; i--) {
if (c->loops[i].label &&
c->loops[i].label_len == node->len &&
memcmp(c->loops[i].label, node->str, node->len) == 0) {
target = i;
break;
}
}
}
int offset = emit_jump(c, OP_JMP);
patch_list_add(&c->loops[target].breaks, offset);
}
static void compile_continue(sv_compiler_t *c, sv_ast_t *node) {
if (c->loop_count == 0) return;
int target = c->loop_count - 1;
if (node->str) {
for (int i = c->loop_count - 1; i >= 0; i--) {
if (c->loops[i].label &&
c->loops[i].label_len == node->len &&
memcmp(c->loops[i].label, node->str, node->len) == 0) {
target = i;
break;
}
}
}
int offset = emit_jump(c, OP_JMP);
patch_list_add(&c->loops[target].continues, offset);
}
static void compile_finally_block(sv_compiler_t *c, sv_ast_t *finally_body) {
int finally_jump = emit_jump(c, OP_FINALLY);
compile_stmt(c, finally_body);
emit_op(c, OP_FINALLY_RET);
patch_jump(c, finally_jump);
}
static void compile_catch_body(sv_compiler_t *c, sv_ast_t *node) {
begin_scope(c);
if (node->catch_param && node->catch_param->type == N_IDENT) {
int loc = add_local(c, node->catch_param->str,
node->catch_param->len, false, c->scope_depth);
emit_put_local(c, loc);
} else if (node->catch_param && is_destructure_pattern_node(node->catch_param)) {
compile_destructure_binding(c, node->catch_param, VAR_LET);
emit_op(c, OP_POP);
} else {
emit_op(c, OP_POP);
}
compile_stmt(c, node->catch_body);
end_scope(c);
}
static void compile_try(sv_compiler_t *c, sv_ast_t *node) {
c->try_depth++;
int try_jump = emit_jump(c, OP_TRY_PUSH);
compile_stmt(c, node->body);
emit_op(c, OP_TRY_POP);
bool has_catch = (node->catch_body != NULL);
bool has_finally = (node->finally_body != NULL);
if (!has_finally) {
int end_jump = emit_jump(c, OP_JMP);
patch_jump(c, try_jump);
int catch_tag = emit_jump(c, OP_CATCH);
if (has_catch)
compile_catch_body(c, node);
else
emit_op(c, OP_POP);
patch_jump(c, catch_tag);
patch_jump(c, end_jump);
c->try_depth--;
return;
}
int to_finally_from_try = emit_jump(c, OP_JMP);
int to_finally_from_catch = -1;
int to_finally_from_throw = -1;
patch_jump(c, try_jump);
if (has_catch) {
int catch_tag = emit_jump(c, OP_CATCH);
int catch_throw_jump = emit_jump(c, OP_TRY_PUSH);
compile_catch_body(c, node);
emit_op(c, OP_TRY_POP);
to_finally_from_catch = emit_jump(c, OP_JMP);
patch_jump(c, catch_throw_jump);
emit_op(c, OP_POP);
to_finally_from_throw = emit_jump(c, OP_JMP);
patch_jump(c, catch_tag);
} else {
emit_op(c, OP_POP);
to_finally_from_throw = emit_jump(c, OP_JMP);
}
patch_jump(c, to_finally_from_try);
if (to_finally_from_catch >= 0) patch_jump(c, to_finally_from_catch);
if (to_finally_from_throw >= 0) patch_jump(c, to_finally_from_throw);
compile_finally_block(c, node->finally_body);
c->try_depth--;
}
static void compile_switch(sv_compiler_t *c, sv_ast_t *node) {
int case_count = node->args.count;
int default_case = -1;
int *match_to_stub = NULL;
int *stub_to_body = NULL;
if (case_count > 0) {
match_to_stub = calloc((size_t)case_count, sizeof(int));
stub_to_body = calloc((size_t)case_count, sizeof(int));
for (int i = 0; i < case_count; i++) {
match_to_stub[i] = -1;
stub_to_body[i] = -1;
}
}
compile_expr(c, node->cond);
begin_scope(c);
push_loop(c, c->code_len, NULL, 0);
for (int i = 0; i < case_count; i++) {
sv_ast_t *cas = node->args.items[i];
if (!cas->left) {
default_case = i;
continue;
}
emit_op(c, OP_DUP);
compile_expr(c, cas->left);
emit_op(c, OP_SEQ);
match_to_stub[i] = emit_jump(c, OP_JMP_TRUE);
}
int miss_jump = emit_jump(c, OP_JMP);
int default_to_body = -1;
int miss_to_end = -1;
for (int i = 0; i < case_count; i++) {
if (match_to_stub[i] < 0) continue;
patch_jump(c, match_to_stub[i]);
emit_op(c, OP_POP);
stub_to_body[i] = emit_jump(c, OP_JMP);
}
patch_jump(c, miss_jump);
emit_op(c, OP_POP);
if (default_case >= 0)
default_to_body = emit_jump(c, OP_JMP);
else
miss_to_end = emit_jump(c, OP_JMP);
for (int i = 0; i < case_count; i++) {
if (i == default_case && default_to_body >= 0)
patch_jump(c, default_to_body);
if (stub_to_body[i] >= 0)
patch_jump(c, stub_to_body[i]);
sv_ast_t *cas = node->args.items[i];
compile_stmts(c, &cas->args);
}
if (miss_to_end >= 0)
patch_jump(c, miss_to_end);
free(match_to_stub);
free(stub_to_body);
pop_loop(c);
end_scope(c);
}
static inline bool is_loop_node(sv_ast_t *n) {
return n && (n->type == N_WHILE || n->type == N_DO_WHILE ||
n->type == N_FOR || n->type == N_FOR_IN ||
n->type == N_FOR_OF || n->type == N_FOR_AWAIT_OF);
}
static void compile_label(sv_compiler_t *c, sv_ast_t *node) {
if (is_loop_node(node->body)) {
c->pending_label = node->str;
c->pending_label_len = node->len;
compile_stmt(c, node->body);
c->pending_label = NULL;
c->pending_label_len = 0;
} else {
push_loop(c, c->code_len, node->str, node->len);
compile_stmt(c, node->body);
pop_loop(c);
}
}
static void emit_field_inits(sv_compiler_t *c, sv_ast_t **fields, int count) {
sv_compiler_t *enc = c->enclosing;
for (int i = 0; i < count; i++) {
sv_ast_t *m = fields[i];
emit_op(c, OP_THIS);
if (m->right) compile_expr(c, m->right);
else emit_op(c, OP_UNDEF);
if (m->flags & FN_COMPUTED) {
int key_local = enc->computed_key_locals[i];
enc->locals[key_local].captured = true;
uint16_t slot = (uint16_t)local_to_frame_slot(enc, key_local);
int uv = add_upvalue(c, slot, true, false);
emit_op(c, OP_GET_UPVAL);
emit_u16(c, (uint16_t)uv);
} else {
compile_static_property_key(c, m->left);
}
emit_op(c, OP_SWAP);
emit_op(c, OP_DEFINE_METHOD_COMP);
emit(c, 0);
emit_op(c, OP_POP);
}
}
static sv_ast_t *find_class_constructor(sv_ast_t *node) {
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type == N_METHOD && m->left && m->left->type == N_IDENT &&
m->left->len == 11 &&
memcmp(m->left->str, "constructor", 11) == 0) {
return m;
}
}
return NULL;
}
static void compile_class_method(sv_compiler_t *c, sv_ast_t *m,
int ctor_local, int proto_local,
int preeval_key) {
bool is_static = !!(m->flags & FN_STATIC);
int home_local = is_static ? ctor_local : proto_local;
bool is_fn = (m->right && m->right->type == N_FUNC);
if (is_fn) {
compile_func_expr(c, m->right);
emit_get_local(c, home_local);
emit_op(c, OP_SET_HOME_OBJ);
emit_op(c, OP_SWAP);
} else {
emit_get_local(c, home_local);
if (m->right) compile_expr(c, m->right);
else emit_op(c, OP_UNDEF);
}
uint8_t method_flags = 0;
if (m->flags & FN_GETTER) method_flags |= 1;
if (m->flags & FN_SETTER) method_flags |= 2;
if (m->flags & FN_COMPUTED) {
if (preeval_key >= 0) emit_get_local(c, preeval_key);
else compile_expr(c, m->left);
} else compile_static_property_key(c, m->left);
emit_op(c, OP_SWAP);
emit_op(c, OP_DEFINE_METHOD_COMP);
emit(c, method_flags);
emit_op(c, OP_POP);
}
static void compile_class(sv_compiler_t *c, sv_ast_t *node) {
int outer_name_local = -1;
bool class_repl_top = is_repl_top_level(c);
if (node->str)
outer_name_local = resolve_local(c, node->str, node->len);
if (node->left)
compile_expr(c, node->left);
else
emit_op(c, OP_UNDEF);
sv_ast_t *ctor_method = find_class_constructor(node);
int field_count = 0;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type != N_METHOD) continue;
if (m == ctor_method) continue;
if (m->flags & FN_STATIC) continue;
bool is_fn = (m->right && m->right->type == N_FUNC);
if (!is_fn) field_count++;
}
sv_ast_t **field_inits = NULL;
int *computed_key_locals = NULL;
if (field_count > 0) {
field_inits = malloc(sizeof(sv_ast_t *) * field_count);
computed_key_locals = malloc(sizeof(int) * field_count);
int fi = 0;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type != N_METHOD) continue;
if (m == ctor_method) continue;
if (m->flags & FN_STATIC) continue;
bool is_fn = (m->right && m->right->type == N_FUNC);
if (!is_fn) {
field_inits[fi] = m;
if (m->flags & FN_COMPUTED) {
compile_expr(c, m->left);
int loc = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, loc);
computed_key_locals[fi] = loc;
} else {
computed_key_locals[fi] = -1;
}
fi++;
}
}
}
int *method_comp_keys = NULL;
if (node->str) {
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type != N_METHOD || !(m->flags & FN_COMPUTED)) continue;
if (m == ctor_method) continue;
bool is_fn = (m->right && m->right->type == N_FUNC);
if (!is_fn && !(m->flags & FN_STATIC)) continue;
if (!method_comp_keys) {
method_comp_keys = malloc(sizeof(int) * node->args.count);
for (int j = 0; j < node->args.count; j++) method_comp_keys[j] = -1;
}
compile_expr(c, m->left);
int loc = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, loc);
method_comp_keys[i] = loc;
}
}
int inner_name_local = -1;
if (node->str) {
begin_scope(c);
inner_name_local = add_local(c, node->str, node->len, true, c->scope_depth);
}
if (ctor_method && ctor_method->right) {
c->field_inits = field_inits;
c->field_init_count = field_count;
c->computed_key_locals = computed_key_locals;
compile_func_expr(c, ctor_method->right);
c->field_inits = NULL;
c->field_init_count = 0;
c->computed_key_locals = NULL;
} else if (field_count > 0) {
c->computed_key_locals = computed_key_locals;
sv_compiler_t comp = {0};
comp.js = c->js;
comp.source = c->source;
comp.source_len = c->source_len;
comp.enclosing = c;
comp.scope_depth = 0;
comp.is_strict = c->is_strict;
comp.param_count = 0;
emit_field_inits(&comp, field_inits, field_count);
emit_op(&comp, OP_RETURN_UNDEF);
sv_func_t *fn = code_arena_bump(sizeof(sv_func_t));
memset(fn, 0, sizeof(sv_func_t));
fn->code = code_arena_bump((size_t)comp.code_len);
memcpy(fn->code, comp.code, (size_t)comp.code_len);
fn->code_len = comp.code_len;
if (comp.const_count > 0) {
fn->constants = code_arena_bump((size_t)comp.const_count * sizeof(jsval_t));
memcpy(fn->constants, comp.constants, (size_t)comp.const_count * sizeof(jsval_t));
fn->const_count = comp.const_count;
}
if (comp.atom_count > 0) {
fn->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
memcpy(fn->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
fn->atom_count = comp.atom_count;
}
if (comp.upvalue_count > 0) {
fn->upval_descs = code_arena_bump(
(size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
memcpy(fn->upval_descs, comp.upval_descs,
(size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
fn->upvalue_count = comp.upvalue_count;
}
fn->max_locals = comp.max_local_count;
fn->max_stack = fn->max_locals + 64;
fn->param_count = comp.param_count;
fn->is_strict = comp.is_strict;
fn->filename = c->js->filename;
fn->source_line = (int)node->line;
if (node->str && node->len > 0) {
char *name = code_arena_bump(node->len + 1);
memcpy(name, node->str, node->len);
name[node->len] = '\0';
fn->name = name;
}
free(comp.code); free(comp.constants); free(comp.atoms);
free(comp.locals); free(comp.upval_descs); free(comp.loops);
int idx = add_constant(c, mkval(T_CFUNC, (uintptr_t)fn));
emit_op(c, OP_CLOSURE);
emit_u32(c, (uint32_t)idx);
} else emit_op(c, OP_UNDEF);
free(field_inits);
free(computed_key_locals);
c->computed_key_locals = NULL;
bool has_static_name = false;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type != N_METHOD) continue;
if (!(m->flags & FN_STATIC)) continue;
if (m->flags & FN_COMPUTED) continue;
if (m->left && m->left->str && m->left->len == 4 &&
memcmp(m->left->str, "name", 4) == 0) {
has_static_name = true;
break;
}
}
if (node->str && !has_static_name) {
int atom = add_atom(c, node->str, node->len);
emit_op(c, OP_DEFINE_CLASS);
emit_u32(c, (uint32_t)atom);
emit(c, 1);
} else {
emit_op(c, OP_DEFINE_CLASS);
emit_u32(c, 0);
emit(c, 0);
}
int proto_local = add_local(c, "", 0, false, c->scope_depth);
int ctor_local = add_local(c, "", 0, false, c->scope_depth);
emit_put_local(c, proto_local);
emit_put_local(c, ctor_local);
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *m = node->args.items[i];
if (m->type == N_STATIC_BLOCK) {
begin_scope(c);
compile_stmts(c, &m->args);
end_scope(c);
continue;
}
if (m->type != N_METHOD) continue;
if (m == ctor_method) continue;
bool is_fn = (m->right && m->right->type == N_FUNC);
if (!is_fn && !(m->flags & FN_STATIC)) continue;
compile_class_method(c, m, ctor_local, proto_local,
method_comp_keys ? method_comp_keys[i] : -1);
}
free(method_comp_keys);
emit_get_local(c, ctor_local);
if (inner_name_local >= 0) {
emit_op(c, OP_DUP);
emit_put_local(c, inner_name_local);
}
if (class_repl_top && node->str) {
emit_op(c, OP_DUP);
emit_atom_op(c, OP_PUT_GLOBAL, node->str, node->len);
} else if (outer_name_local >= 0) {
emit_op(c, OP_DUP);
emit_put_local(c, outer_name_local);
c->locals[outer_name_local].is_tdz = false;
}
if (node->str)
end_scope(c);
}
static sv_func_t *compile_function_body(
sv_compiler_t *enclosing,
sv_ast_t *node,
sv_compile_mode_t mode
) {
sv_compiler_t comp = {0};
comp.js = enclosing->js;
comp.source = enclosing->source;
comp.source_len = enclosing->source_len;
comp.enclosing = enclosing;
comp.scope_depth = 0;
comp.is_arrow = !!(node->flags & FN_ARROW);
comp.is_strict = enclosing->is_strict;
comp.mode = mode;
comp.strict_args_local = -1;
comp.new_target_local = -1;
comp.super_local = -1;
comp.param_count = node->args.count;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
if (p->type == N_IDENT) {
add_local(&comp, p->str, p->len, false, -1);
} else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
add_local(&comp, p->right->str, p->right->len, false, -1);
} else if (p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
add_local(&comp, p->left->str, p->left->len, false, -1);
} else add_local(&comp, "", 0, false, -1);
}
comp.param_locals = comp.local_count;
if (!comp.is_strict && node->body && node->body->type == N_BLOCK) {
for (int i = 0; i < node->body->args.count; i++) {
sv_ast_t *stmt = node->body->args.items[i];
if (!stmt || stmt->type == N_EMPTY) continue;
if (stmt->type != N_STRING) break;
if (sv_ast_is_use_strict(comp.js, stmt)) comp.is_strict = true;
}
}
if (comp.is_strict) {
const char *param_names[256];
uint32_t param_lens[256];
int param_name_count = 0;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
const char *pname = NULL;
uint32_t plen = 0;
if (p && p->type == N_IDENT) {
pname = p->str; plen = p->len;
} else if (p && p->type == N_REST && p->right && p->right->type == N_IDENT) {
pname = p->right->str; plen = p->right->len;
} else if (p && p->type == N_ASSIGN_PAT && p->left && p->left->type == N_IDENT) {
pname = p->left->str; plen = p->left->len;
}
if (!pname || plen == 0) continue;
if (is_strict_restricted_ident(pname, plen)) {
js_mkerr_typed(
comp.js, JS_ERR_SYNTAX,
"strict mode forbids '%.*s' as a parameter name",
(int)plen, pname);
return NULL;
}
for (int j = 0; j < param_name_count; j++) {
if (param_lens[j] == plen &&
memcmp(param_names[j], pname, plen) == 0) {
js_mkerr_typed(
comp.js, JS_ERR_SYNTAX,
"duplicate parameter name '%.*s' in strict mode",
(int)plen, pname);
return NULL;
}
}
if (param_name_count < (int)(sizeof(param_names) / sizeof(param_names[0]))) {
param_names[param_name_count] = pname;
param_lens[param_name_count] = plen;
param_name_count++;
}
}
}
bool has_non_simple_params = false;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
if (p->type != N_IDENT) { has_non_simple_params = true; break; }
}
bool repl_top = is_repl_top_level(&comp);
if (!has_non_simple_params && node->body) {
if (node->body->type == N_BLOCK) {
if (!repl_top) {
for (int i = 0; i < node->body->args.count; i++)
hoist_var_decls(&comp, node->body->args.items[i]);
hoist_lexical_decls(&comp, &node->body->args);
}
hoist_func_decls(&comp, &node->body->args);
} else if (!repl_top) hoist_var_decls(&comp, node->body);
}
if (!has_non_simple_params) {
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
if (p->type == N_ASSIGN_PAT) {
emit_op(&comp, OP_GET_ARG);
emit_u16(&comp, (uint16_t)i);
emit_op(&comp, OP_DUP);
emit_op(&comp, OP_IS_UNDEF);
int skip = emit_jump(&comp, OP_JMP_FALSE);
emit_op(&comp, OP_POP);
compile_expr(&comp, p->right);
patch_jump(&comp, skip);
if (p->left && p->left->type == N_IDENT) {
emit_op(&comp, OP_PUT_ARG);
emit_u16(&comp, (uint16_t)i);
} else if (p->left) {
compile_destructure_binding(&comp, p->left, VAR_LET);
emit_op(&comp, OP_POP);
} else emit_op(&comp, OP_POP);
} else if (
p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
emit_op(&comp, OP_GET_ARG);
emit_u16(&comp, (uint16_t)i);
compile_destructure_binding(&comp, p, VAR_LET);
emit_op(&comp, OP_POP);
} else if (p->type == N_REST && p->right && p->right->type == N_IDENT) {
emit_op(&comp, OP_REST);
emit_u16(&comp, (uint16_t)i);
int loc = resolve_local(&comp, p->right->str, p->right->len);
if (loc >= 0) {
emit_op(&comp, OP_PUT_ARG);
emit_u16(&comp, (uint16_t)loc);
}
} else if (p->type == N_REST && p->right) {
emit_op(&comp, OP_REST);
emit_u16(&comp, (uint16_t)i);
compile_destructure_binding(&comp, p->right, VAR_LET);
emit_op(&comp, OP_POP);
}
}
} else {
int *param_bind_locals = NULL;
int param_bind_count = 0;
int param_bind_cap = 0;
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
const char *pname = NULL;
uint32_t plen = 0;
if (p->type == N_IDENT) {
pname = p->str; plen = p->len;
} else if ((
p->type == N_ASSIGN_PAT) && p->left &&
p->left->type == N_IDENT) {
pname = p->left->str; plen = p->left->len;
} else if (
p->type == N_REST && p->right &&
p->right->type == N_IDENT) {
pname = p->right->str; plen = p->right->len;
}
int lb = comp.local_count;
if (pname && plen) {
int loc = add_local(&comp, pname, plen, false, 0);
comp.locals[loc].is_tdz = true;
int slot = loc - comp.param_locals;
emit_op(&comp, OP_SET_LOCAL_UNDEF);
emit_u16(&comp, (uint16_t)slot);
}
if (param_bind_count >= param_bind_cap) {
param_bind_cap = param_bind_cap ? param_bind_cap * 2 : 8;
param_bind_locals = realloc(
param_bind_locals,
(size_t)param_bind_cap * sizeof(int));
}
param_bind_locals[param_bind_count++] = lb;
}
for (int i = 0; i < node->args.count; i++) {
sv_ast_t *p = node->args.items[i];
int bind_lb = param_bind_locals[i];
if (p->type == N_IDENT) {
if (bind_lb < comp.local_count) {
emit_op(&comp, OP_GET_ARG);
emit_u16(&comp, (uint16_t)i);
int slot = bind_lb - comp.param_locals;
comp.locals[bind_lb].is_tdz = false;
if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
}
} else if (p->type == N_ASSIGN_PAT) {
emit_op(&comp, OP_GET_ARG);
emit_u16(&comp, (uint16_t)i);
emit_op(&comp, OP_DUP);
emit_op(&comp, OP_IS_UNDEF);
int skip = emit_jump(&comp, OP_JMP_FALSE);
emit_op(&comp, OP_POP);
compile_expr(&comp, p->right);
patch_jump(&comp, skip);
if (p->left && p->left->type == N_IDENT && bind_lb < comp.local_count) {
int slot = bind_lb - comp.param_locals;
comp.locals[bind_lb].is_tdz = false;
if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
} else if (p->left) {
compile_destructure_binding(&comp, p->left, VAR_LET);
emit_op(&comp, OP_POP);
} else {
emit_op(&comp, OP_POP);
}
} else if (
p->type == N_ARRAY_PAT || p->type == N_ARRAY ||
p->type == N_OBJECT_PAT || p->type == N_OBJECT) {
emit_op(&comp, OP_GET_ARG);
emit_u16(&comp, (uint16_t)i);
compile_destructure_binding(&comp, p, VAR_LET);
emit_op(&comp, OP_POP);
} else if (
p->type == N_REST && p->right && p->right->type == N_IDENT &&
bind_lb < comp.local_count) {
emit_op(&comp, OP_REST);
emit_u16(&comp, (uint16_t)i);
int slot = bind_lb - comp.param_locals;
comp.locals[bind_lb].is_tdz = false;
if (slot <= 255) { emit_op(&comp, OP_PUT_LOCAL8); emit(&comp, (uint8_t)slot); }
else { emit_op(&comp, OP_PUT_LOCAL); emit_u16(&comp, (uint16_t)slot); }
} else if (p->type == N_REST && p->right) {
emit_op(&comp, OP_REST);
emit_u16(&comp, (uint16_t)i);
compile_destructure_binding(&comp, p->right, VAR_LET);
emit_op(&comp, OP_POP);
}
}
free(param_bind_locals);
if (node->body) {
if (node->body->type == N_BLOCK) {
if (!repl_top) {
for (int i = 0; i < node->body->args.count; i++)
hoist_var_decls(&comp, node->body->args.items[i]);
hoist_lexical_decls(&comp, &node->body->args);
}
hoist_func_decls(&comp, &node->body->args);
} else if (!repl_top) {
hoist_var_decls(&comp, node->body);
}
}
}
if (!comp.is_arrow && has_implicit_arguments_obj(&comp) &&
(node->flags & FN_USES_ARGS)) {
comp.strict_args_local = add_local(&comp, "", 0, false, comp.scope_depth);
emit_op(&comp, OP_SPECIAL_OBJ);
emit(&comp, 0);
emit_put_local(&comp, comp.strict_args_local);
}
if (!comp.is_arrow && comp.enclosing) {
static const char nt_name[] = "\x01new.target";
comp.new_target_local = add_local(&comp, nt_name, sizeof(nt_name) - 1, false, comp.scope_depth);
emit_op(&comp, OP_SPECIAL_OBJ);
emit(&comp, 1);
emit_put_local(&comp, comp.new_target_local);
}
if (!comp.is_arrow && comp.enclosing && (node->flags & (FN_METHOD | FN_GETTER | FN_SETTER | FN_STATIC))) {
static const char sv_name[] = "\x01super";
comp.super_local = add_local(&comp, sv_name, sizeof(sv_name) - 1, false, comp.scope_depth);
emit_op(&comp, OP_SPECIAL_OBJ);
emit(&comp, 2);
emit_put_local(&comp, comp.super_local);
}
if (enclosing->field_init_count > 0) {
emit_field_inits(&comp, enclosing->field_inits, enclosing->field_init_count);
}
if (node->body) {
if (node->body->type == N_BLOCK) {
int last_expr_idx = -1;
if (has_completion_value(&comp) && node->body->args.count > 0) {
sv_ast_t *last = node->body->args.items[node->body->args.count - 1];
if (sv_ast_can_be_expression_statement(last))
last_expr_idx = node->body->args.count - 1;
}
for (int i = 0; i < node->body->args.count; i++) {
sv_ast_t *stmt = node->body->args.items[i];
if (i == last_expr_idx) {
compile_expr(&comp, stmt);
emit_close_upvals(&comp);
emit_op(&comp, OP_RETURN);
} else {
compile_stmt(&comp, stmt);
}
}
} else compile_tail_return_expr(&comp, node->body);
}
for (int i = 0; i < comp.deferred_export_count; i++) {
sv_deferred_export_t *e = &comp.deferred_exports[i];
compile_export_emit(&comp, e->name, e->len);
}
free(comp.deferred_exports);
emit_close_upvals(&comp);
emit_op(&comp, OP_RETURN_UNDEF);
int max_locals = comp.max_local_count - comp.param_locals;
sv_func_t *func = code_arena_bump(sizeof(sv_func_t));
memset(func, 0, sizeof(sv_func_t));
func->code = code_arena_bump((size_t)comp.code_len);
memcpy(func->code, comp.code, (size_t)comp.code_len);
func->code_len = comp.code_len;
if (comp.const_count > 0) {
func->constants = code_arena_bump((size_t)comp.const_count * sizeof(jsval_t));
memcpy(func->constants, comp.constants, (size_t)comp.const_count * sizeof(jsval_t));
func->const_count = comp.const_count;
}
if (comp.atom_count > 0) {
func->atoms = code_arena_bump((size_t)comp.atom_count * sizeof(sv_atom_t));
memcpy(func->atoms, comp.atoms, (size_t)comp.atom_count * sizeof(sv_atom_t));
func->atom_count = comp.atom_count;
}
if (comp.upvalue_count > 0) {
func->upval_descs = code_arena_bump(
(size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
memcpy(func->upval_descs, comp.upval_descs,
(size_t)comp.upvalue_count * sizeof(sv_upval_desc_t));
func->upvalue_count = comp.upvalue_count;
}
if (comp.srcpos_count > 0) {
func->srcpos = code_arena_bump((size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
memcpy(func->srcpos, comp.srcpos, (size_t)comp.srcpos_count * sizeof(sv_srcpos_t));
func->srcpos_count = comp.srcpos_count;
}
if (enclosing->source && enclosing->source_len > 0) {
func->source = enclosing->source;
func->source_len = (int)enclosing->source_len;
func->source_start = (int)node->src_off;
func->source_end = (node->src_end > node->src_off)
? (int)node->src_end : func->source_len;
}
func->max_locals = max_locals;
func->max_stack = max_locals + 64;
func->param_count = comp.param_count;
func->is_strict = comp.is_strict;
func->is_arrow = comp.is_arrow;
func->is_async = !!(node->flags & FN_ASYNC);
func->is_generator = !!(node->flags & FN_GENERATOR);
func->is_method = !!(node->flags & FN_METHOD);
func->is_tla = comp.is_tla;
func->filename = enclosing->js->filename;
func->source_line = (int)node->line;
if (node->str && node->len > 0) {
char *name = code_arena_bump(node->len + 1);
memcpy(name, node->str, node->len);
name[node->len] = '\0';
func->name = name;
} else if (enclosing->inferred_name && enclosing->inferred_name_len > 0) {
char *name = code_arena_bump(enclosing->inferred_name_len + 1);
memcpy(name, enclosing->inferred_name, enclosing->inferred_name_len);
name[enclosing->inferred_name_len] = '\0';
func->name = name;
}
free(comp.code);
free(comp.constants);
free(comp.atoms);
free(comp.locals);
free(comp.upval_descs);
free(comp.loops);
free(comp.srcpos);
return func;
}
static const char *sv_op_names[OP__COUNT] = {
#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = #name,
#include "silver/opcode.h"
};
enum {
SVF_none, SVF_u8, SVF_i8, SVF_u16, SVF_i16, SVF_u32, SVF_i32,
SVF_atom, SVF_atom_u8, SVF_label, SVF_label8, SVF_loc, SVF_loc8,
SVF_loc_atom, SVF_arg, SVF_const, SVF_const8, SVF_npop, SVF_var_ref,
};
static const uint8_t sv_op_fmts[OP__COUNT] = {
#define OP_DEF(name, size, n_pop, n_push, f) [OP_##name] = SVF_##f,
#include "silver/opcode.h"
};
void sv_disasm(ant_t *js, sv_func_t *func, const char *label) {
const char *fname = func->name ? func->name : "";
fprintf(stderr, "[generated bytecode for function: %s (%p <SharedFunctionInfo %s>)]\n",
fname, (void *)func, fname);
fprintf(stderr, "Bytecode length: %d\n", func->code_len);
fprintf(stderr, "Parameter count %d\n", func->param_count);
fprintf(stderr, "Register count %d\n", func->max_locals);
fprintf(stderr, "Frame size %d\n", func->max_locals * (int)sizeof(jsval_t));
int pc = 0;
while (pc < func->code_len) {
uint8_t op = func->code[pc];
const char *name = (op < OP__COUNT) ? sv_op_names[op] : "???";
uint8_t size = (op < OP__COUNT) ? sv_op_size[op] : 1;
uint8_t fmt = (op < OP__COUNT) ? sv_op_fmts[op] : SVF_none;
uint32_t line, col;
if (sv_lookup_srcpos(func, pc, &line, &col))
fprintf(stderr, "%5u S> ", line);
else
fprintf(stderr, " ");
fprintf(stderr, "%p @ %4d : ", (void *)(func->code + pc), pc);
char hex[32];
int hlen = 0;
for (int i = 0; i < size && i < 8; i++)
hlen += snprintf(hex + hlen, sizeof(hex) - hlen, "%02x ", func->code[pc + i]);
fprintf(stderr, "%-18s", hex);
fprintf(stderr, "%s", name ? name : "???");
switch (fmt) {
case SVF_u8:
fprintf(stderr, " [%d]", func->code[pc + 1]);
break;
case SVF_i8:
fprintf(stderr, " [%d]", (int8_t)func->code[pc + 1]);
break;
case SVF_u16:
fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
break;
case SVF_i16:
fprintf(stderr, " [%d]", (int16_t)sv_get_u16(func->code + pc + 1));
break;
case SVF_u32:
fprintf(stderr, " [%d]", (int)sv_get_u32(func->code + pc + 1));
break;
case SVF_i32:
fprintf(stderr, " [%d]", (int32_t)sv_get_u32(func->code + pc + 1));
break;
case SVF_atom: {
uint32_t idx = sv_get_u32(func->code + pc + 1);
if (idx < (uint32_t)func->atom_count)
fprintf(stderr, " [%.*s]", (int)func->atoms[idx].len, func->atoms[idx].str);
else
fprintf(stderr, " a%u", idx);
break;
}
case SVF_atom_u8: {
uint32_t idx = sv_get_u32(func->code + pc + 1);
uint8_t extra = func->code[pc + 5];
if (idx < (uint32_t)func->atom_count)
fprintf(stderr, " [%.*s], [%d]", (int)func->atoms[idx].len, func->atoms[idx].str, extra);
else
fprintf(stderr, " a%u, [%d]", idx, extra);
break;
}
case SVF_label: {
int32_t off = (int32_t)sv_get_u32(func->code + pc + 1);
fprintf(stderr, " [%d] (%d)", off, pc + size + off);
break;
}
case SVF_label8: {
int8_t off = (int8_t)func->code[pc + 1];
fprintf(stderr, " [%d] (%d)", off, pc + size + off);
break;
}
case SVF_loc:
fprintf(stderr, " r%d", sv_get_u16(func->code + pc + 1));
break;
case SVF_loc8:
fprintf(stderr, " r%d", func->code[pc + 1]);
break;
case SVF_loc_atom: {
uint16_t slot = sv_get_u16(func->code + pc + 1);
uint32_t aidx = sv_get_u32(func->code + pc + 3);
fprintf(stderr, " r%d", slot);
if (aidx < (uint32_t)func->atom_count)
fprintf(stderr, ", [%.*s]", (int)func->atoms[aidx].len, func->atoms[aidx].str);
else
fprintf(stderr, ", a%u", aidx);
break;
}
case SVF_arg:
fprintf(stderr, " a%d", sv_get_u16(func->code + pc + 1));
break;
case SVF_const: {
uint32_t idx = sv_get_u32(func->code + pc + 1);
fprintf(stderr, " [%u]", idx);
break;
}
case SVF_const8:
fprintf(stderr, " [%d]", func->code[pc + 1]);
break;
case SVF_npop:
fprintf(stderr, " %d", sv_get_u16(func->code + pc + 1));
break;
case SVF_var_ref:
fprintf(stderr, " [%d]", sv_get_u16(func->code + pc + 1));
break;
default:
break;
}
fprintf(stderr, "\n");
pc += size;
}
fprintf(stderr, "Constant pool (size = %d)\n", func->const_count);
for (int i = 0; i < func->const_count; i++) {
jsval_t v = func->constants[i];
uint8_t t = vtype(v);
if (t == T_STR) {
jsoff_t slen;
jsoff_t soff = vstr(js, v, &slen);
fprintf(stderr, " %d: <String[%d]: #%.*s>\n", i, (int)slen, (int)slen, &js->mem[soff]);
} else if (t == T_NUM) {
fprintf(stderr, " %d: <Number [%g]>\n", i, tod(v));
} else if (t == T_CFUNC) {
sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(v);
const char *cname = child->name ? child->name : "";
fprintf(stderr, " %d: <SharedFunctionInfo %s>\n", i, cname);
} else fprintf(stderr, " %d: <Unknown type=%d>\n", i, t);
}
if (func->atom_count > 0) {
fprintf(stderr, "Atom table (size = %d)\n", func->atom_count);
for (int i = 0; i < func->atom_count; i++)
fprintf(stderr, " %d: <String[%d]: #%.*s>\n",
i, (int)func->atoms[i].len, (int)func->atoms[i].len, func->atoms[i].str);
}
fprintf(stderr, "Handler Table (size = 0)\n");
fprintf(stderr, "Source Position Table (size = %d)\n", func->srcpos_count);
fprintf(stderr, "\n");
for (int i = 0; i < func->const_count; i++) {
if (vtype(func->constants[i]) == T_CFUNC) {
sv_func_t *child = (sv_func_t *)(uintptr_t)vdata(func->constants[i]);
char child_label[256];
snprintf(child_label, sizeof(child_label), "%s/closure[%d]", label, i);
sv_disasm(js, child, child_label);
}
}
}
sv_func_t *sv_compile(ant_t *js, sv_ast_t *program, sv_compile_mode_t mode, const char *source, jsoff_t source_len) {
if (!program || program->type != N_PROGRAM) return NULL;
static const char *k_top_name_script = "<script>";
static const char *k_top_name_module = "<module>";
static const char *k_top_name_eval = "<eval>";
static const char *k_top_name_repl = "<repl>";
const char *top_name = k_top_name_script;
switch (mode) {
case SV_COMPILE_MODULE: top_name = k_top_name_module; break;
case SV_COMPILE_EVAL: top_name = k_top_name_eval; break;
case SV_COMPILE_REPL: top_name = k_top_name_repl; break;
case SV_COMPILE_SCRIPT:
default: top_name = k_top_name_script; break;
}
sv_ast_t top_fn;
memset(&top_fn, 0, sizeof(top_fn));
top_fn.type = N_FUNC;
top_fn.line = 1;
top_fn.str = top_name;
top_fn.len = (uint32_t)strlen(top_name);
top_fn.src_off = 0;
top_fn.src_end = (source_len > 0) ? (uint32_t)source_len : 0;
top_fn.body = sv_ast_new(N_BLOCK);
top_fn.body->args = program->args;
sv_compiler_t root = {0};
root.js = js;
root.source = pin_source_text(source, source_len);
root.source_len = source_len;
root.mode = mode;
root.is_strict = ((program->flags & FN_PARSE_STRICT) != 0);
sv_func_t *func = compile_function_body(&root, &top_fn, mode);
if (js->thrown_exists || !func) return NULL;
return func;
}
sv_func_t *sv_compile_function(ant_t *js, const char *source, size_t len, bool is_async) {
const char *prefix = is_async ? "(async function" : "(function";
size_t prefix_len = strlen(prefix);
size_t wrapped_len = prefix_len + len + 1;
char *wrapped = malloc(wrapped_len + 1);
if (!wrapped) return NULL;
memcpy(wrapped, prefix, prefix_len);
memcpy(wrapped + prefix_len, source, len);
wrapped[prefix_len + len] = ')';
wrapped[wrapped_len] = '\0';
bool parse_strict = sv_vm_is_strict(js->vm);
sv_ast_t *program = sv_parse(js, wrapped, (jsoff_t)wrapped_len, parse_strict);
if (!program) { free(wrapped); return NULL; }
sv_ast_t *func_node = NULL;
if (program->args.count > 0) {
sv_ast_t *stmt = program->args.items[0];
if (stmt && stmt->type == N_FUNC)
func_node = stmt;
else if (stmt && stmt->left && stmt->left->type == N_FUNC)
func_node = stmt->left;
}
if (!func_node) { free(wrapped); return NULL; }
sv_compiler_t root = {0};
root.js = js;
root.source = pin_source_text(wrapped, (jsoff_t)wrapped_len);
root.source_len = (jsoff_t)wrapped_len;
root.mode = SV_COMPILE_SCRIPT;
root.is_strict = (program->flags & FN_PARSE_STRICT) != 0;
sv_func_t *func = compile_function_body(&root, func_node, SV_COMPILE_SCRIPT);
free(wrapped);
if (js->thrown_exists || !func) return NULL;
return func;
}
sv_func_t *sv_compile_function_parts(
ant_t *js,
const char *params,
size_t params_len,
const char *body,
size_t body_len,
bool is_async
) {
size_t source_len = params_len + body_len + 3;
char *source = malloc(source_len + 1);
if (!source) return NULL;
size_t pos = 0;
source[pos++] = '(';
if (params_len > 0 && params) {
memcpy(source + pos, params, params_len);
pos += params_len;
}
source[pos++] = ')';
source[pos++] = '{';
if (body_len > 0 && body) {
memcpy(source + pos, body, body_len);
pos += body_len;
}
source[pos++] = '}';
source[pos] = '\0';
sv_func_t *func = sv_compile_function(js, source, pos, is_async);
free(source);
return func;
}

File Metadata

Mime Type
text/x-c
Expires
Thu, Mar 26, 4:41 PM (2 d)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
511846
Default Alt Text
compiler.c (125 KB)

Event Timeline