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 26 / 45

tests.cchange 1/1

#define _POSIX_C_SOURCE 200809L
 
#include "asm.h"
#include "vm.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static int g_tests_run = 0;
static int g_tests_failed = 0;
 
static void report(int cond, const char *file, int line, const char *desc) {
    g_tests_run++;
    if (!cond) {
        g_tests_failed++;
        fprintf(stderr, "FAIL %s:%d: %s\n", file, line, desc);
    }
}
#define CHECK(cond) report((cond), __FILE__, __LINE__, #cond)
 
static char *read_file(const char *path) {
    FILE *f = fopen(path, "rb");
    if (f == NULL) {
        fprintf(stderr, "cannot open %s\n", path);
        exit(1);
    }
    fseek(f, 0, SEEK_END);
    long sz = ftell(f);
    fseek(f, 0, SEEK_SET);
    char *buf = malloc((size_t)sz + 1);
    size_t n = fread(buf, 1, (size_t)sz, f);
    buf[n] = '\0';
    fclose(f);
    return buf;
}
 
typedef struct {
    int assembled;
    AsmStatus asm_status;
    VMStatus vm_status;
    char *output; /* caller must free(); NULL if assembly failed */
} RunResult;
 
static RunResult run_source(const char *source) {
    RunResult r;
    memset(&r, 0, sizeof(r));
 
    uint8_t *code = NULL;
    size_t code_size = 0;
    AsmError aerr;
    r.asm_status = asm_assemble(source, &code, &code_size, &aerr);
    if (r.asm_status != ASM_OK) {
        r.assembled = 0;
        return r;
    }
    r.assembled = 1;
 
    char *bufp = NULL;
    size_t bufsz = 0;
    FILE *mem = open_memstream(&bufp, &bufsz);
 
    VM vm;
    vm_init(&vm, code, code_size, mem);
    r.vm_status = vm_run(&vm);
 
    fclose(mem);
    free(code);
    r.output = bufp;
    return r;
}
 
/* ---- example programs ---- */
 
static void check_example(const char *path, const char *expected) {
    char *source = read_file(path);
    RunResult r = run_source(source);
    CHECK(r.assembled);
    if (r.assembled) {
        CHECK(r.vm_status == VM_OK);
        int match = r.output != NULL && strcmp(r.output, expected) == 0;
        CHECK(match);
        if (!match) {
            fprintf(stderr, "  in %s\n  expected: %s\n  actual:   %s\n", path, expected,
                    r.output ? r.output : "(null)");
        }
    }
    free(r.output);
    free(source);
}
 
static void test_fib(void) { check_example("examples/fib.vasm", "6765\n"); }
static void test_fact(void) { check_example("examples/fact.vasm", "3628800\n"); }
static void test_primes(void) {
    check_example("examples/primes.vasm",
                   "2\n3\n5\n7\n11\n13\n17\n19\n23\n29\n31\n37\n41\n43\n47\n");
}
 
/* ---- op-level positive tests ---- */
 
static void test_arithmetic_ops(void) {
    RunResult r = run_source(
        "PUSH 3\nPUSH 4\nADD\nPRINT\n"
        "PUSH 10\nPUSH 3\nSUB\nPRINT\n"
        "PUSH 6\nPUSH 7\nMUL\nPRINT\n"
        "PUSH 20\nPUSH 6\nDIV\nPRINT\n"
        "PUSH 20\nPUSH 6\nMOD\nPRINT\n"
        "PUSH 5\nNEG\nPRINT\n"
        "PUSH 3\nPUSH 3\nEQ\nPRINT\n"
        "PUSH 3\nPUSH 4\nLT\nPRINT\n"
        "PUSH 4\nPUSH 3\nGT\nPRINT\n"
        "PUSH 1\nDUP\nADD\nPRINT\n"
        "PUSH 1\nPUSH 2\nSWAP\nSUB\nPRINT\n"
        "HALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_OK);
    const char *expected = "7\n7\n42\n3\n2\n-5\n1\n1\n1\n2\n1\n";
    CHECK(r.output != NULL && strcmp(r.output, expected) == 0);
    free(r.output);
}
 
static void test_call_ret(void) {
    RunResult r = run_source(
        "PUSH 41\n"
        "CALL inc\n"
        "PRINT\n"
        "HALT\n"
        "inc:\n"
        "    STORE 0\n"
        "    LOAD 0\n"
        "    PUSH 1\n"
        "    ADD\n"
        "    RET\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_OK);
    CHECK(r.output != NULL && strcmp(r.output, "42\n") == 0);
    free(r.output);
}
 
/* ---- negative tests: VM error paths reachable via valid assembly ---- */
 
static void test_stack_underflow(void) {
    RunResult r = run_source("ADD\nHALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_STACK_UNDERFLOW);
    free(r.output);
}
 
static void test_stack_overflow(void) {
    RunResult r = run_source("loop:\n    PUSH 1\n    JMP loop\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_STACK_OVERFLOW);
    free(r.output);
}
 
static void test_div_zero(void) {
    RunResult r = run_source("PUSH 5\nPUSH 0\nDIV\nHALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_DIV_ZERO);
    free(r.output);
}
 
static void test_mod_zero(void) {
    RunResult r = run_source("PUSH 5\nPUSH 0\nMOD\nHALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_DIV_ZERO);
    free(r.output);
}
 
static void test_call_stack_overflow(void) {
    RunResult r = run_source("loop:\n    CALL loop\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_CALLSTACK_OVERFLOW);
    free(r.output);
}
 
static void test_call_stack_underflow(void) {
    RunResult r = run_source("RET\nHALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_ERR_CALLSTACK_UNDERFLOW);
    free(r.output);
}
 
/* ---- negative tests: VM error paths that need hand-crafted bytecode,
 * since a correct assembler can never emit them ---- */
 
static void test_vm_bad_opcode(void) {
    uint8_t code[] = {0xFF};
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_BAD_OPCODE);
}
 
static void test_vm_out_of_range_jump(void) {
    uint8_t code[5];
    code[0] = (uint8_t)OP_JMP;
    int32_t target = 9999;
    memcpy(&code[1], &target, sizeof(target));
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_BAD_JUMP);
}
 
static void test_vm_negative_jump_target(void) {
    uint8_t code[5];
    code[0] = (uint8_t)OP_JMP;
    int32_t target = -1;
    memcpy(&code[1], &target, sizeof(target));
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_BAD_JUMP);
}
 
static void test_vm_bad_local_index(void) {
    uint8_t code[2];
    code[0] = (uint8_t)OP_LOAD;
    code[1] = 200;
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_BAD_LOCAL_INDEX);
}
 
static void test_vm_truncated_instruction(void) {
    uint8_t code[1] = {(uint8_t)OP_PUSH}; /* missing 8-byte immediate */
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_TRUNCATED);
}
 
static void test_vm_no_code(void) {
    VM vm;
    vm_init(&vm, NULL, 0, NULL);
    VMStatus st = vm_run(&vm);
    CHECK(st == VM_ERR_NO_CODE);
}
 
/* ---- negative tests: assembler error paths ---- */
 
static void test_asm_unknown_mnemonic(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("FOO\nHALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_UNKNOWN_MNEMONIC);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_unknown_label(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("JMP nowhere\nHALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_UNKNOWN_LABEL);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_duplicate_label(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("a: HALT\na: HALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_DUPLICATE_LABEL);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_missing_operand(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("PUSH\nHALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_MISSING_OPERAND);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_unexpected_operand(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("HALT 1\n", &code, &size, &err);
    CHECK(st == ASM_ERR_UNEXPECTED_OPERAND);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_bad_local_index(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("LOAD 16\nHALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_BAD_OPERAND);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_bad_integer_operand(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("PUSH abc\nHALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_BAD_OPERAND);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_invalid_label_name(void) {
    AsmError err;
    uint8_t *code;
    size_t size;
    AsmStatus st = asm_assemble("9bad: HALT\n", &code, &size, &err);
    CHECK(st == ASM_ERR_BAD_LABEL_NAME);
    CHECK(code == NULL && size == 0);
}
 
static void test_asm_comments_and_whitespace(void) {
    RunResult r = run_source(
        "; leading comment\n"
        "   PUSH 1   ; push one\n"
        "\n"
        "# also a comment style\n"
        "   PUSH 2\n"
        "   ADD\n"
        "   PRINT\n"
        "   HALT\n");
    CHECK(r.assembled);
    CHECK(r.vm_status == VM_OK);
    CHECK(r.output != NULL && strcmp(r.output, "3\n") == 0);
    free(r.output);
}
 
int main(void) {
    test_fib();
    test_fact();
    test_primes();
 
    test_arithmetic_ops();
    test_call_ret();
    test_asm_comments_and_whitespace();
 
    test_stack_underflow();
    test_stack_overflow();
    test_div_zero();
    test_mod_zero();
    test_call_stack_overflow();
    test_call_stack_underflow();
 
    test_vm_bad_opcode();
    test_vm_out_of_range_jump();
    test_vm_negative_jump_target();
    test_vm_bad_local_index();
    test_vm_truncated_instruction();
    test_vm_no_code();
 
    test_asm_unknown_mnemonic();
    test_asm_unknown_label();
    test_asm_duplicate_label();
    test_asm_missing_operand();
    test_asm_unexpected_operand();
    test_asm_bad_local_index();
    test_asm_bad_integer_operand();
    test_asm_invalid_label_name();
 
    printf("%d/%d tests passed\n", g_tests_run - g_tests_failed, g_tests_run);
    return g_tests_failed == 0 ? 0 : 1;
}
 

367 linesc

Writes …/tests.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