Implement a stack-based bytecode virtual machine with an assembler in C11 in this direc…

claude-codeclaude-sonnet-5 · 45 steps · 10m 00s · 9 filessession 38d9918d-816@patrick-toulme

Implement a stack-based bytecode virtual machine with an assembler in C11 in this directory. Files: vm.c, vm.h (the VM: operand stack, call stack, ops PUSH, POP, DUP, SWAP, ADD, SUB, MUL, DIV, MOD, NEG, EQ, LT, GT, JMP, JZ, JNZ, CALL, RET, LOAD, STORE for 16 locals per frame, PRINT, HALT; robust error handling for stack under/overflow, division by zero, bad opcodes, out-of-range jumps), asm.c (a two-pass assembler from mnemonic text with labels and comments to bytecode), examples/ (fib.vasm computing fib(20) recursively, fact.vasm computing 10! iteratively, primes.vasm printing primes below 50), tests.c (runs each example through assembler+VM and asserts exact output; plus negative tests for each error path), Makefile (clang -std=c11 -Wall -Wextra -fsanitize=address). Build with make, run the tests under ASan, and fix failures until everything passes clean.

same matchclaude-code · 45 steps codex · 86 steps opencode · 46 steps pi · 59 steps antigravity · 28 steps

compare in arena

step 15 / 45

asm.cchange 1/1

#include "asm.h"
#include "vm.h"
 
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef enum { OPERAND_NONE, OPERAND_IMM64, OPERAND_ADDR, OPERAND_LOCAL } OperandKind;
 
typedef struct {
    const char *name;
    uint8_t opcode;
    OperandKind operand;
} InstrDef;
 
static const InstrDef INSTR_TABLE[] = {
    {"PUSH", OP_PUSH, OPERAND_IMM64},
    {"POP", OP_POP, OPERAND_NONE},
    {"DUP", OP_DUP, OPERAND_NONE},
    {"SWAP", OP_SWAP, OPERAND_NONE},
    {"ADD", OP_ADD, OPERAND_NONE},
    {"SUB", OP_SUB, OPERAND_NONE},
    {"MUL", OP_MUL, OPERAND_NONE},
    {"DIV", OP_DIV, OPERAND_NONE},
    {"MOD", OP_MOD, OPERAND_NONE},
    {"NEG", OP_NEG, OPERAND_NONE},
    {"EQ", OP_EQ, OPERAND_NONE},
    {"LT", OP_LT, OPERAND_NONE},
    {"GT", OP_GT, OPERAND_NONE},
    {"JMP", OP_JMP, OPERAND_ADDR},
    {"JZ", OP_JZ, OPERAND_ADDR},
    {"JNZ", OP_JNZ, OPERAND_ADDR},
    {"CALL", OP_CALL, OPERAND_ADDR},
    {"RET", OP_RET, OPERAND_NONE},
    {"LOAD", OP_LOAD, OPERAND_LOCAL},
    {"STORE", OP_STORE, OPERAND_LOCAL},
    {"PRINT", OP_PRINT, OPERAND_NONE},
    {"HALT", OP_HALT, OPERAND_NONE},
};
#define INSTR_TABLE_LEN (sizeof(INSTR_TABLE) / sizeof(INSTR_TABLE[0]))
 
typedef struct {
    const InstrDef *instr; /* NULL if this line only defines a label */
    char *operand;          /* owned; NULL if instr has no operand */
    int line_no;
    size_t address;
    size_t size;
} Statement;
 
typedef struct {
    char *name; /* owned */
    size_t address;
} LabelEntry;
 
static char *xstrdup(const char *s) {
    size_t n = strlen(s) + 1;
    char *p = malloc(n);
    if (p) memcpy(p, s, n);
    return p;
}
 
static char *trim(char *s) {
    while (*s != '\0' && isspace((unsigned char)*s)) s++;
    if (*s == '\0') return s;
    char *end = s + strlen(s) - 1;
    while (end > s && isspace((unsigned char)*end)) {
        *end = '\0';
        end--;
    }
    return s;
}
 
static int ieq(const char *a, const char *b) {
    while (*a != '\0' && *b != '\0') {
        if (tolower((unsigned char)*a) != tolower((unsigned char)*b)) return 0;
        a++;
        b++;
    }
    return *a == '\0' && *b == '\0';
}
 
static int is_valid_label_name(const char *s) {
    if (s[0] == '\0') return 0;
    if (!isalpha((unsigned char)s[0]) && s[0] != '_') return 0;
    for (const char *p = s + 1; *p != '\0'; p++) {
        if (!isalnum((unsigned char)*p) && *p != '_') return 0;
    }
    return 1;
}
 
static const InstrDef *find_instr(const char *name) {
    for (size_t i = 0; i < INSTR_TABLE_LEN; i++) {
        if (ieq(name, INSTR_TABLE[i].name)) return &INSTR_TABLE[i];
    }
    return NULL;
}
 
static LabelEntry *find_label(LabelEntry *labels, size_t count, const char *name) {
    for (size_t i = 0; i < count; i++) {
        if (strcmp(labels[i].name, name) == 0) return &labels[i];
    }
    return NULL;
}
 
static void set_err(AsmError *err, AsmStatus status, int line, const char *fmt, ...) {
    err->status = status;
    err->line = line;
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(err->message, sizeof(err->message), fmt, ap);
    va_end(ap);
}
 
static void free_statements(Statement *stmts, size_t count) {
    for (size_t i = 0; i < count; i++) free(stmts[i].operand);
    free(stmts);
}
 
static void free_labels(LabelEntry *labels, size_t count) {
    for (size_t i = 0; i < count; i++) free(labels[i].name);
    free(labels);
}
 
AsmStatus asm_assemble(const char *source, uint8_t **out_code, size_t *out_size, AsmError *err) {
    AsmError local_err;
    if (err == NULL) err = &local_err;
    memset(err, 0, sizeof(*err));
    err->status = ASM_OK;
 
    *out_code = NULL;
    *out_size = 0;
 
    char *buf = xstrdup(source);
    if (buf == NULL) {
        set_err(err, ASM_ERR_OUT_OF_MEMORY, 0, "out of memory");
        return err->status;
    }
 
    Statement *stmts = NULL;
    size_t stmt_count = 0, stmt_cap = 0;
    LabelEntry *labels = NULL;
    size_t label_count = 0, label_cap = 0;
    size_t offset = 0;
    int line_no = 0;
    AsmStatus rc = ASM_OK;
 
    char *cursor = buf;
    while (*cursor != '\0') {
        line_no++;
        char *nl = strchr(cursor, '\n');
        if (nl != NULL) *nl = '\0';
        char *line = cursor;
        cursor = (nl != NULL) ? nl + 1 : cursor + strlen(cursor);
 
        size_t len = strlen(line);
        if (len > 0 && line[len - 1] == '\r') line[len - 1] = '\0';
 
        for (char *p = line; *p != '\0'; p++) {
            if (*p == ';' || *p == '#') {
                *p = '\0';
                break;
            }
        }
 
        char *trimmed = trim(line);
        if (*trimmed == '\0') continue;
 
        char *label_name = NULL;
        char *rest = trimmed;
        char *colon = strchr(trimmed, ':');
        if (colon != NULL) {
            *colon = '\0';
            char *lbl = trim(trimmed);
            if (*lbl == '\0') {
                rc = ASM_ERR_EMPTY_LABEL;
                set_err(err, rc, line_no, "empty label name");
                goto fail;
            }
            if (!is_valid_label_name(lbl)) {
                rc = ASM_ERR_BAD_LABEL_NAME;
                set_err(err, rc, line_no, "invalid label name '%s'", lbl);
                goto fail;
            }
            label_name = lbl;
            rest = trim(colon + 1);
        }
 
        const InstrDef *instr = NULL;
        char *operand = NULL;
        if (*rest != '\0') {
            char *space = rest;
            while (*space != '\0' && !isspace((unsigned char)*space)) space++;
            size_t mnlen = (size_t)(space - rest);
            char mnemonic_buf[32];
            if (mnlen == 0 || mnlen >= sizeof(mnemonic_buf)) {
                rc = ASM_ERR_UNKNOWN_MNEMONIC;
                set_err(err, rc, line_no, "invalid mnemonic");
                goto fail;
            }
            memcpy(mnemonic_buf, rest, mnlen);
            mnemonic_buf[mnlen] = '\0';
 
            instr = find_instr(mnemonic_buf);
            if (instr == NULL) {
                rc = ASM_ERR_UNKNOWN_MNEMONIC;
                set_err(err, rc, line_no, "unknown mnemonic '%s'", mnemonic_buf);
                goto fail;
            }
 
            char *operand_part = trim(space);
            if (instr->operand == OPERAND_NONE) {
                if (*operand_part != '\0') {
                    rc = ASM_ERR_UNEXPECTED_OPERAND;
                    set_err(err, rc, line_no, "%s takes no operand", instr->name);
                    goto fail;
                }
            } else {
                if (*operand_part == '\0') {
                    rc = ASM_ERR_MISSING_OPERAND;
                    set_err(err, rc, line_no, "%s requires an operand", instr->name);
                    goto fail;
                }
                operand = xstrdup(operand_part);
                if (operand == NULL) {
                    rc = ASM_ERR_OUT_OF_MEMORY;
                    set_err(err, rc, line_no, "out of memory");
                    goto fail;
                }
            }
        }
 
        size_t size = 0;
        if (instr != NULL) {
            switch (instr->operand) {
            case OPERAND_NONE: size = 1; break;
            case OPERAND_IMM64: size = 9; break;
            case OPERAND_ADDR: size = 5; break;
            case OPERAND_LOCAL: size = 2; break;
            }
        }
 
        if (label_name != NULL) {
            if (find_label(labels, label_count, label_name) != NULL) {
                rc = ASM_ERR_DUPLICATE_LABEL;
                set_err(err, rc, line_no, "duplicate label '%s'", label_name);
                free(operand);
                goto fail;
            }
            if (label_count == label_cap) {
                size_t new_cap = label_cap == 0 ? 8 : label_cap * 2;
                LabelEntry *nl = realloc(labels, new_cap * sizeof(LabelEntry));
                if (nl == NULL) {
                    rc = ASM_ERR_OUT_OF_MEMORY;
                    set_err(err, rc, line_no, "out of memory");
                    free(operand);
                    goto fail;
                }
                labels = nl;
                label_cap = new_cap;
            }
            labels[label_count].name = xstrdup(label_name);
            labels[label_count].address = offset;
            label_count++;
        }
 
        if (instr != NULL) {
            if (stmt_count == stmt_cap) {
                size_t new_cap = stmt_cap == 0 ? 16 : stmt_cap * 2;
                Statement *ns = realloc(stmts, new_cap * sizeof(Statement));
                if (ns == NULL) {
                    rc = ASM_ERR_OUT_OF_MEMORY;
                    set_err(err, rc, line_no, "out of memory");
                    free(operand);
                    goto fail;
                }
                stmts = ns;
                stmt_cap = new_cap;
            }
            stmts[stmt_count].instr = instr;
            stmts[stmt_count].operand = operand;
            stmts[stmt_count].line_no = line_no;
            stmts[stmt_count].address = offset;
            stmts[stmt_count].size = size;
            stmt_count++;
            offset += size;
        }
    }
 
    /* Pass 2: code generation, resolving label references from pass 1's table. */
    {
        uint8_t *code = NULL;
        if (offset > 0) {
            code = malloc(offset);
            if (code == NULL) {
                rc = ASM_ERR_OUT_OF_MEMORY;
                set_err(err, rc, 0, "out of memory");
                goto fail;
            }
        }
 
        for (size_t i = 0; i < stmt_count; i++) {
            Statement *s = &stmts[i];
            code[s->address] = s->instr->opcode;
            switch (s->instr->operand) {
            case OPERAND_NONE:
                break;
 
            case OPERAND_IMM64: {
                char *endptr = NULL;
                errno = 0;
                long long v = strtoll(s->operand, &endptr, 0);
                if (endptr == s->operand || *endptr != '\0' || errno == ERANGE) {
                    rc = ASM_ERR_BAD_OPERAND;
                    set_err(err, rc, s->line_no, "invalid integer operand '%s'", s->operand);
                    free(code);
                    goto fail;
                }
                int64_t val = (int64_t)v;
                memcpy(code + s->address + 1, &val, sizeof(val));
                break;
            }
 
            case OPERAND_ADDR: {
                LabelEntry *le = find_label(labels, label_count, s->operand);
                if (le == NULL) {
                    rc = ASM_ERR_UNKNOWN_LABEL;
                    set_err(err, rc, s->line_no, "undefined label '%s'", s->operand);
                    free(code);
                    goto fail;
                }
                if (le->address > (size_t)INT32_MAX) {
                    rc = ASM_ERR_BAD_OPERAND;
                    set_err(err, rc, s->line_no, "target address too large for '%s'", s->operand);
                    free(code);
                    goto fail;
                }
                int32_t addr32 = (int32_t)le->address;
                memcpy(code + s->address + 1, &addr32, sizeof(addr32));
                break;
            }
 
            case OPERAND_LOCAL: {
                char *endptr = NULL;
                errno = 0;
                long v = strtol(s->operand, &endptr, 10);
                if (endptr == s->operand || *endptr != '\0' || errno == ERANGE || v < 0 ||
                    v >= VM_LOCALS_PER_FRAME) {
                    rc = ASM_ERR_BAD_OPERAND;
                    set_err(err, rc, s->line_no, "local index must be 0-%d, got '%s'",
                            VM_LOCALS_PER_FRAME - 1, s->operand);
                    free(code);
                    goto fail;
                }
                code[s->address + 1] = (uint8_t)v;
                break;
            }
            }
        }
 
        *out_code = code;
        *out_size = offset;
    }
 
    free_statements(stmts, stmt_count);
    free_labels(labels, label_count);
    free(buf);
    return ASM_OK;
 
fail:
    free_statements(stmts, stmt_count);
    free_labels(labels, label_count);
    free(buf);
    return rc;
}
 
const char *asm_status_str(AsmStatus status) {
    switch (status) {
    case ASM_OK: return "ok";
    case ASM_ERR_EMPTY_LABEL: return "empty label";
    case ASM_ERR_BAD_LABEL_NAME: return "invalid label name";
    case ASM_ERR_DUPLICATE_LABEL: return "duplicate label";
    case ASM_ERR_UNKNOWN_MNEMONIC: return "unknown mnemonic";
    case ASM_ERR_UNKNOWN_LABEL: return "undefined label";
    case ASM_ERR_MISSING_OPERAND: return "missing operand";
    case ASM_ERR_UNEXPECTED_OPERAND: return "unexpected operand";
    case ASM_ERR_BAD_OPERAND: return "bad operand";
    case ASM_ERR_OUT_OF_MEMORY: return "out of memory";
    default: return "unknown error";
    }
}
 

394 linesc

Writes …/asm.c

Files at this step

drag the rail to scrub

Discussion

No comments yet. Start the discussion. Recorded by @patrick-toulme.

#c #claude #claude-code #claude-sonnet-5 #quick #testing

v1-claude

← all sessions