Phase 6: compiler, bytecode VM

# tiny compiler bytecode ISA

A stack machine, similar in spirit to tinyfs: minimal, fixed-size, no
dynamic growth. Values are 32-bit signed integers only - the compiled
language (unlike the scripting language) has no string type.

## Design invariant

Every expression, once compiled, leaves **exactly one** value on the value
stack. Statement-level wrappers (`OP_POP` after an expression-statement)
and binary/unary ops (pop N, push 1) all rely on this. Assignment is an
expression too: it evaluates to the assigned value, via `<value> DUP
STORE_*` rather than a plain `STORE_*` that would leave nothing behind.

## VM state

Four fixed-size arrays, no heap allocation at run time:

- **value stack** - expression operands/results.
- **locals stack** - one contiguous region per active call frame (params
  then other locals, slot-indexed - names are resolved to slots at compile
  time, the VM has no notion of variable names).
- **call stack** - `{return_pc, locals_base}` per active call, for nested
  and recursive calls.
- **globals** - fixed array, slot-indexed, for variables assigned outside
  any function.

Functions cannot see globals or an enclosing scope - same "no closures"
rule as the scripting language's interpreter (kernel/lang/script/eval.c),
so both languages behave consistently.

## Opcodes

| op | value | operand | stack effect |
|---|---|---|---|
| `OP_HALT` | 0 | - | stops execution |
| `OP_PUSH_CONST` | 1 | i32 | push const |
| `OP_POP` | 2 | - | pop |
| `OP_DUP` | 3 | - | push top again |
| `OP_LOAD_LOCAL` | 4 | u8 slot | push locals[base+slot] |
| `OP_STORE_LOCAL` | 5 | u8 slot | pop -> locals[base+slot] |
| `OP_LOAD_GLOBAL` | 6 | u8 slot | push globals[slot] |
| `OP_STORE_GLOBAL` | 7 | u8 slot | pop -> globals[slot] |
| `OP_ADD`..`OP_OR` | 8-20 | - | pop 2, push 1 (`+ - * / % == != < <= > >= && \|\|`) |
| `OP_NEG` | 21 | - | pop 1, push 1 |
| `OP_NOT` | 22 | - | pop 1, push 1 |
| `OP_JMP` | 23 | u16 addr | `pc = addr` |
| `OP_JMP_IF_FALSE` | 24 | u16 addr | pop cond; if false, `pc = addr` |
| `OP_CALL` | 25 | u16 func index | pop `param_count` args, push new frame, jump to entry |
| `OP_RET` | 26 | - | pop return value, pop frame, push return value back |
| `OP_SYS_PRINT` | 27 | - | pop 1, print as decimal + newline, push 0 |

`OP_AND`/`OP_OR` are eager (both operands always evaluated), unlike the
scripting language's short-circuit `&&`/`||` - a deliberate simplification
for the compiled path.

Division/modulo by zero yields 0 rather than trapping, matching the
scripting language's behavior.

## File format (`.tbc`)

```
struct tbc_header {        // 12 bytes, packed
    uint32_t magic;         // 'T','B','C','1'
    uint16_t entry_pc;       // where top-level code starts, within code[]
    uint16_t global_count;
    uint16_t func_count;
    uint16_t code_size;
};

struct tbc_func {          // 4 bytes, packed, func_count of these follow the header
    uint16_t entry_addr;    // offset within code[]
    uint8_t  param_count;
    uint8_t  local_count;   // includes params, which occupy slots 0..param_count-1
};

uint8_t code[code_size];   // follows the func table
```

The whole file must fit in one tinyfs file (`TINYFS_MAX_FILE_SIZE`, 4KB).

## Source language

C-like and statically scoped: `int`-only variables (no declarations -
first assignment creates the variable, in whichever scope - global or
current function - is active), `if`/`else`, `while`, `func name(params)
{...}` with `return`, arithmetic/comparison/logical operators, and one
builtin, `print(expr)`. Parser: `kernel/lang/compiler/parser.c`, reusing
the scripting language's AST node type (`kernel/lang/script/ast.h`) since
the tree shape is identical minus string literals. Codegen:
`kernel/lang/compiler/codegen.c`. VM: `kernel/lang/vm.c`.

Shell usage: `build prog.tc prog.tbc` compiles, `exec prog.tbc` runs it.

#pragma once

/* Shared between kernel/lang/compiler/codegen.c (producer) and
 * kernel/lang/vm.c (consumer). See docs/bytecode-isa.md. */

#include <stdint.h>

#define TBC_MAGIC 0x31434254u /* "TBC1" */

typedef enum {
    OP_HALT = 0,
    OP_PUSH_CONST,
    OP_POP,
    OP_DUP,
    OP_LOAD_LOCAL,
    OP_STORE_LOCAL,
    OP_LOAD_GLOBAL,
    OP_STORE_GLOBAL,
    OP_ADD,
    OP_SUB,
    OP_MUL,
    OP_DIV,
    OP_MOD,
    OP_EQ,
    OP_NEQ,
    OP_LT,
    OP_LE,
    OP_GT,
    OP_GE,
    OP_AND,
    OP_OR,
    OP_NEG,
    OP_NOT,
    OP_JMP,
    OP_JMP_IF_FALSE,
    OP_CALL,
    OP_RET,
    OP_SYS_PRINT,
} bc_opcode_t;

typedef struct {
    uint32_t magic;
    uint16_t entry_pc;
    uint16_t global_count;
    uint16_t func_count;
    uint16_t code_size;
} __attribute__((packed)) tbc_header_t;

typedef struct {
    uint16_t entry_addr;
    uint8_t  param_count;
    uint8_t  local_count;
} __attribute__((packed)) tbc_func_t;

#define VM_FUNCS_MAX 16

#include "parser.h"

#include "../../string.h"

static void copy_name(char *dst, const char *src) {
    int i = 0;
    while (src[i] && i < TOKEN_TEXT_MAX - 1) {
        dst[i] = src[i];
        i++;
    }
    dst[i] = '\0';
}

static void advance(tc_parser_t *p) {
    p->cur = lexer_next(&p->lexer);
}

void tc_parser_init(tc_parser_t *p, const char *src) {
    lexer_init(&p->lexer, src);
    p->error = 0;
    p->error_msg[0] = '\0';
    advance(p);
}

static void parse_error(tc_parser_t *p, const char *msg) {
    if (!p->error) {
        p->error = 1;
        copy_name(p->error_msg, msg);
    }
}

static int check(tc_parser_t *p, token_type_t t) {
    return p->cur.type == t;
}

static int match(tc_parser_t *p, token_type_t t) {
    if (check(p, t)) {
        advance(p);
        return 1;
    }
    return 0;
}

static void expect(tc_parser_t *p, token_type_t t) {
    if (!match(p, t)) {
        parse_error(p, "unexpected token");
    }
}

static int is_kw(tc_parser_t *p, const char *kw) {
    return check(p, TOK_IDENT) && strcmp(p->cur.text, kw) == 0;
}

static ast_node_t *parse_expression(tc_parser_t *p);
static ast_node_t *parse_statement(tc_parser_t *p);

static ast_node_t *parse_block(tc_parser_t *p) {
    expect(p, TOK_LBRACE);
    ast_node_t *blk = ast_new(AST_BLOCK);
    ast_node_t *tail = NULL;
    while (!check(p, TOK_RBRACE) && !check(p, TOK_EOF) && !p->error) {
        ast_node_t *s = parse_statement(p);
        if (!blk->list) { blk->list = s; } else { tail->next = s; }
        tail = s;
    }
    expect(p, TOK_RBRACE);
    return blk;
}

static ast_node_t *parse_primary(tc_parser_t *p) {
    if (check(p, TOK_NUMBER)) {
        ast_node_t *n = ast_new(AST_NUM);
        n->num = p->cur.number;
        advance(p);
        return n;
    }
    if (check(p, TOK_STRING)) {
        parse_error(p, "strings are not supported in the compiled language");
        advance(p);
        return ast_new(AST_NUM);
    }
    if (check(p, TOK_IDENT)) {
        char name[TOKEN_TEXT_MAX];
        copy_name(name, p->cur.text);
        advance(p);
        if (check(p, TOK_LPAREN)) {
            advance(p);
            ast_node_t *n = ast_new(AST_CALL);
            copy_name(n->name, name);
            ast_node_t *tail = NULL;
            if (!check(p, TOK_RPAREN)) {
                for (;;) {
                    ast_node_t *arg = parse_expression(p);
                    if (!n->list) { n->list = arg; } else { tail->next = arg; }
                    tail = arg;
                    if (!match(p, TOK_COMMA)) {
                        break;
                    }
                }
            }
            expect(p, TOK_RPAREN);
            return n;
        }
        ast_node_t *n = ast_new(AST_VAR);
        copy_name(n->name, name);
        return n;
    }
    if (match(p, TOK_LPAREN)) {
        ast_node_t *n = parse_expression(p);
        expect(p, TOK_RPAREN);
        return n;
    }
    parse_error(p, "expected expression");
    advance(p);
    return ast_new(AST_NUM);
}

static ast_node_t *parse_unary(tc_parser_t *p) {
    if (check(p, TOK_MINUS) || check(p, TOK_NOT)) {
        token_type_t op = p->cur.type;
        advance(p);
        ast_node_t *n = ast_new(AST_UNOP);
        n->op = op;
        n->a = parse_unary(p);
        return n;
    }
    return parse_primary(p);
}

static ast_node_t *parse_binop_level(tc_parser_t *p, ast_node_t *(*next)(tc_parser_t *),
                                      const token_type_t *ops, int nops) {
    ast_node_t *left = next(p);
    for (;;) {
        int matched = 0;
        for (int i = 0; i < nops; i++) {
            if (check(p, ops[i])) {
                token_type_t op = p->cur.type;
                advance(p);
                ast_node_t *right = next(p);
                ast_node_t *n = ast_new(AST_BINOP);
                n->op = op;
                n->a = left;
                n->b = right;
                left = n;
                matched = 1;
                break;
            }
        }
        if (!matched) {
            return left;
        }
    }
}

static ast_node_t *parse_multiplicative(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_STAR, TOK_SLASH, TOK_PERCENT };
    return parse_binop_level(p, parse_unary, ops, 3);
}

static ast_node_t *parse_additive(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_PLUS, TOK_MINUS };
    return parse_binop_level(p, parse_multiplicative, ops, 2);
}

static ast_node_t *parse_relational(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_LT, TOK_LE, TOK_GT, TOK_GE };
    return parse_binop_level(p, parse_additive, ops, 4);
}

static ast_node_t *parse_equality(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_EQ, TOK_NEQ };
    return parse_binop_level(p, parse_relational, ops, 2);
}

static ast_node_t *parse_and(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_AND };
    return parse_binop_level(p, parse_equality, ops, 1);
}

static ast_node_t *parse_or(tc_parser_t *p) {
    static const token_type_t ops[] = { TOK_OR };
    return parse_binop_level(p, parse_and, ops, 1);
}

static ast_node_t *parse_assignment(tc_parser_t *p) {
    if (check(p, TOK_IDENT)) {
        tc_parser_t save = *p;
        char name[TOKEN_TEXT_MAX];
        copy_name(name, p->cur.text);
        advance(p);
        if (check(p, TOK_ASSIGN)) {
            advance(p);
            ast_node_t *value = parse_assignment(p);
            ast_node_t *n = ast_new(AST_ASSIGN);
            copy_name(n->name, name);
            n->a = value;
            return n;
        }
        *p = save;
    }
    return parse_or(p);
}

static ast_node_t *parse_expression(tc_parser_t *p) {
    return parse_assignment(p);
}

static ast_node_t *parse_statement(tc_parser_t *p) {
    if (check(p, TOK_LBRACE)) {
        return parse_block(p);
    }

    if (is_kw(p, "if")) {
        advance(p);
        expect(p, TOK_LPAREN);
        ast_node_t *cond = parse_expression(p);
        expect(p, TOK_RPAREN);
        ast_node_t *then_blk = parse_block(p);
        ast_node_t *else_blk = NULL;
        if (is_kw(p, "else")) {
            advance(p);
            else_blk = is_kw(p, "if") ? parse_statement(p) : parse_block(p);
        }
        ast_node_t *n = ast_new(AST_IF);
        n->a = cond;
        n->b = then_blk;
        n->c = else_blk;
        return n;
    }

    if (is_kw(p, "while")) {
        advance(p);
        expect(p, TOK_LPAREN);
        ast_node_t *cond = parse_expression(p);
        expect(p, TOK_RPAREN);
        ast_node_t *body = parse_block(p);
        ast_node_t *n = ast_new(AST_WHILE);
        n->a = cond;
        n->b = body;
        return n;
    }

    if (is_kw(p, "func")) {
        advance(p);
        char name[TOKEN_TEXT_MAX];
        if (check(p, TOK_IDENT)) {
            copy_name(name, p->cur.text);
            advance(p);
        } else {
            parse_error(p, "expected function name");
            name[0] = '\0';
        }
        expect(p, TOK_LPAREN);
        ast_node_t *params = NULL;
        ast_node_t *ptail = NULL;
        if (!check(p, TOK_RPAREN)) {
            for (;;) {
                if (check(p, TOK_IDENT)) {
                    ast_node_t *pn = ast_new(AST_VAR);
                    copy_name(pn->name, p->cur.text);
                    advance(p);
                    if (!params) { params = pn; } else { ptail->next = pn; }
                    ptail = pn;
                } else {
                    parse_error(p, "expected parameter name");
                    break;
                }
                if (!match(p, TOK_COMMA)) {
                    break;
                }
            }
        }
        expect(p, TOK_RPAREN);
        ast_node_t *body = parse_block(p);
        ast_node_t *n = ast_new(AST_FUNC_DEF);
        copy_name(n->name, name);
        n->list = params;
        n->b = body;
        return n;
    }

    if (is_kw(p, "return")) {
        advance(p);
        ast_node_t *n = ast_new(AST_RETURN);
        if (!check(p, TOK_SEMI)) {
            n->a = parse_expression(p);
        }
        expect(p, TOK_SEMI);
        return n;
    }

    ast_node_t *e = parse_expression(p);
    expect(p, TOK_SEMI);
    ast_node_t *n = ast_new(AST_EXPR_STMT);
    n->a = e;
    return n;
}

ast_node_t *tc_parse_program(tc_parser_t *p) {
    ast_node_t *prog = ast_new(AST_BLOCK);
    ast_node_t *tail = NULL;
    while (!check(p, TOK_EOF) && !p->error) {
        ast_node_t *s = parse_statement(p);
        if (!prog->list) { prog->list = s; } else { tail->next = s; }
        tail = s;
    }
    return prog;
}

#include "codegen.h"

#include "../../string.h"
#include "../bytecode.h"
#include "../lexer.h"

typedef struct {
    uint8_t *code;
    uint32_t code_cap;
    uint32_t code_len;

    char func_names[VM_FUNCS_MAX][TOKEN_TEXT_MAX];
    tbc_func_t funcs[VM_FUNCS_MAX];
    int func_count;

    char global_names[VM_GLOBALS_MAX][TOKEN_TEXT_MAX];
    int global_count;

    char local_names[VM_LOCALS_PER_FRAME_MAX][TOKEN_TEXT_MAX];
    int local_count;
    int in_function;

    int error;
    char error_msg[64];
} compiler_t;

static void copy_name(char *dst, const char *src) {
    int i = 0;
    while (src[i] && i < TOKEN_TEXT_MAX - 1) {
        dst[i] = src[i];
        i++;
    }
    dst[i] = '\0';
}

static void compile_error(compiler_t *c, const char *msg) {
    if (!c->error) {
        c->error = 1;
        copy_name(c->error_msg, msg); /* error_msg is 64 bytes, plenty for these */
    }
}

static void emit_byte(compiler_t *c, uint8_t b) {
    if (c->code_len >= c->code_cap) {
        compile_error(c, "compiled program too large");
        return;
    }
    c->code[c->code_len++] = b;
}

static void emit_op(compiler_t *c, bc_opcode_t op) {
    emit_byte(c, (uint8_t)op);
}

static void emit_u16(compiler_t *c, uint16_t v) {
    emit_byte(c, (uint8_t)(v & 0xFF));
    emit_byte(c, (uint8_t)((v >> 8) & 0xFF));
}

static void emit_i32(compiler_t *c, int32_t v) {
    uint32_t u = (uint32_t)v;
    emit_byte(c, (uint8_t)(u & 0xFF));
    emit_byte(c, (uint8_t)((u >> 8) & 0xFF));
    emit_byte(c, (uint8_t)((u >> 16) & 0xFF));
    emit_byte(c, (uint8_t)((u >> 24) & 0xFF));
}

static void patch_u16(compiler_t *c, uint32_t pos, uint16_t v) {
    c->code[pos] = (uint8_t)(v & 0xFF);
    c->code[pos + 1] = (uint8_t)((v >> 8) & 0xFF);
}

static int find_local(compiler_t *c, const char *name) {
    for (int i = 0; i < c->local_count; i++) {
        if (strcmp(c->local_names[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

static int find_or_add_local(compiler_t *c, const char *name) {
    int i = find_local(c, name);
    if (i >= 0) {
        return i;
    }
    if (c->local_count >= VM_LOCALS_PER_FRAME_MAX) {
        compile_error(c, "too many local variables in one function");
        return 0;
    }
    copy_name(c->local_names[c->local_count], name);
    return c->local_count++;
}

static int find_global(compiler_t *c, const char *name) {
    for (int i = 0; i < c->global_count; i++) {
        if (strcmp(c->global_names[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

static int find_or_add_global(compiler_t *c, const char *name) {
    int i = find_global(c, name);
    if (i >= 0) {
        return i;
    }
    if (c->global_count >= VM_GLOBALS_MAX) {
        compile_error(c, "too many global variables");
        return 0;
    }
    copy_name(c->global_names[c->global_count], name);
    return c->global_count++;
}

static int find_func_index(compiler_t *c, const char *name) {
    for (int i = 0; i < c->func_count; i++) {
        if (strcmp(c->func_names[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

static void compile_expr(compiler_t *c, ast_node_t *node);
static void compile_stmt(compiler_t *c, ast_node_t *node);

static void compile_var_load(compiler_t *c, const char *name) {
    if (c->in_function) {
        int slot = find_local(c, name);
        if (slot < 0) {
            compile_error(c, "undefined local variable");
            slot = 0;
        }
        emit_op(c, OP_LOAD_LOCAL);
        emit_byte(c, (uint8_t)slot);
    } else {
        int slot = find_global(c, name);
        if (slot < 0) {
            compile_error(c, "undefined global variable");
            slot = 0;
        }
        emit_op(c, OP_LOAD_GLOBAL);
        emit_byte(c, (uint8_t)slot);
    }
}

static void compile_var_store(compiler_t *c, const char *name) {
    if (c->in_function) {
        int slot = find_or_add_local(c, name);
        emit_op(c, OP_STORE_LOCAL);
        emit_byte(c, (uint8_t)slot);
    } else {
        int slot = find_or_add_global(c, name);
        emit_op(c, OP_STORE_GLOBAL);
        emit_byte(c, (uint8_t)slot);
    }
}

static const bc_opcode_t BINOP_TABLE[] = {
    [TOK_PLUS] = OP_ADD, [TOK_MINUS] = OP_SUB, [TOK_STAR] = OP_MUL,
    [TOK_SLASH] = OP_DIV, [TOK_PERCENT] = OP_MOD,
    [TOK_EQ] = OP_EQ, [TOK_NEQ] = OP_NEQ,
    [TOK_LT] = OP_LT, [TOK_LE] = OP_LE, [TOK_GT] = OP_GT, [TOK_GE] = OP_GE,
    [TOK_AND] = OP_AND, [TOK_OR] = OP_OR,
};

static void compile_expr(compiler_t *c, ast_node_t *node) {
    switch (node->kind) {
        case AST_NUM:
            emit_op(c, OP_PUSH_CONST);
            emit_i32(c, node->num);
            return;
        case AST_STR:
            compile_error(c, "strings are not supported in the compiled language");
            return;
        case AST_VAR:
            compile_var_load(c, node->name);
            return;
        case AST_ASSIGN:
            compile_expr(c, node->a);
            emit_op(c, OP_DUP); /* assignment evaluates to the assigned value */
            compile_var_store(c, node->name);
            return;
        case AST_UNOP:
            compile_expr(c, node->a);
            emit_op(c, node->op == TOK_MINUS ? OP_NEG : OP_NOT);
            return;
        case AST_BINOP: {
            compile_expr(c, node->a);
            compile_expr(c, node->b);
            if ((size_t)node->op >= sizeof(BINOP_TABLE) / sizeof(BINOP_TABLE[0])) {
                compile_error(c, "unsupported operator");
                return;
            }
            emit_op(c, BINOP_TABLE[node->op]);
            return;
        }
        case AST_CALL: {
            int argc = 0;
            for (ast_node_t *a = node->list; a; a = a->next) {
                compile_expr(c, a);
                argc++;
            }
            if (strcmp(node->name, "print") == 0) {
                if (argc != 1) {
                    compile_error(c, "print takes exactly one argument");
                }
                emit_op(c, OP_SYS_PRINT);
                return;
            }
            int idx = find_func_index(c, node->name);
            if (idx < 0) {
                compile_error(c, "call to unknown function");
                return;
            }
            if (argc != c->funcs[idx].param_count) {
                compile_error(c, "argument count mismatch");
                return;
            }
            if (argc > VM_MAX_CALL_ARGS) {
                compile_error(c, "too many arguments");
                return;
            }
            emit_op(c, OP_CALL);
            emit_u16(c, (uint16_t)idx);
            return;
        }
        default:
            compile_error(c, "expression expected");
            return;
    }
}

static void compile_stmt(compiler_t *c, ast_node_t *node) {
    switch (node->kind) {
        case AST_BLOCK:
            for (ast_node_t *s = node->list; s; s = s->next) {
                compile_stmt(c, s);
            }
            return;
        case AST_IF: {
            compile_expr(c, node->a);
            emit_op(c, OP_JMP_IF_FALSE);
            uint32_t else_jump = c->code_len;
            emit_u16(c, 0);

            compile_stmt(c, node->b);

            if (node->c) {
                emit_op(c, OP_JMP);
                uint32_t end_jump = c->code_len;
                emit_u16(c, 0);

                patch_u16(c, else_jump, (uint16_t)c->code_len);
                compile_stmt(c, node->c);
                patch_u16(c, end_jump, (uint16_t)c->code_len);
            } else {
                patch_u16(c, else_jump, (uint16_t)c->code_len);
            }
            return;
        }
        case AST_WHILE: {
            uint32_t loop_start = c->code_len;
            compile_expr(c, node->a);
            emit_op(c, OP_JMP_IF_FALSE);
            uint32_t exit_jump = c->code_len;
            emit_u16(c, 0);

            compile_stmt(c, node->b);
            emit_op(c, OP_JMP);
            emit_u16(c, (uint16_t)loop_start);

            patch_u16(c, exit_jump, (uint16_t)c->code_len);
            return;
        }
        case AST_RETURN:
            if (node->a) {
                compile_expr(c, node->a);
            } else {
                emit_op(c, OP_PUSH_CONST);
                emit_i32(c, 0);
            }
            emit_op(c, OP_RET);
            return;
        case AST_EXPR_STMT:
            compile_expr(c, node->a);
            emit_op(c, OP_POP);
            return;
        case AST_FUNC_DEF:
            compile_error(c, "nested functions are not supported");
            return;
        default:
            compile_error(c, "statement expected");
            return;
    }
}

static void compile_function(compiler_t *c, ast_node_t *def) {
    int idx = find_func_index(c, def->name);
    tbc_func_t *fe = &c->funcs[idx];
    fe->entry_addr = (uint16_t)c->code_len;

    c->in_function = 1;
    c->local_count = 0;

    int param_count = 0;
    for (ast_node_t *pn = def->list; pn; pn = pn->next) {
        find_or_add_local(c, pn->name);
        param_count++;
    }
    fe->param_count = (uint8_t)param_count;

    compile_stmt(c, def->b);

    /* Implicit `return 0;` if the body falls through without one. */
    emit_op(c, OP_PUSH_CONST);
    emit_i32(c, 0);
    emit_op(c, OP_RET);

    fe->local_count = (uint8_t)c->local_count;
    c->in_function = 0;
}

int codegen_compile(ast_node_t *prog, uint8_t *out_buf, uint32_t out_buf_size,
                     uint32_t *out_len, char *error_msg, uint32_t error_msg_size) {
    static uint8_t code_buf[4096];

    compiler_t c;
    memset(&c, 0, sizeof(c));
    c.code = code_buf;
    c.code_cap = sizeof(code_buf);

    for (ast_node_t *s = prog->list; s; s = s->next) {
        if (s->kind == AST_FUNC_DEF) {
            if (c.func_count >= VM_FUNCS_MAX) {
                compile_error(&c, "too many functions");
                break;
            }
            copy_name(c.func_names[c.func_count], s->name);
            c.func_count++;
        }
    }

    for (ast_node_t *s = prog->list; s && !c.error; s = s->next) {
        if (s->kind == AST_FUNC_DEF) {
            compile_function(&c, s);
        }
    }

    uint16_t entry_pc = (uint16_t)c.code_len;
    c.in_function = 0;
    for (ast_node_t *s = prog->list; s && !c.error; s = s->next) {
        if (s->kind != AST_FUNC_DEF) {
            compile_stmt(&c, s);
        }
    }
    emit_op(&c, OP_HALT);

    if (c.error) {
        copy_name(error_msg, c.error_msg);
        (void)error_msg_size;
        return -1;
    }

    tbc_header_t hdr;
    hdr.magic = TBC_MAGIC;
    hdr.entry_pc = entry_pc;
    hdr.global_count = (uint16_t)c.global_count;
    hdr.func_count = (uint16_t)c.func_count;
    hdr.code_size = (uint16_t)c.code_len;

    uint32_t total = sizeof(hdr) + (uint32_t)c.func_count * sizeof(tbc_func_t) + c.code_len;
    if (total > out_buf_size) {
        copy_name(error_msg, "compiled program too large for output buffer");
        return -1;
    }

    uint32_t off = 0;
    memcpy(out_buf + off, &hdr, sizeof(hdr));
    off += sizeof(hdr);
    for (int i = 0; i < c.func_count; i++) {
        memcpy(out_buf + off, &c.funcs[i], sizeof(tbc_func_t));
        off += sizeof(tbc_func_t);
    }
    memcpy(out_buf + off, c.code, c.code_len);
    off += c.code_len;

    *out_len = off;
    return 0;
}

#include "vm.h"

#include "../console.h"
#include "../serial.h"
#include "../string.h"
#include "bytecode.h"

typedef struct {
    uint16_t return_pc;
    uint16_t locals_base;
} vm_frame_t;

typedef struct {
    int32_t value_stack[VM_VALUE_STACK_MAX];
    int sp;

    int32_t locals[VM_LOCALS_STACK_MAX];
    int locals_top;
    int locals_base;

    vm_frame_t call_stack[VM_CALL_STACK_MAX];
    int call_depth;

    int32_t globals[VM_GLOBALS_MAX];
} vm_t;

static void report_error(const char *msg) {
    console_write("vm: error: ");
    console_write(msg);
    console_write("\n");
    serial_write("vm: error: ");
    serial_write(msg);
    serial_write("\n");
}

static void vm_push(vm_t *vm, int32_t v) {
    if (vm->sp >= VM_VALUE_STACK_MAX) {
        return; /* stack overflow - silently clamp, tiny scope */
    }
    vm->value_stack[vm->sp++] = v;
}

static int32_t vm_pop(vm_t *vm) {
    if (vm->sp <= 0) {
        return 0;
    }
    return vm->value_stack[--vm->sp];
}

void vm_run(const uint8_t *file, uint32_t len) {
    if (len < sizeof(tbc_header_t)) {
        report_error("truncated .tbc file");
        return;
    }

    tbc_header_t hdr;
    memcpy(&hdr, file, sizeof(hdr));
    if (hdr.magic != TBC_MAGIC) {
        report_error("bad .tbc magic");
        return;
    }
    if (hdr.func_count > VM_FUNCS_MAX) {
        report_error("too many functions for this VM");
        return;
    }

    uint32_t off = sizeof(hdr);
    tbc_func_t funcs[VM_FUNCS_MAX];
    for (int i = 0; i < hdr.func_count; i++) {
        if (off + sizeof(tbc_func_t) > len) {
            report_error("truncated .tbc function table");
            return;
        }
        memcpy(&funcs[i], file + off, sizeof(tbc_func_t));
        off += sizeof(tbc_func_t);
    }

    if (off + hdr.code_size > len) {
        report_error("truncated .tbc code section");
        return;
    }
    const uint8_t *code = file + off;
    uint32_t code_size = hdr.code_size;

    static vm_t vm;
    memset(&vm, 0, sizeof(vm));

    uint32_t pc = hdr.entry_pc;

    for (;;) {
        if (pc >= code_size) {
            report_error("program counter ran off the end of code");
            return;
        }
        uint8_t op = code[pc++];

        switch ((bc_opcode_t)op) {
            case OP_HALT:
                return;

            case OP_PUSH_CONST: {
                int32_t v;
                memcpy(&v, code + pc, sizeof(v));
                pc += sizeof(v);
                vm_push(&vm, v);
                break;
            }
            case OP_POP:
                vm_pop(&vm);
                break;
            case OP_DUP: {
                int32_t v = vm.sp > 0 ? vm.value_stack[vm.sp - 1] : 0;
                vm_push(&vm, v);
                break;
            }
            case OP_LOAD_LOCAL: {
                uint8_t slot = code[pc++];
                vm_push(&vm, vm.locals[vm.locals_base + slot]);
                break;
            }
            case OP_STORE_LOCAL: {
                uint8_t slot = code[pc++];
                vm.locals[vm.locals_base + slot] = vm.sp > 0 ? vm.value_stack[vm.sp - 1] : 0;
                vm_pop(&vm);
                break;
            }
            case OP_LOAD_GLOBAL: {
                uint8_t slot = code[pc++];
                vm_push(&vm, vm.globals[slot]);
                break;
            }
            case OP_STORE_GLOBAL: {
                uint8_t slot = code[pc++];
                vm.globals[slot] = vm.sp > 0 ? vm.value_stack[vm.sp - 1] : 0;
                vm_pop(&vm);
                break;
            }

            case OP_ADD: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a + b); break; }
            case OP_SUB: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a - b); break; }
            case OP_MUL: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a * b); break; }
            case OP_DIV: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, b != 0 ? a / b : 0); break; }
            case OP_MOD: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, b != 0 ? a % b : 0); break; }
            case OP_EQ:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a == b); break; }
            case OP_NEQ: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a != b); break; }
            case OP_LT:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a < b); break; }
            case OP_LE:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a <= b); break; }
            case OP_GT:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a > b); break; }
            case OP_GE:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, a >= b); break; }
            case OP_AND: { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, (a != 0) && (b != 0)); break; }
            case OP_OR:  { int32_t b = vm_pop(&vm), a = vm_pop(&vm); vm_push(&vm, (a != 0) || (b != 0)); break; }
            case OP_NEG: { int32_t a = vm_pop(&vm); vm_push(&vm, -a); break; }
            case OP_NOT: { int32_t a = vm_pop(&vm); vm_push(&vm, !a); break; }

            case OP_JMP: {
                uint16_t addr;
                memcpy(&addr, code + pc, sizeof(addr));
                pc = addr;
                break;
            }
            case OP_JMP_IF_FALSE: {
                uint16_t addr;
                memcpy(&addr, code + pc, sizeof(addr));
                pc += sizeof(addr);
                int32_t cond = vm_pop(&vm);
                if (!cond) {
                    pc = addr;
                }
                break;
            }

            case OP_CALL: {
                uint16_t func_idx;
                memcpy(&func_idx, code + pc, sizeof(func_idx));
                pc += sizeof(func_idx);

                if (func_idx >= hdr.func_count) {
                    report_error("call to invalid function index");
                    return;
                }
                tbc_func_t *fe = &funcs[func_idx];

                int32_t args[VM_MAX_CALL_ARGS];
                int argc = fe->param_count;
                for (int i = argc - 1; i >= 0; i--) {
                    args[i] = vm_pop(&vm);
                }

                if (vm.call_depth >= VM_CALL_STACK_MAX) {
                    report_error("call stack overflow");
                    return;
                }
                vm.call_stack[vm.call_depth].return_pc = (uint16_t)pc;
                vm.call_stack[vm.call_depth].locals_base = (uint16_t)vm.locals_base;
                vm.call_depth++;

                if (vm.locals_top + fe->local_count > VM_LOCALS_STACK_MAX) {
                    report_error("locals stack overflow");
                    return;
                }
                int new_base = vm.locals_top;
                for (int i = 0; i < fe->local_count; i++) {
                    vm.locals[new_base + i] = (i < argc) ? args[i] : 0;
                }
                vm.locals_base = new_base;
                vm.locals_top = new_base + fe->local_count;

                pc = fe->entry_addr;
                break;
            }
            case OP_RET: {
                int32_t retval = vm_pop(&vm);
                if (vm.call_depth <= 0) {
                    report_error("return with no active call frame");
                    return;
                }
                vm.call_depth--;
                vm.locals_top = vm.locals_base;
                pc = vm.call_stack[vm.call_depth].return_pc;
                vm.locals_base = vm.call_stack[vm.call_depth].locals_base;
                vm_push(&vm, retval);
                break;
            }

            case OP_SYS_PRINT: {
                int32_t v = vm_pop(&vm);
                char buf[16];
                itoa(v, buf, 10);
                console_write(buf);
                console_write("\n");
                serial_write(buf);
                serial_write("\n");
                vm_push(&vm, 0);
                break;
            }

            default:
                report_error("invalid opcode");
                return;
        }
    }
}

- static void cmd_rm(const char *name) {
+ static void cmd_build(const char *src_name, const char *out_name) {
+     static char src[TINYFS_MAX_FILE_SIZE + 1];
+     uint32_t src_len = 0;
+     if (tinyfs_read(src_name, src, sizeof(src) - 1, &src_len) != 0) {
+         print_line("build: no such file");
+         return;
+     }
+     src[src_len] = '\0';
+ 
+     tc_parser_t p;
+     tc_parser_init(&p, src);
+     ast_node_t *prog = tc_parse_program(&p);
+     if (p.error) {
+         console_write("build: parse error: ");
+         console_write(p.error_msg);
+         console_write("\n");
+         serial_write("build: parse error: ");
+         serial_write(p.error_msg);
+         serial_write("\n");
+         return;
+     }
+ 
+     static uint8_t out_buf[TINYFS_MAX_FILE_SIZE];
+     uint32_t out_len = 0;
+     char err[64];
+     if (codegen_compile(prog, out_buf, sizeof(out_buf), &out_len, err, sizeof(err)) != 0) {
+         console_write("build: compile error: ");
+         console_write(err);
+         console_write("\n");
+         serial_write("build: compile error: ");
+         serial_write(err);
+         serial_write("\n");
+         return;
+     }
+ 
+     tinyfs_create(out_name);
+     if (tinyfs_write(out_name, out_buf, out_len) != 0) {
+         print_line("build: failed to write output file");
+         return;
+     }
+     print_line("build: ok");
+ }
+ 
+ static void cmd_exec(const char *name) {
+     static uint8_t buf[TINYFS_MAX_FILE_SIZE];
+     uint32_t len = 0;
+     if (tinyfs_read(name, buf, sizeof(buf), &len) != 0) {
+         print_line("exec: no such file");
+         return;
+     }
+     vm_run(buf, len);
+ }
+ 
+ static void cmd_rm(const char *name) {

-         } else if (strcmp(cmd, "write") == 0) {
-             char name[TINYFS_NAME_MAX];
-             if (next_word(&p, name, sizeof(name)) == 0) {
-                 print_line("usage: write <file> <text>");
-             } else {
-                 skip_spaces(&p);
-                 cmd_write(name, p);
-             }
-         } else {
+         } else if (strcmp(cmd, "write") == 0) {
+             char name[TINYFS_NAME_MAX];
+             if (next_word(&p, name, sizeof(name)) == 0) {
+                 print_line("usage: write <file> <text>");
+             } else {
+                 skip_spaces(&p);
+                 cmd_write(name, p);
+             }
+         } else if (strcmp(cmd, "build") == 0) {
+             char src_name[TINYFS_NAME_MAX];
+             char out_name[TINYFS_NAME_MAX];
+             if (next_word(&p, src_name, sizeof(src_name)) == 0 ||
+                 next_word(&p, out_name, sizeof(out_name)) == 0) {
+                 print_line("usage: build <src> <out>");
+             } else {
+                 cmd_build(src_name, out_name);
+             }
+         } else if (strcmp(cmd, "exec") == 0) {
+             char name[TINYFS_NAME_MAX];
+             if (next_word(&p, name, sizeof(name)) == 0) {
+                 print_line("usage: exec <file>");
+             } else {
+                 cmd_exec(name);
+             }
+         } else {