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

antigravitygemini · 28 steps · 1m 01s · 9 filessession da5b2d5a-567@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 28 / 28

tests.cchange 1/1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "vm.h"
#include "asm.h"
 
static void test_example_file(const char *filepath, const char *expected_output) {
    printf("Testing example: %s ... ", filepath);
    uint8_t *code = NULL;
    size_t code_size = 0;
    AsmError asm_err;
 
    AsmResult asm_res = assemble_file(filepath, &code, &code_size, &asm_err);
    if (asm_res != ASM_OK) {
        fprintf(stderr, "Assembly failed: %s (line %d: %s)\n",
                asm_result_to_string(asm_res), asm_err.error_line, asm_err.error_msg);
        assert(asm_res == ASM_OK);
    }
 
    char *buf = NULL;
    size_t buf_size = 0;
    FILE *out = open_memstream(&buf, &buf_size);
 
    VM vm;
    vm_init(&vm, code, code_size, out);
    VMResult vm_res = vm_run(&vm);
 
    fclose(out);
 
    if (vm_res != VM_OK) {
        fprintf(stderr, "VM execution failed: %s\n", vm_result_to_string(vm_res));
        assert(vm_res == VM_OK);
    }
 
    assert(buf != NULL);
    assert(strcmp(buf, expected_output) == 0);
 
    free(buf);
    free(code);
    printf("PASSED\n");
}
 
static void test_vm_instructions(void) {
    printf("Testing VM basic instructions ... ");
    const char *src =
        "PUSH 10\n"
        "PUSH 20\n"
        "DUP\n"
        "PRINT\n"   // prints 20
        "SWAP\n"
        "PRINT\n"   // prints 10
        "PRINT\n"   // prints 20
        "PUSH 5\n"
        "NEG\n"
        "PRINT\n"   // prints -5
        "PUSH 10\n"
        "PUSH 10\n"
        "EQ\n"
        "PRINT\n"   // prints 1
        "PUSH 5\n"
        "PUSH 10\n"
        "LT\n"
        "PRINT\n"   // prints 1
        "PUSH 5\n"
        "PUSH 10\n"
        "GT\n"
        "PRINT\n"   // prints 0
        "HALT\n";
 
    uint8_t *code = NULL;
    size_t code_size = 0;
    AsmError asm_err;
    AsmResult asm_res = assemble_string(src, &code, &code_size, &asm_err);
    assert(asm_res == ASM_OK);
 
    char *buf = NULL;
    size_t buf_size = 0;
    FILE *out = open_memstream(&buf, &buf_size);
 
    VM vm;
    vm_init(&vm, code, code_size, out);
    VMResult vm_res = vm_run(&vm);
    fclose(out);
 
    assert(vm_res == VM_OK);
    const char *expected = "20\n10\n20\n-5\n1\n1\n0\n";
    assert(strcmp(buf, expected) == 0);
 
    free(buf);
    free(code);
    printf("PASSED\n");
}
 
static void test_negative_stack_overflow(void) {
    printf("Testing negative path: Stack overflow ... ");
    // Stack capacity is 256. Push 257 elements.
    size_t code_cap = 257 * 9 + 1;
    uint8_t *code = malloc(code_cap);
    size_t offset = 0;
    int64_t val = 42;
    for (int i = 0; i < 257; i++) {
        code[offset++] = OP_PUSH;
        memcpy(&code[offset], &val, 8);
        offset += 8;
    }
    code[offset++] = OP_HALT;
 
    VM vm;
    vm_init(&vm, code, offset, NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_STACK_OVERFLOW);
 
    free(code);
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_stack_underflow(void) {
    printf("Testing negative path: Stack underflow ... ");
    // Empty stack, execute POP
    uint8_t code[] = { OP_POP, OP_HALT };
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_STACK_UNDERFLOW);
 
    // Stack with 1 element, execute ADD (requires 2)
    uint8_t code2[] = { OP_PUSH, 1,0,0,0,0,0,0,0, OP_ADD, OP_HALT };
    vm_init(&vm, code2, sizeof(code2), NULL);
    res = vm_run(&vm);
    assert(res == VM_ERR_STACK_UNDERFLOW);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_call_stack_overflow(void) {
    printf("Testing negative path: Call stack overflow ... ");
    // CALL to offset 0 infinitely until call stack (capacity 256) overflows
    uint8_t code[] = { OP_CALL, 0, 0, 0, 0, OP_HALT };
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_CALL_STACK_OVERFLOW);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_call_stack_underflow(void) {
    printf("Testing negative path: Call stack underflow ... ");
    // RET at top level
    uint8_t code[] = { OP_RET, OP_HALT };
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_CALL_STACK_UNDERFLOW);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_division_by_zero(void) {
    printf("Testing negative path: Division/Modulo by zero ... ");
    // DIV by 0
    const char *src_div = "PUSH 10\nPUSH 0\nDIV\nHALT\n";
    uint8_t *code = NULL;
    size_t code_size = 0;
    AsmError asm_err;
    AsmResult asm_res = assemble_string(src_div, &code, &code_size, &asm_err);
    assert(asm_res == ASM_OK);
 
    VM vm;
    vm_init(&vm, code, code_size, NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_DIVISION_BY_ZERO);
    free(code);
 
    // MOD by 0
    const char *src_mod = "PUSH 10\nPUSH 0\nMOD\nHALT\n";
    asm_res = assemble_string(src_mod, &code, &code_size, &asm_err);
    assert(asm_res == ASM_OK);
 
    vm_init(&vm, code, code_size, NULL);
    res = vm_run(&vm);
    assert(res == VM_ERR_DIVISION_BY_ZERO);
    free(code);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_invalid_opcode(void) {
    printf("Testing negative path: Invalid opcode ... ");
    uint8_t code[] = { 0xFF, OP_HALT };
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_INVALID_OPCODE);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_invalid_jump(void) {
    printf("Testing negative path: Invalid jump target ... ");
    // Jump to target address 1000 which is out of range
    uint32_t bad_target = 1000;
    uint8_t code[5];
    code[0] = OP_JMP;
    memcpy(&code[1], &bad_target, 4);
 
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_INVALID_JUMP);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_negative_invalid_local_index(void) {
    printf("Testing negative path: Invalid local index ... ");
    // LOAD 16 (valid range is 0..15)
    uint8_t code[] = { OP_LOAD, 16, OP_HALT };
    VM vm;
    vm_init(&vm, code, sizeof(code), NULL);
    VMResult res = vm_run(&vm);
    assert(res == VM_ERR_INVALID_LOCAL_INDEX);
 
    // STORE 16
    uint8_t code2[] = { OP_PUSH, 1,0,0,0,0,0,0,0, OP_STORE, 16, OP_HALT };
    vm_init(&vm, code2, sizeof(code2), NULL);
    res = vm_run(&vm);
    assert(res == VM_ERR_INVALID_LOCAL_INDEX);
 
    printf("PASSED (%s)\n", vm_result_to_string(res));
}
 
static void test_assembler_negative_paths(void) {
    printf("Testing Assembler negative error paths ... ");
    uint8_t *code = NULL;
    size_t code_size = 0;
    AsmError err;
 
    // Unknown instruction
    AsmResult res = assemble_string("FOOBAR 10\n", &code, &code_size, &err);
    assert(res == ASM_ERR_UNKNOWN_INSTRUCTION);
 
    // Missing operand
    res = assemble_string("PUSH\n", &code, &code_size, &err);
    assert(res == ASM_ERR_INVALID_OPERAND);
 
    // Undefined label
    res = assemble_string("JMP missing_label\n", &code, &code_size, &err);
    assert(res == ASM_ERR_UNDEFINED_LABEL);
 
    // Duplicate label
    res = assemble_string("label:\nlabel:\nHALT\n", &code, &code_size, &err);
    assert(res == ASM_ERR_DUPLICATE_LABEL);
 
    // Invalid local index in STORE
    res = assemble_string("STORE 20\n", &code, &code_size, &err);
    assert(res == ASM_ERR_INVALID_OPERAND);
 
    printf("PASSED\n");
}
 
int main(void) {
    printf("=== RUNNING VM & ASSEMBLER TEST SUITE ===\n\n");
 
    // Test example files
    test_example_file("examples/fib.vasm", "6765\n");
    test_example_file("examples/fact.vasm", "3628800\n");
    test_example_file("examples/primes.vasm", "2\n3\n5\n7\n11\n13\n17\n19\n23\n29\n31\n37\n41\n43\n47\n");
 
    // Basic instructions
    test_vm_instructions();
 
    // Negative VM error paths
    test_negative_stack_overflow();
    test_negative_stack_underflow();
    test_negative_call_stack_overflow();
    test_negative_call_stack_underflow();
    test_negative_division_by_zero();
    test_negative_invalid_opcode();
    test_negative_invalid_jump();
    test_negative_invalid_local_index();
 
    // Negative Assembler error paths
    test_assembler_negative_paths();
 
    printf("\n=== ALL TESTS PASSED CLEANLY ===\n");
    return 0;
}
 

290 linesc

Implemented a stack-based bytecode Virtual Machine and two-pass Assembler in C11 with full…

Files at this step

drag the rail to scrub

Discussion

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

#antigravity #c #gemini #quick #testing

v5-agy

← all sessions