zzy/spl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stage1 优化重构代码

Browse Source
This commit is contained in:
zzy
2026-07-11 23:18:06 +08:00
parent 53ae30f1ca
commit f1b4225c92
3 changed files with 563 additions and 535 deletions
Download Patch File Download Diff File Expand all files Collapse all files

514
stage1/spl_stmt.c
View File

@@ -25,18 +25,7 @@ static void parse_ret_stmt(spl_comp_t *ctx) {
} else {
spl_expr_result_t val = spl_parse_expr(ctx, PREC_MIN);
(void)val;
spl_type_t rt = SPL_VOID;
if (ctx->current_ret_type) {
if (ctx->current_ret_type->kind == TYPE_BASIC) {
rt = ctx->current_ret_type->basic_type;
} else if (ctx->current_ret_type->kind == TYPE_PTR) {
rt = SPL_PTR;
} else if (spl_type_size(ctx->current_ret_type) <= sizeof(spl_val_t)) {
/* 1-slot struct/enum/etc: use PTR type */
rt = SPL_PTR;
}
}
spl_emit(ctx, SPL_RET, rt, 0);
spl_emit_ret(ctx, ctx->current_ret_type);
}
if (peek(ctx)->type == TOK_SEMICOLON)
advance(ctx);
@@ -84,9 +73,18 @@ static void parse_var_decl(spl_comp_t *ctx, int is_const) {
/* Init expression: parse before declare to enable type inference */
spl_expr_result_t init = {0};
int inline_lit = 0;
if (has_init) {
skip_nl(ctx);
init = spl_parse_expr(ctx, PREC_MIN);
/* Inline struct/enum/slice literal: var x: Type = { .field = val }
* Don't call spl_parse_expr — { would be consumed as block expression */
if (var_type && peek(ctx)->type == TOK_L_BRACE &&
(var_type->kind == TYPE_STRUCT || var_type->kind == TYPE_ENUM ||
var_type->kind == TYPE_SLICE)) {
inline_lit = 1;
} else {
init = spl_parse_expr(ctx, PREC_MIN);
}
}
if (!var_type) {
@@ -96,84 +94,19 @@ static void parse_var_decl(spl_comp_t *ctx, int is_const) {
/* Store init value */
if (has_init) {
/* Handle slice struct literal: { .ptr = ..., .len = ... } */
if (var_type && var_type->kind == TYPE_SLICE && peek(ctx)->type == TOK_L_BRACE &&
!init.type) {
advance(ctx); /* { */
skip_nl(ctx);
while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
if (peek(ctx)->type == TOK_COMMA) {
advance(ctx);
skip_nl(ctx);
continue;
}
if (peek(ctx)->type == TOK_DOT)
advance(ctx);
spl_tok_t *ftok = advance(ctx);
char fname[256];
usize fnl = ftok->len < 255 ? ftok->len : 255;
memcpy(fname, ftok->lexeme, fnl);
fname[fnl] = '\0';
skip_nl(ctx);
if (peek(ctx)->type == TOK_ASSIGN)
advance(ctx);
skip_nl(ctx);
spl_expr_result_t fv = spl_parse_expr(ctx, PREC_MIN);
(void)fv;
if (strcmp(fname, "ptr") == 0) {
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset);
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_PTR, 0);
} else if (strcmp(fname, "len") == 0) {
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset + (int)sizeof(spl_val_t));
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_USIZE, 0);
}
skip_nl(ctx);
}
expect(ctx, TOK_R_BRACE);
} else if (var_type && (var_type->kind == TYPE_STRUCT || var_type->kind == TYPE_ENUM)) {
/* Struct/enum initialization */
usize sz = spl_type_size(var_type);
if (sz <= sizeof(spl_val_t)) {
/* Fits in one slot: value on stack, store directly */
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset);
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_PTR, 0);
if (inline_lit && (var_type->kind == TYPE_STRUCT || var_type->kind == TYPE_ENUM ||
var_type->kind == TYPE_SLICE)) {
/* Inline struct/enum/slice literal: var x: Type = { .field = val }
* Use spl_parse_struct_literal to handle field parsing uniformly. */
spl_parse_struct_literal(ctx, var_type);
if (var_type->kind == TYPE_SLICE) {
/* Slice: copy 2 temp slots to variable */
spl_emit_copy_slots(ctx, offset, 2);
} else {
/* Multi-slot: copy from temp addr to var, slot by slot */
usize nslots = (sz + sizeof(spl_val_t) - 1) / sizeof(spl_val_t);
spl_emit_copy_slots(ctx, offset, nslots);
spl_emit_store_init(ctx, offset, var_type);
}
} else if (var_type && var_type->kind == TYPE_ARRAY) {
/* Array initialization: store each element in reverse stack order */
spl_type_info_t *elem = var_type->elem;
spl_type_t bt = (elem && elem->kind == TYPE_BASIC) ? elem->basic_type : SPL_I32;
usize stride = spl_type_elem_stride(elem);
for (int i = (int)var_type->array_len - 1; i >= 0; i--) {
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset + (int)(i * stride));
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, bt, 0);
}
} else if (var_type && var_type->kind == TYPE_SLICE) {
/* Slice initialization: stack has [ptr, len] from slice expression.
* Store len at offset+8, then ptr at offset. */
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset + (int)sizeof(spl_val_t));
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_USIZE, 0);
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset);
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_PTR, 0);
} else {
/* Single value store */
spl_emit(ctx, SPL_LADDR, SPL_PTR, offset);
spl_type_t bt = (var_type->kind == TYPE_BASIC) ? var_type->basic_type
: (var_type->kind == TYPE_PTR) ? SPL_PTR
: SPL_I32;
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, bt, 0);
spl_emit_store_init(ctx, offset, var_type);
}
}
@@ -206,6 +139,88 @@ void spl_parse_block(spl_comp_t *ctx) {
}
}
/* Forward declaration for block expr */
static int is_assign_op(spl_tok_type_t t);
/* ============================================================
* Block expression: { stmts; [trailing_expr] }
* Parses a block and returns the trailing expression type.
* Like Rust/Zig: the last expression without semicolon is the block's value.
* ============================================================ */
spl_expr_result_t spl_parse_block_expr(spl_comp_t *ctx) {
advance(ctx); /* { */
spl_push_scope(ctx);
spl_expr_result_t result = {0}; /* void by default */
skip_nl(ctx);
while (peek(ctx)->type != TOK_R_BRACE && peek(ctx)->type != TOK_EOF) {
if (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_ENDLINE) {
advance(ctx);
skip_nl(ctx);
continue;
}
spl_tok_type_t t = peek(ctx)->type;
int is_keyword = (t == KW_RET || t == KW_VAR || t == KW_CONST || t == KW_IF ||
t == KW_WHILE || t == KW_LOOP || t == KW_FOR || t == KW_BREAK ||
t == KW_CONTINUE || t == KW_DEFER || t == KW_MATCH || t == KW_TYPE ||
t == TOK_L_BRACE || t == TOK_SHARP || t == TOK_LINE_COMMENT);
if (is_keyword) {
/* Keyword statement — produces void */
spl_parse_stmt(ctx);
result = (spl_expr_result_t){0};
} else {
/* Expression — look ahead for assignment */
int is_assign = 0;
{
usize look = ctx->tok_idx;
while (look < vec_size(ctx->toks)) {
spl_tok_type_t lt = vec_at(ctx->toks, look).type;
if (lt == TOK_SEMICOLON || lt == TOK_ENDLINE || lt == TOK_R_BRACE ||
lt == TOK_EOF)
break;
if (lt == TOK_L_PAREN)
break;
if (is_assign_op(lt)) {
is_assign = 1;
break;
}
look++;
}
}
int saved_addr = ctx->addr_of_mode;
if (is_assign)
ctx->addr_of_mode = 1;
spl_expr_result_t expr = spl_parse_expr(ctx, PREC_MIN);
ctx->addr_of_mode = saved_addr;
skip_nl(ctx);
if (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_ENDLINE) {
/* Expression statement: drop value, consume ; */
if (!is_assign && expr.type && expr.type->kind == TYPE_BASIC &&
expr.type->basic_type != SPL_VOID)
spl_emit(ctx, SPL_DROP, SPL_VOID, 0);
while (peek(ctx)->type == TOK_SEMICOLON || peek(ctx)->type == TOK_ENDLINE)
advance(ctx);
result = (spl_expr_result_t){0};
} else {
/* Trailing expression — this is the block's value */
result = expr;
}
}
skip_nl(ctx);
}
spl_emit_defer_epilogue(ctx, ctx->scope_depth);
spl_pop_scope(ctx);
expect(ctx, TOK_R_BRACE);
return result;
}
/* ============================================================
* If statement: if expr { ... } [else { ... }]
* ============================================================ */
@@ -234,41 +249,53 @@ static void parse_if_stmt(spl_comp_t *ctx) {
}
}
/* ============================================================
* Loop context helpers (save/restore loop state for while/loop/for)
* ============================================================ */
typedef struct {
int saved_loop;
usize saved_continue;
usize saved_bp_count;
spl_val_t loop_start;
} spl_loop_save_t;
static void loop_enter(spl_comp_t *ctx, spl_loop_save_t *save) {
save->loop_start = vec_size(ctx->prog.insns);
save->saved_loop = ctx->in_loop;
save->saved_continue = ctx->continue_target;
save->saved_bp_count = ctx->break_patch_count;
ctx->in_loop = 1;
ctx->continue_target = save->loop_start;
}
static void loop_exit(spl_comp_t *ctx, spl_loop_save_t *save) {
spl_val_t here = vec_size(ctx->prog.insns);
spl_emit(ctx, SPL_JMP, SPL_VOID, (spl_val_t)((isize)save->loop_start - (isize)here - 1));
for (usize i = save->saved_bp_count; i < ctx->break_patch_count; i++)
spl_patch_to_here(ctx, ctx->break_patches[i]);
ctx->break_patch_count = save->saved_bp_count;
ctx->in_loop = save->saved_loop;
ctx->continue_target = save->saved_continue;
}
/* ============================================================
* While statement: while expr { ... }
* ============================================================ */
static void parse_while_stmt(spl_comp_t *ctx) {
spl_val_t loop_start = vec_size(ctx->prog.insns);
int saved_loop = ctx->in_loop;
usize saved_continue = ctx->continue_target;
usize saved_bp_count = ctx->break_patch_count;
ctx->in_loop = 1;
ctx->continue_target = loop_start;
advance(ctx); /* while */
skip_nl(ctx);
spl_expr_result_t cond = spl_parse_expr(ctx, PREC_MIN);
(void)cond;
spl_loop_save_t save;
loop_enter(ctx, &save);
spl_val_t bz_addr = spl_emit_bz(ctx);
skip_nl(ctx);
spl_parse_block(ctx);
/* JMP back to loop condition — use relative offset */
spl_val_t here = vec_size(ctx->prog.insns);
spl_emit(ctx, SPL_JMP, SPL_VOID, (spl_val_t)((isize)loop_start - (isize)here - 1));
loop_exit(ctx, &save);
spl_patch_to_here(ctx, bz_addr);
/* Patch break statements — compute relative offset */
for (usize i = saved_bp_count; i < ctx->break_patch_count; i++) {
spl_patch_to_here(ctx, ctx->break_patches[i]);
}
ctx->break_patch_count = saved_bp_count;
ctx->in_loop = saved_loop;
ctx->continue_target = saved_continue;
}
/* ============================================================
@@ -276,30 +303,12 @@ static void parse_while_stmt(spl_comp_t *ctx) {
* ============================================================ */
static void parse_loop_stmt(spl_comp_t *ctx) {
spl_val_t loop_start = vec_size(ctx->prog.insns);
int saved_loop = ctx->in_loop;
usize saved_continue = ctx->continue_target;
usize saved_bp_count = ctx->break_patch_count;
ctx->in_loop = 1;
ctx->continue_target = loop_start;
spl_loop_save_t save;
loop_enter(ctx, &save);
advance(ctx); /* loop */
skip_nl(ctx);
spl_parse_block(ctx);
/* JMP back to loop start — use relative offset */
spl_val_t here = vec_size(ctx->prog.insns);
spl_emit(ctx, SPL_JMP, SPL_VOID, (spl_val_t)((isize)loop_start - (isize)here - 1));
/* Patch break statements — compute relative offset */
for (usize i = saved_bp_count; i < ctx->break_patch_count; i++) {
spl_patch_to_here(ctx, ctx->break_patches[i]);
}
ctx->break_patch_count = saved_bp_count;
ctx->in_loop = saved_loop;
ctx->continue_target = saved_continue;
loop_exit(ctx, &save);
}
/* ============================================================
@@ -344,21 +353,15 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_STORE, SPL_USIZE, 0);
/* Stack: [end] */
spl_val_t loop_start = vec_size(ctx->prog.insns);
/* Condition: i < end */
spl_loop_save_t save;
loop_enter(ctx, &save);
spl_emit(ctx, SPL_LADDR, SPL_PTR, ioffset);
spl_emit(ctx, SPL_LOAD, SPL_USIZE, 0);
spl_emit(ctx, SPL_PICK, SPL_VOID, 1);
spl_emit(ctx, SPL_ULT, SPL_USIZE, 0);
spl_val_t bz_addr = spl_emit_bz(ctx);
int saved_loop = ctx->in_loop;
usize saved_continue = ctx->continue_target;
usize saved_bp_count = ctx->break_patch_count;
ctx->in_loop = 1;
ctx->continue_target = loop_start;
skip_nl(ctx);
spl_parse_block(ctx); /* body */
@@ -370,21 +373,12 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_ADD, SPL_USIZE, 0);
spl_emit(ctx, SPL_STORE, SPL_USIZE, 0);
/* JMP back to condition */
spl_val_t jmp_here = vec_size(ctx->prog.insns);
spl_emit(ctx, SPL_JMP, SPL_VOID, (spl_val_t)((isize)loop_start - (isize)jmp_here - 1));
loop_exit(ctx, &save);
/* Exit: patch bz, drop end */
spl_patch_to_here(ctx, bz_addr);
spl_emit(ctx, SPL_DROP, SPL_VOID, 0);
/* Patch breaks */
for (usize i = saved_bp_count; i < ctx->break_patch_count; i++)
spl_patch_to_here(ctx, ctx->break_patches[i]);
ctx->break_patch_count = saved_bp_count;
ctx->in_loop = saved_loop;
ctx->continue_target = saved_continue;
spl_emit_defer_epilogue(ctx, ctx->scope_depth);
spl_pop_scope(ctx);
return;
@@ -458,7 +452,8 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_PUSH, SPL_USIZE, 0);
/* Stack: [ptr, len, idx=0] */
spl_val_t loop_start = vec_size(ctx->prog.insns);
spl_loop_save_t save;
loop_enter(ctx, &save);
/* Condition: idx < len */
spl_emit(ctx, SPL_PICK, SPL_VOID, 1); /* copy len */
@@ -487,13 +482,6 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_STORE, SPL_I32, 0);
/* Loop context */
int saved_loop = ctx->in_loop;
usize saved_continue = ctx->continue_target;
usize saved_bp_count = ctx->break_patch_count;
ctx->in_loop = 1;
ctx->continue_target = loop_start;
skip_nl(ctx);
spl_parse_block(ctx); /* body */
@@ -504,9 +492,7 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_SWAP, SPL_VOID, 0);
spl_emit(ctx, SPL_DROP, SPL_VOID, 0); /* replace old idx with new */
/* JMP back to condition */
spl_val_t jmp_here = vec_size(ctx->prog.insns);
spl_emit(ctx, SPL_JMP, SPL_VOID, (spl_val_t)((isize)loop_start - (isize)jmp_here - 1));
loop_exit(ctx, &save);
/* Exit: patch bz, drop idx, len, ptr */
spl_patch_to_here(ctx, bz_addr);
@@ -514,13 +500,6 @@ static void parse_for_stmt(spl_comp_t *ctx) {
spl_emit(ctx, SPL_DROP, SPL_VOID, 0); /* drop len */
spl_emit(ctx, SPL_DROP, SPL_VOID, 0); /* drop ptr */
/* Patch breaks */
for (usize i = saved_bp_count; i < ctx->break_patch_count; i++)
spl_patch_to_here(ctx, ctx->break_patches[i]);
ctx->break_patch_count = saved_bp_count;
ctx->in_loop = saved_loop;
ctx->continue_target = saved_continue;
spl_pop_scope(ctx);
}
@@ -582,10 +561,92 @@ static void parse_defer_stmt(spl_comp_t *ctx) {
}
}
/* ============================================================
* Match statement helpers
* ============================================================ */
/* Parse an enum variant pattern in a match arm: .VariantName
* Delegates comparison to expr layer (spl_emit_match_enum_cmp).
* Returns the variant for binding parsing, or NULL on error. */
static spl_enum_variant_t *parse_match_enum_variant(spl_comp_t *ctx, spl_type_info_t *enum_type,
int val_offset) {
return spl_emit_match_enum_cmp(ctx, enum_type, val_offset);
}
/* Parse a value pattern in a match arm (non-enum).
* Delegates comparison to expr layer (spl_emit_match_value_cmp).
* Uses PREC_LOGOR internally to prevent => from being consumed as assignment. */
static void parse_match_value_pattern(spl_comp_t *ctx, int val_offset) {
spl_emit_match_value_cmp(ctx, val_offset);
}
/* Parse enum variant data bindings: (name1, name2, ...)
* Declares local variables and loads corresponding field data
* from the matched value's data area (offset 4+).
* Sets *scope_pushed = 1 if bindings declared. */
static void parse_match_enum_bindings(spl_comp_t *ctx, spl_enum_variant_t *variant, int val_offset,
int *scope_pushed) {
advance(ctx); /* ( */
skip_nl(ctx);
if (peek(ctx)->type == TOK_R_PAREN) {
expect(ctx, TOK_R_PAREN);
return;
}
spl_push_scope(ctx);
*scope_pushed = 1;
if (variant->data_type && variant->data_type->kind == TYPE_STRUCT) {
/* Multi-field struct destructuring: one binding per struct field */
int bi = 0;
for (;;) {
spl_tok_t *btok = advance(ctx);
char bname[256];
usize bnl = btok->len < 255 ? btok->len : 255;
memcpy(bname, btok->lexeme, bnl);
bname[bnl] = '\0';
spl_type_info_t *btype = spl_type_basic(SPL_I32);
usize field_byte_off = 4; /* skip tag */
if ((usize)bi < vec_size(variant->data_type->fields)) {
btype = vec_at(variant->data_type->fields, bi).type;
field_byte_off = 4 + vec_at(variant->data_type->fields, bi).offset;
}
int boffset = spl_declare_var(ctx, bname, btype, 0);
spl_emit_load_to_var(ctx, val_offset, field_byte_off, btype, boffset);
bi++;
skip_nl(ctx);
if (peek(ctx)->type == TOK_COMMA) {
advance(ctx);
skip_nl(ctx);
continue;
}
break;
}
} else if (variant->data_type) {
/* Single-value binding */
spl_tok_t *btok = advance(ctx);
char bname[256];
usize bnl = btok->len < 255 ? btok->len : 255;
memcpy(bname, btok->lexeme, bnl);
bname[bnl] = '\0';
spl_type_info_t *btype = variant->data_type;
int boffset = spl_declare_var(ctx, bname, btype, 0);
spl_emit_load_to_var(ctx, val_offset, 4, btype, boffset);
}
expect(ctx, TOK_R_PAREN);
}
/* ============================================================
* Match statement:
* Enum: match expr { .Variant(bindings) => stmt, ... }
* Int: match expr { literal => stmt, ..., _ => stmt }
* Value: match expr { lit, lit => stmt, ..., _ => stmt }
*
* Built as enhanced if-else: each arm is a condition chain.
* Fallthrough (comma-separated patterns) uses BNZ for OR.
* ============================================================ */
static void parse_match_stmt(spl_comp_t *ctx) {
@@ -594,11 +655,9 @@ static void parse_match_stmt(spl_comp_t *ctx) {
spl_expr_result_t expr = spl_parse_expr(ctx, PREC_MIN);
/* Determine match type (enum or integer) */
/* Determine match type */
int is_enum_match = 0;
int is_int_match = 0;
spl_type_info_t *enum_type = NULL;
spl_type_info_t *t = expr.type;
if (t && t->kind == TYPE_ENUM) {
is_enum_match = 1;
@@ -606,16 +665,12 @@ static void parse_match_stmt(spl_comp_t *ctx) {
} else if (t && t->kind == TYPE_PTR && t->elem && t->elem->kind == TYPE_ENUM) {
is_enum_match = 1;
enum_type = t->elem;
} else if (t && t->kind == TYPE_BASIC && spl_type_is_integer(t->basic_type)) {
is_int_match = 1;
}
if (!is_enum_match && !is_int_match) {
} else if (!(t && t->kind == TYPE_BASIC && spl_type_is_integer(t->basic_type))) {
spl_comp_error(ctx, "match expression must be an enum or integer type");
return;
}
/* Save the value/address to a temp slot */
/* Save match value to temp slot */
int val_offset = ctx->current_local_bytes;
ctx->current_local_bytes += (int)sizeof(spl_val_t);
if (ctx->current_local_bytes > ctx->peak_local_bytes)
@@ -650,57 +705,23 @@ static void parse_match_stmt(spl_comp_t *ctx) {
int n_bnz = 0;
spl_enum_variant_t *arm_variant = NULL;
/* --- Parse arm pattern(s): comma-separated values with fallthrough --- */
/* --- Parse arm pattern(s): comma-separated with fallthrough --- */
if (peek(ctx)->type == KW_ANY) {
/* _ default arm: always matches, no comparison */
/* _ default arm: always matches, skip comparison */
advance(ctx);
} else {
for (;;) {
if (is_enum_match) {
/* .VariantName */
if (peek(ctx)->type == TOK_DOT)
advance(ctx);
spl_tok_t *vtok = advance(ctx);
char vname[256];
usize vnl = vtok->len < 255 ? vtok->len : 255;
memcpy(vname, vtok->lexeme, vnl);
vname[vnl] = '\0';
spl_enum_variant_t *variant = NULL;
vec_for(enum_type->variants, vi) {
if (strcmp(vec_at(enum_type->variants, vi).name, vname) == 0) {
variant = &vec_at(enum_type->variants, vi);
break;
}
}
if (!variant) {
spl_comp_error(ctx, "unknown variant '%s' in match", vname);
arm_variant = parse_match_enum_variant(ctx, enum_type, val_offset);
if (ctx->has_error)
break;
}
arm_variant = variant;
/* Compare tag: load [val_offset] → addr → +0 → tag */
spl_emit(ctx, SPL_LADDR, SPL_PTR, val_offset);
spl_emit(ctx, SPL_LOAD, SPL_PTR, 0);
spl_emit(ctx, SPL_PUSH, SPL_USIZE, 0);
spl_emit(ctx, SPL_ADD, SPL_USIZE, 0);
spl_emit(ctx, SPL_LOAD, SPL_I32, 0);
spl_emit(ctx, SPL_PUSH, SPL_I32, variant->value);
spl_emit(ctx, SPL_EQ, SPL_I32, 0);
/* If bindings follow, this must be the last pattern */
skip_nl(ctx);
if (peek(ctx)->type == TOK_L_PAREN) {
has_parens = 1;
break;
break; /* bindings → must be last in fallthrough group */
}
} else if (is_int_match) {
/* Parse expression as arm value */
spl_parse_expr(ctx, PREC_MIN);
/* Compare: load saved match value, then EQ */
spl_emit(ctx, SPL_LADDR, SPL_PTR, val_offset);
spl_emit(ctx, SPL_LOAD, SPL_PTR, 0);
spl_emit(ctx, SPL_EQ, SPL_I32, 0);
} else {
parse_match_value_pattern(ctx, val_offset);
}
/* Check for more comma-separated patterns */
@@ -708,9 +729,8 @@ static void parse_match_stmt(spl_comp_t *ctx) {
if (peek(ctx)->type == TOK_COMMA) {
advance(ctx);
skip_nl(ctx);
/* If another pattern follows (not ⇒), emit BNZ for fallthrough */
if (peek(ctx)->type != TOK_ASSIGN) {
bnz_addrs[n_bnz++] = spl_emit_bnz(ctx);
bnz_addrs[n_bnz++] = spl_emit_bnz(ctx); /* fallthrough to body */
continue;
}
break;
@@ -718,7 +738,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
break;
}
/* Last pattern: BZ to skip arm if no value matched */
/* Last pattern: BZ past body if no match */
if (!ctx->has_error) {
bz_addr = spl_emit_bz(ctx);
body_start = vec_size(ctx->prog.insns);
@@ -727,53 +747,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
/* --- Parse enum bindings (only for last variant) --- */
if (is_enum_match && has_parens && arm_variant) {
advance(ctx); /* ( */
skip_nl(ctx);
if (peek(ctx)->type != TOK_R_PAREN) {
spl_push_scope(ctx);
scope_pushed = 1;
if (arm_variant->data_type && arm_variant->data_type->kind == TYPE_STRUCT) {
int bi = 0;
for (;;) {
spl_tok_t *btok = advance(ctx);
char bname[256];
usize bnl = btok->len < 255 ? btok->len : 255;
memcpy(bname, btok->lexeme, bnl);
bname[bnl] = '\0';
spl_type_info_t *btype = spl_type_basic(SPL_I32);
usize field_byte_off = 4;
if ((usize)bi < vec_size(arm_variant->data_type->fields)) {
btype = vec_at(arm_variant->data_type->fields, bi).type;
field_byte_off = 4 + vec_at(arm_variant->data_type->fields, bi).offset;
}
int boffset = spl_declare_var(ctx, bname, btype, 0);
spl_emit_load_to_var(ctx, val_offset, field_byte_off, btype, boffset);
bi++;
skip_nl(ctx);
if (peek(ctx)->type == TOK_COMMA) {
advance(ctx);
skip_nl(ctx);
continue;
}
break;
}
} else if (arm_variant->data_type) {
spl_tok_t *btok = advance(ctx);
char bname[256];
usize bnl = btok->len < 255 ? btok->len : 255;
memcpy(bname, btok->lexeme, bnl);
bname[bnl] = '\0';
spl_type_info_t *btype = arm_variant->data_type;
int boffset = spl_declare_var(ctx, bname, btype, 0);
spl_emit_load_to_var(ctx, val_offset, 4, btype, boffset);
}
}
expect(ctx, TOK_R_PAREN);
parse_match_enum_bindings(ctx, arm_variant, val_offset, &scope_pushed);
}
skip_nl(ctx);
@@ -786,10 +760,10 @@ static void parse_match_stmt(spl_comp_t *ctx) {
}
skip_nl(ctx);
/* Parse arm body statement */
/* Parse arm body (reuses stmt infrastructure) */
spl_parse_stmt(ctx);
/* Pop scope if we pushed one */
/* Pop scope if bindings were declared */
if (scope_pushed) {
spl_emit_defer_epilogue(ctx, ctx->scope_depth);
spl_pop_scope(ctx);
@@ -803,7 +777,7 @@ static void parse_match_stmt(spl_comp_t *ctx) {
if (bz_addr)
spl_patch_to_here(ctx, bz_addr);
/* Patch BNZs to body start (fallthrough values matched) */
/* Patch BNZ fallthroughs to body start */
for (int i = 0; i < n_bnz; i++) {
spl_val_t offset = body_start - bnz_addrs[i] - 1;
spl_patch(ctx, bnz_addrs[i], offset);