Phase 5: scripting language

#pragma once

/* Shared tokenizer used by both the scripting language (kernel/lang/script)
 * and the tiny compiler (kernel/lang/compiler). Keywords are not baked in
 * here - callers recognize keywords by comparing TOK_IDENT text, since the
 * two languages don't share a keyword set. */

#include <stdint.h>

typedef enum {
    TOK_EOF,
    TOK_IDENT,
    TOK_NUMBER,
    TOK_STRING,
    TOK_LPAREN,
    TOK_RPAREN,
    TOK_LBRACE,
    TOK_RBRACE,
    TOK_COMMA,
    TOK_SEMI,
    TOK_PLUS,
    TOK_MINUS,
    TOK_STAR,
    TOK_SLASH,
    TOK_PERCENT,
    TOK_ASSIGN,
    TOK_EQ,
    TOK_NEQ,
    TOK_LT,
    TOK_LE,
    TOK_GT,
    TOK_GE,
    TOK_NOT,
    TOK_AND,
    TOK_OR,
    TOK_ERROR,
} token_type_t;

#define TOKEN_TEXT_MAX 32

typedef struct {
    token_type_t type;
    char text[TOKEN_TEXT_MAX]; /* TOK_IDENT */
    int32_t number;             /* TOK_NUMBER */
    char *string;                /* TOK_STRING - kmalloc'd, owned by the AST node it ends up in */
} token_t;

typedef struct {
    const char *src;
    int pos;
} lexer_t;

void lexer_init(lexer_t *lx, const char *src);
token_t lexer_next(lexer_t *lx);

#include "lexer.h"

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

static int is_alpha(char c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
}

static int is_digit(char c) {
    return c >= '0' && c <= '9';
}

static int is_alnum(char c) {
    return is_alpha(c) || is_digit(c);
}

static void skip_ws_and_comments(lexer_t *lx) {
    for (;;) {
        char c = lx->src[lx->pos];
        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
            lx->pos++;
        } else if (c == '#') {
            while (lx->src[lx->pos] && lx->src[lx->pos] != '\n') {
                lx->pos++;
            }
        } else {
            break;
        }
    }
}

void lexer_init(lexer_t *lx, const char *src) {
    lx->src = src;
    lx->pos = 0;
}

token_t lexer_next(lexer_t *lx) {
    token_t tok;
    tok.string = NULL;
    tok.number = 0;
    tok.text[0] = '\0';

    skip_ws_and_comments(lx);
    char c = lx->src[lx->pos];

    if (c == '\0') {
        tok.type = TOK_EOF;
        return tok;
    }

    if (is_alpha(c)) {
        int start = lx->pos;
        while (is_alnum(lx->src[lx->pos])) {
            lx->pos++;
        }
        int len = lx->pos - start;
        if (len >= TOKEN_TEXT_MAX) {
            len = TOKEN_TEXT_MAX - 1;
        }
        memcpy(tok.text, lx->src + start, (size_t)len);
        tok.text[len] = '\0';
        tok.type = TOK_IDENT;
        return tok;
    }

    if (is_digit(c)) {
        int32_t val = 0;
        while (is_digit(lx->src[lx->pos])) {
            val = val * 10 + (lx->src[lx->pos] - '0');
            lx->pos++;
        }
        tok.number = val;
        tok.type = TOK_NUMBER;
        return tok;
    }

    if (c == '"') {
        lx->pos++;
        int start = lx->pos;
        while (lx->src[lx->pos] && lx->src[lx->pos] != '"') {
            lx->pos++;
        }
        int len = lx->pos - start;
        char *s = kmalloc((size_t)len + 1);
        memcpy(s, lx->src + start, (size_t)len);
        s[len] = '\0';
        if (lx->src[lx->pos] == '"') {
            lx->pos++;
        }
        tok.string = s;
        tok.type = TOK_STRING;
        return tok;
    }

    lx->pos++;
    switch (c) {
        case '(': tok.type = TOK_LPAREN; break;
        case ')': tok.type = TOK_RPAREN; break;
        case '{': tok.type = TOK_LBRACE; break;
        case '}': tok.type = TOK_RBRACE; break;
        case ',': tok.type = TOK_COMMA; break;
        case ';': tok.type = TOK_SEMI; break;
        case '+': tok.type = TOK_PLUS; break;
        case '-': tok.type = TOK_MINUS; break;
        case '*': tok.type = TOK_STAR; break;
        case '/': tok.type = TOK_SLASH; break;
        case '%': tok.type = TOK_PERCENT; break;
        case '=':
            if (lx->src[lx->pos] == '=') { lx->pos++; tok.type = TOK_EQ; }
            else { tok.type = TOK_ASSIGN; }
            break;
        case '!':
            if (lx->src[lx->pos] == '=') { lx->pos++; tok.type = TOK_NEQ; }
            else { tok.type = TOK_NOT; }
            break;
        case '<':
            if (lx->src[lx->pos] == '=') { lx->pos++; tok.type = TOK_LE; }
            else { tok.type = TOK_LT; }
            break;
        case '>':
            if (lx->src[lx->pos] == '=') { lx->pos++; tok.type = TOK_GE; }
            else { tok.type = TOK_GT; }
            break;
        case '&':
            if (lx->src[lx->pos] == '&') { lx->pos++; tok.type = TOK_AND; }
            else { tok.type = TOK_ERROR; }
            break;
        case '|':
            if (lx->src[lx->pos] == '|') { lx->pos++; tok.type = TOK_OR; }
            else { tok.type = TOK_ERROR; }
            break;
        default:
            tok.type = TOK_ERROR;
            break;
    }
    return tok;
}

#pragma once

#include "../lexer.h"

typedef enum {
    AST_NUM,
    AST_STR,
    AST_VAR,
    AST_ASSIGN,
    AST_BINOP,
    AST_UNOP,
    AST_CALL,
    AST_IF,
    AST_WHILE,
    AST_FUNC_DEF,
    AST_RETURN,
    AST_BLOCK,
    AST_EXPR_STMT,
} ast_kind_t;

typedef struct ast_node ast_node_t;

/* One generic node shape for the whole tree, in the tradition of tiny
 * interpreters: `a`/`b`/`c` are kind-specific children, `list` is a
 * singly-linked chain (block statements, call args, function params),
 * and `next` links siblings within such a chain. See eval.c/parser.c for
 * which fields each AST_* kind actually uses. */
struct ast_node {
    ast_kind_t kind;
    token_type_t op; /* AST_BINOP / AST_UNOP */

    int32_t num;  /* AST_NUM */
    char *str;     /* AST_STR - shares the token's kmalloc'd buffer */
    char name[TOKEN_TEXT_MAX]; /* AST_VAR / AST_ASSIGN / AST_CALL / AST_FUNC_DEF */

    ast_node_t *a, *b, *c;
    ast_node_t *list;
    ast_node_t *next;
};

ast_node_t *ast_new(ast_kind_t kind);

#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(parser_t *p) {
    p->cur = lexer_next(&p->lexer);
}

void parser_init(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(parser_t *p, const char *msg) {
    if (!p->error) {
        p->error = 1;
        copy_name(p->error_msg, msg); /* error_msg is 64 bytes, plenty for our short messages */
    }
}

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

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

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

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

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

static ast_node_t *parse_block(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(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)) {
        ast_node_t *n = ast_new(AST_STR);
        n->str = p->cur.string;
        advance(p);
        return n;
    }
    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); /* avoid getting stuck */
    return ast_new(AST_NUM);
}

static ast_node_t *parse_unary(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(parser_t *p, ast_node_t *(*next)(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(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(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(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(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(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(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(parser_t *p) {
    if (check(p, TOK_IDENT)) {
        parser_t save = *p; /* plain-old-data struct, safe to snapshot/restore */
        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); /* right-associative */
            ast_node_t *n = ast_new(AST_ASSIGN);
            copy_name(n->name, name);
            n->a = value;
            return n;
        }
        *p = save; /* not an assignment - rewind and parse as a normal expression */
    }
    return parse_or(p);
}

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

static ast_node_t *parse_statement(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 *parse_program(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 "eval.h"

#include "../../console.h"
#include "../../fs/tinyfs.h"
#include "../../memory.h"
#include "../../serial.h"
#include "../../string.h"
#include "ast.h"
#include "parser.h"

typedef enum { VAL_INT, VAL_STR } value_type_t;

typedef struct {
    value_type_t type;
    union {
        int32_t i;
        char *s;
    } as;
} value_t;

#define MAX_VARS 32

typedef struct {
    char names[MAX_VARS][TOKEN_TEXT_MAX];
    value_t values[MAX_VARS];
    int count;
} env_t;

#define MAX_FUNCS 16

typedef struct {
    char name[TOKEN_TEXT_MAX];
    ast_node_t *def;
} func_entry_t;

typedef struct {
    func_entry_t funcs[MAX_FUNCS];
    int func_count;
} interp_t;

typedef enum { EXEC_NORMAL, EXEC_RETURN } exec_signal_t;

typedef struct {
    exec_signal_t signal;
    value_t return_value;
} exec_result_t;

static const value_t VAL_ZERO = { VAL_INT, { .i = 0 } };

static int env_find(env_t *env, const char *name) {
    for (int i = 0; i < env->count; i++) {
        if (strcmp(env->names[i], name) == 0) {
            return i;
        }
    }
    return -1;
}

static value_t env_get(env_t *env, const char *name) {
    int i = env_find(env, name);
    return i < 0 ? VAL_ZERO : env->values[i];
}

static void env_set(env_t *env, const char *name, value_t v) {
    int i = env_find(env, name);
    if (i >= 0) {
        env->values[i] = v;
        return;
    }
    if (env->count < MAX_VARS) {
        int n = 0;
        while (name[n] && n < TOKEN_TEXT_MAX - 1) {
            env->names[env->count][n] = name[n];
            n++;
        }
        env->names[env->count][n] = '\0';
        env->values[env->count] = v;
        env->count++;
    }
    /* else: variable table full - silently dropped, tiny scope */
}

static int to_int(value_t v) {
    if (v.type == VAL_INT) {
        return v.as.i;
    }
    return (v.as.s && v.as.s[0]) ? 1 : 0;
}

static char *str_concat(const char *a, const char *b) {
    size_t la = strlen(a);
    size_t lb = strlen(b);
    char *r = kmalloc(la + lb + 1);
    memcpy(r, a, la);
    memcpy(r + la, b, lb);
    r[la + lb] = '\0';
    return r;
}

static void print_value(value_t v) {
    if (v.type == VAL_STR) {
        console_write(v.as.s);
        serial_write(v.as.s);
    } else {
        char buf[16];
        itoa(v.as.i, buf, 10);
        console_write(buf);
        serial_write(buf);
    }
}

static value_t eval_binop(token_type_t op, value_t l, value_t r) {
    if (op == TOK_PLUS && (l.type == VAL_STR || r.type == VAL_STR)) {
        char lb[16], rb[16];
        const char *ls = (l.type == VAL_STR) ? l.as.s : itoa(l.as.i, lb, 10);
        const char *rs = (r.type == VAL_STR) ? r.as.s : itoa(r.as.i, rb, 10);
        return (value_t){ VAL_STR, { .s = str_concat(ls, rs) } };
    }
    if (op == TOK_EQ || op == TOK_NEQ) {
        int eq;
        if (l.type == VAL_STR && r.type == VAL_STR) {
            eq = strcmp(l.as.s, r.as.s) == 0;
        } else if (l.type == VAL_INT && r.type == VAL_INT) {
            eq = l.as.i == r.as.i;
        } else {
            eq = 0;
        }
        return (value_t){ VAL_INT, { .i = (op == TOK_EQ) ? eq : !eq } };
    }

    int li = to_int(l);
    int ri = to_int(r);
    switch (op) {
        case TOK_MINUS:   return (value_t){ VAL_INT, { .i = li - ri } };
        case TOK_STAR:    return (value_t){ VAL_INT, { .i = li * ri } };
        case TOK_SLASH:   return (value_t){ VAL_INT, { .i = ri != 0 ? li / ri : 0 } };
        case TOK_PERCENT: return (value_t){ VAL_INT, { .i = ri != 0 ? li % ri : 0 } };
        case TOK_LT:      return (value_t){ VAL_INT, { .i = li < ri } };
        case TOK_LE:      return (value_t){ VAL_INT, { .i = li <= ri } };
        case TOK_GT:      return (value_t){ VAL_INT, { .i = li > ri } };
        case TOK_GE:      return (value_t){ VAL_INT, { .i = li >= ri } };
        default:          return VAL_ZERO;
    }
}

static ast_node_t *find_func(interp_t *interp, const char *name) {
    for (int i = 0; i < interp->func_count; i++) {
        if (strcmp(interp->funcs[i].name, name) == 0) {
            return interp->funcs[i].def;
        }
    }
    return NULL;
}

static void register_func(interp_t *interp, ast_node_t *def) {
    if (interp->func_count >= MAX_FUNCS) {
        return;
    }
    func_entry_t *e = &interp->funcs[interp->func_count++];
    int n = 0;
    while (def->name[n] && n < TOKEN_TEXT_MAX - 1) {
        e->name[n] = def->name[n];
        n++;
    }
    e->name[n] = '\0';
    e->def = def;
}

static value_t eval_expr(interp_t *interp, env_t *env, ast_node_t *node);
static exec_result_t exec_stmt(interp_t *interp, env_t *env, ast_node_t *node);

static exec_result_t exec_block(interp_t *interp, env_t *env, ast_node_t *block) {
    exec_result_t r = { EXEC_NORMAL, VAL_ZERO };
    for (ast_node_t *s = block->list; s; s = s->next) {
        r = exec_stmt(interp, env, s);
        if (r.signal == EXEC_RETURN) {
            return r;
        }
    }
    return r;
}

static value_t eval_call(interp_t *interp, env_t *env, ast_node_t *node) {
    value_t args[8];
    int argc = 0;
    for (ast_node_t *a = node->list; a && argc < 8; a = a->next) {
        args[argc++] = eval_expr(interp, env, a);
    }

    if (strcmp(node->name, "print") == 0) {
        for (int i = 0; i < argc; i++) {
            if (i > 0) {
                console_write(" ");
                serial_write(" ");
            }
            print_value(args[i]);
        }
        console_write("\n");
        serial_write("\n");
        return VAL_ZERO;
    }

    if (strcmp(node->name, "fread") == 0 && argc >= 1 && args[0].type == VAL_STR) {
        static char buf[TINYFS_MAX_FILE_SIZE + 1];
        uint32_t len = 0;
        if (tinyfs_read(args[0].as.s, buf, sizeof(buf) - 1, &len) == 0) {
            buf[len] = '\0';
            char *out = kmalloc(len + 1);
            memcpy(out, buf, len + 1);
            return (value_t){ VAL_STR, { .s = out } };
        }
        return (value_t){ VAL_STR, { .s = "" } };
    }

    if (strcmp(node->name, "fwrite") == 0 && argc >= 2 && args[0].type == VAL_STR) {
        const char *content = (args[1].type == VAL_STR) ? args[1].as.s : "";
        tinyfs_create(args[0].as.s); /* ignored if it already exists */
        int rc = tinyfs_write(args[0].as.s, content, (uint32_t)strlen(content));
        return (value_t){ VAL_INT, { .i = rc == 0 } };
    }

    if (strcmp(node->name, "flist") == 0) {
        tinyfs_dirent_t entries[TINYFS_NUM_INODES];
        int n = tinyfs_list(entries, TINYFS_NUM_INODES);
        for (int i = 0; i < n; i++) {
            console_write(entries[i].name);
            console_write("\n");
            serial_write(entries[i].name);
            serial_write("\n");
        }
        return (value_t){ VAL_INT, { .i = n } };
    }

    ast_node_t *def = find_func(interp, node->name);
    if (!def) {
        return VAL_ZERO; /* unknown function - tiny scope, no error propagation */
    }

    env_t local;
    local.count = 0;
    int i = 0;
    for (ast_node_t *pn = def->list; pn; pn = pn->next, i++) {
        env_set(&local, pn->name, i < argc ? args[i] : VAL_ZERO);
    }

    exec_result_t r = exec_block(interp, &local, def->b);
    return r.signal == EXEC_RETURN ? r.return_value : VAL_ZERO;
}

static value_t eval_expr(interp_t *interp, env_t *env, ast_node_t *node) {
    switch (node->kind) {
        case AST_NUM:
            return (value_t){ VAL_INT, { .i = node->num } };
        case AST_STR:
            return (value_t){ VAL_STR, { .s = node->str } };
        case AST_VAR:
            return env_get(env, node->name);
        case AST_ASSIGN: {
            value_t v = eval_expr(interp, env, node->a);
            env_set(env, node->name, v);
            return v;
        }
        case AST_UNOP: {
            value_t v = eval_expr(interp, env, node->a);
            if (node->op == TOK_MINUS) {
                return (value_t){ VAL_INT, { .i = -to_int(v) } };
            }
            return (value_t){ VAL_INT, { .i = !to_int(v) } };
        }
        case AST_BINOP: {
            if (node->op == TOK_AND) {
                value_t l = eval_expr(interp, env, node->a);
                if (!to_int(l)) {
                    return VAL_ZERO;
                }
                value_t r = eval_expr(interp, env, node->b);
                return (value_t){ VAL_INT, { .i = to_int(r) != 0 } };
            }
            if (node->op == TOK_OR) {
                value_t l = eval_expr(interp, env, node->a);
                if (to_int(l)) {
                    return (value_t){ VAL_INT, { .i = 1 } };
                }
                value_t r = eval_expr(interp, env, node->b);
                return (value_t){ VAL_INT, { .i = to_int(r) != 0 } };
            }
            value_t l = eval_expr(interp, env, node->a);
            value_t r = eval_expr(interp, env, node->b);
            return eval_binop(node->op, l, r);
        }
        case AST_CALL:
            return eval_call(interp, env, node);
        default:
            return VAL_ZERO;
    }
}

static exec_result_t exec_stmt(interp_t *interp, env_t *env, ast_node_t *node) {
    exec_result_t normal = { EXEC_NORMAL, VAL_ZERO };

    switch (node->kind) {
        case AST_BLOCK:
            return exec_block(interp, env, node);
        case AST_IF: {
            value_t c = eval_expr(interp, env, node->a);
            if (to_int(c)) {
                return exec_stmt(interp, env, node->b);
            }
            if (node->c) {
                return exec_stmt(interp, env, node->c);
            }
            return normal;
        }
        case AST_WHILE:
            while (to_int(eval_expr(interp, env, node->a))) {
                exec_result_t r = exec_stmt(interp, env, node->b);
                if (r.signal == EXEC_RETURN) {
                    return r;
                }
            }
            return normal;
        case AST_FUNC_DEF:
            /* top-level defs are pre-registered by script_run; a nested
             * func statement (inside a block) registers here instead */
            register_func(interp, node);
            return normal;
        case AST_RETURN: {
            exec_result_t r = { EXEC_RETURN, VAL_ZERO };
            if (node->a) {
                r.return_value = eval_expr(interp, env, node->a);
            }
            return r;
        }
        case AST_EXPR_STMT:
            eval_expr(interp, env, node->a);
            return normal;
        default:
            return normal;
    }
}

void script_run(const char *src) {
    parser_t p;
    parser_init(&p, src);
    ast_node_t *prog = parse_program(&p);

    if (p.error) {
        console_write("script: parse error: ");
        console_write(p.error_msg);
        console_write("\n");
        serial_write("script: parse error: ");
        serial_write(p.error_msg);
        serial_write("\n");
        return;
    }

    interp_t interp;
    interp.func_count = 0;
    env_t global;
    global.count = 0;

    for (ast_node_t *s = prog->list; s; s = s->next) {
        if (s->kind == AST_FUNC_DEF) {
            register_func(&interp, s);
        }
    }
    for (ast_node_t *s = prog->list; s; s = s->next) {
        if (s->kind != AST_FUNC_DEF) {
            exec_result_t r = exec_stmt(&interp, &global, s);
            if (r.signal == EXEC_RETURN) {
                break;
            }
        }
    }
}

- static void seed_file(const char *name, const char *contents) {
-     tinyfs_create(name);
-     tinyfs_write(name, contents, (uint32_t)strlen(contents));
- }
- 
- int main(int argc, char **argv) {
-     if (argc != 2) {
-         fprintf(stderr, "usage: %s <disk-image>\n", argv[0]);
-         return 1;
-     }
- 
-     disk = fopen(argv[1], "r+b");
-     if (!disk) {
-         perror("fopen");
-         return 1;
-     }
- 
-     tinyfs_init(disk_block_read, disk_block_write);
-     tinyfs_format();
- 
-     seed_file("hello.txt", "Hello, tinyfs!\n");
- 
-     fclose(disk);
-     printf("mkfs_tinyfs: formatted %s (%u data blocks available)\n",
-            argv[1], (unsigned)TINYFS_DATA_BLOCKS);
-     return 0;
- }
+ static void seed_file(const char *name, const char *contents) {
+     tinyfs_create(name);
+     tinyfs_write(name, contents, (uint32_t)strlen(contents));
+ }
+ 
+ /* Seeds a tinyfs file straight from a host file, for test fixtures
+  * (tests/*.tsh, tests/*.tc) so their source lives in one place instead of
+  * being duplicated as a C string literal here. */
+ static void seed_file_from_host(const char *host_path, const char *fs_name) {
+     FILE *f = fopen(host_path, "rb");
+     if (!f) {
+         fprintf(stderr, "mkfs_tinyfs: cannot open seed file %s\n", host_path);
+         exit(1);
+     }
+     char buf[TINYFS_MAX_FILE_SIZE];
+     size_t n = fread(buf, 1, sizeof(buf), f);
+     fclose(f);
+ 
+     tinyfs_create(fs_name);
+     tinyfs_write(fs_name, buf, (uint32_t)n);
+ }
+ 
+ int main(int argc, char **argv) {
+     if (argc < 2) {
+         fprintf(stderr, "usage: %s <disk-image> [host-path:fs-name ...]\n", argv[0]);
+         return 1;
+     }
+ 
+     disk = fopen(argv[1], "r+b");
+     if (!disk) {
+         perror("fopen");
+         return 1;
+     }
+ 
+     tinyfs_init(disk_block_read, disk_block_write);
+     tinyfs_format();
+ 
+     seed_file("hello.txt", "Hello, tinyfs!\n");
+ 
+     for (int i = 2; i < argc; i++) {
+         char spec[256];
+         size_t speclen = strlen(argv[i]);
+         if (speclen >= sizeof(spec)) {
+             fprintf(stderr, "mkfs_tinyfs: seed spec too long: %s\n", argv[i]);
+             return 1;
+         }
+         memcpy(spec, argv[i], speclen + 1);
+ 
+         char *sep = strchr(spec, ':');
+         if (!sep) {
+             fprintf(stderr, "mkfs_tinyfs: bad seed spec %s (want host-path:fs-name)\n", argv[i]);
+             return 1;
+         }
+         *sep = '\0';
+         seed_file_from_host(spec, sep + 1);
+     }
+ 
+     fclose(disk);
+     printf("mkfs_tinyfs: formatted %s (%u data blocks available)\n",
+            argv[1], (unsigned)TINYFS_DATA_BLOCKS);
+     return 0;
+ }

- load_kernel:
-     mov si, dap
-     mov ah, 0x42
-     mov dl, 0x80
-     int 0x13
-     jc disk_error
-     ret
- 
- disk_error:
-     mov si, msg_disk_err
-     call print_str16
- .hang:
-     hlt
-     jmp .hang
- 
- align 4
- dap:
-     db 0x10
-     db 0
-     dw KERNEL_SECTORS
-     dw KERNEL_LOAD_ADDR & 0xFFFF          ; offset  (0x0000)
-     dw (KERNEL_LOAD_ADDR >> 4) & 0xFFFF   ; segment (0x1000)
-     dq KERNEL_START_LBA
- 
- msg_stage2:   db "stage2 ", 0
- msg_disk_err: db "kernel disk err", 0
+ ; Reads the kernel in CHUNK_SECTORS-sized pieces rather than one single
+ ; INT13h AH=0x42 call - BIOSes (including SeaBIOS) commonly cap how many
+ ; sectors a single extended read will reliably transfer well below 512,
+ ; and silently misbehave past that rather than returning an error.
+ CHUNK_SECTORS equ 64
+ 
+ load_kernel:
+     mov word [kernel_remaining], KERNEL_SECTORS
+     mov dword [kernel_lba], KERNEL_START_LBA
+     mov word [kernel_dest_seg], (KERNEL_LOAD_ADDR >> 4)
+ 
+ .loop:
+     mov ax, [kernel_remaining]
+     cmp ax, 0
+     je .done
+     cmp ax, CHUNK_SECTORS
+     jbe .chunk_size_ok
+     mov ax, CHUNK_SECTORS
+ .chunk_size_ok:
+     ; ax = sectors to transfer this iteration
+ 
+     mov [dap_sectors], ax
+     mov si, [kernel_dest_seg]
+     mov [dap_segment], si
+     mov word [dap_offset], 0
+     mov ebx, [kernel_lba]
+     mov [dap_lba], ebx
+     mov dword [dap_lba + 4], 0
+ 
+     push ax
+     mov si, dap
+     mov ah, 0x42
+     mov dl, 0x80
+     int 0x13
+     jc disk_error
+     pop ax
+ 
+     movzx eax, ax                  ; sectors transferred, zero-extended
+     add dword [kernel_lba], eax
+     sub word [kernel_remaining], ax
+     mov cx, ax
+     shl cx, 5                       ; sectors * (512/16) = paragraphs advanced
+     add word [kernel_dest_seg], cx
+ 
+     jmp .loop
+ .done:
+     ret
+ 
+ disk_error:
+     mov si, msg_disk_err
+     call print_str16
+ .hang:
+     hlt
+     jmp .hang
+ 
+ kernel_remaining: dw 0
+ kernel_lba:       dd 0
+ kernel_dest_seg:  dw 0
+ 
+ align 4
+ dap:
+ dap_size:    db 0x10
+              db 0
+ dap_sectors: dw 0
+ dap_offset:  dw 0
+ dap_segment: dw 0
+ dap_lba:     dq 0
+ 
+ msg_stage2:   db "stage2 ", 0
+ msg_disk_err: db "kernel disk err", 0