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

pigpt-5.5 · 59 steps · 6m 14s · 8 filessession 16bb4aa0-258@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 19 / 59

asm.cchange 2/3

#include "vm.h"
 
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct Symbol {
    char *name;
    size_t address;
} Symbol;
 
typedef struct SymbolTable {
    Symbol *items;
    size_t count;
    size_t capacity;
} SymbolTable;
 
static char *xstrdup(const char *s) {
    size_t n = strlen(s) + 1;
    char *copy = (char *)malloc(n);
    if (copy) {
        memcpy(copy, s, n);
    }
    return copy;
}
 
static void set_error(AsmError *error, int line, const char *message) {
    if (!error) {
        return;
    }
    error->line = line;
    snprintf(error->message, sizeof(error->message), "%s", message);
}
 
static void symbol_table_free(SymbolTable *table) {
    for (size_t i = 0; i < table->count; i++) {
        free(table->items[i].name);
    }
    free(table->items);
    table->items = NULL;
    table->count = 0;
    table->capacity = 0;
}
 
static Symbol *symbol_find(SymbolTable *table, const char *name) {
    for (size_t i = 0; i < table->count; i++) {
        if (strcmp(table->items[i].name, name) == 0) {
            return &table->items[i];
        }
    }
    return NULL;
}
 
static int symbol_add(SymbolTable *table, const char *name, size_t address, AsmError *error, int line) {
    if (symbol_find(table, name)) {
        set_error(error, line, "duplicate label");
        return -1;
    }
    if (table->count == table->capacity) {
        size_t new_capacity = table->capacity == 0 ? 32 : table->capacity * 2;
        Symbol *new_items = (Symbol *)realloc(table->items, new_capacity * sizeof(*new_items));
        if (!new_items) {
            set_error(error, line, "out of memory");
            return -1;
        }
        table->items = new_items;
        table->capacity = new_capacity;
    }
    table->items[table->count].name = xstrdup(name);
    if (!table->items[table->count].name) {
        set_error(error, line, "out of memory");
        return -1;
    }
    table->items[table->count].address = address;
    table->count++;
    return 0;
}
 
static char *trim(char *s) {
    while (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';
    }
    return s;
}
 
static int valid_label_name(const char *s) {
    if (!(isalpha((unsigned char)s[0]) || s[0] == '_')) {
        return 0;
    }
    for (size_t i = 1; s[i] != '\0'; i++) {
        if (!(isalnum((unsigned char)s[i]) || s[i] == '_')) {
            return 0;
        }
    }
    return 1;
}
 
static void upper_ascii(char *s) {
    for (; *s; s++) {
        *s = (char)toupper((unsigned char)*s);
    }
}
 
static int instruction_info(const char *mnemonic, VmOpcode *opcode, int *operands) {
    char upper[32];
    if (strlen(mnemonic) >= sizeof(upper)) {
        return -1;
    }
    strcpy(upper, mnemonic);
    upper_ascii(upper);
 
    *operands = 0;
    if (strcmp(upper, "PUSH") == 0) { *opcode = OP_PUSH; *operands = 1; return 0; }
    if (strcmp(upper, "POP") == 0) { *opcode = OP_POP; return 0; }
    if (strcmp(upper, "DUP") == 0) { *opcode = OP_DUP; return 0; }
    if (strcmp(upper, "SWAP") == 0) { *opcode = OP_SWAP; return 0; }
    if (strcmp(upper, "ADD") == 0) { *opcode = OP_ADD; return 0; }
    if (strcmp(upper, "SUB") == 0) { *opcode = OP_SUB; return 0; }
    if (strcmp(upper, "MUL") == 0) { *opcode = OP_MUL; return 0; }
    if (strcmp(upper, "DIV") == 0) { *opcode = OP_DIV; return 0; }
    if (strcmp(upper, "MOD") == 0) { *opcode = OP_MOD; return 0; }
    if (strcmp(upper, "NEG") == 0) { *opcode = OP_NEG; return 0; }
    if (strcmp(upper, "EQ") == 0) { *opcode = OP_EQ; return 0; }
    if (strcmp(upper, "LT") == 0) { *opcode = OP_LT; return 0; }
    if (strcmp(upper, "GT") == 0) { *opcode = OP_GT; return 0; }
    if (strcmp(upper, "JMP") == 0) { *opcode = OP_JMP; *operands = 1; return 0; }
    if (strcmp(upper, "JZ") == 0) { *opcode = OP_JZ; *operands = 1; return 0; }
    if (strcmp(upper, "JNZ") == 0) { *opcode = OP_JNZ; *operands = 1; return 0; }
    if (strcmp(upper, "CALL") == 0) { *opcode = OP_CALL; *operands = 1; return 0; }
    if (strcmp(upper, "RET") == 0) { *opcode = OP_RET; return 0; }
    if (strcmp(upper, "LOAD") == 0) { *opcode = OP_LOAD; *operands = 1; return 0; }
    if (strcmp(upper, "STORE") == 0) { *opcode = OP_STORE; *operands = 1; return 0; }
    if (strcmp(upper, "PRINT") == 0) { *opcode = OP_PRINT; return 0; }
    if (strcmp(upper, "HALT") == 0) { *opcode = OP_HALT; return 0; }
    return -1;
}
 
static int parse_int64(const char *s, int64_t *out) {
    char *end = NULL;
    errno = 0;
    long long v = strtoll(s, &end, 0);
    if (errno != 0 || end == s || *end != '\0') {
        return -1;
    }
    *out = (int64_t)v;
    return 0;
}
 
static int parse_operand(char *operand_text, VmOpcode opcode, SymbolTable *symbols, int pass,
                         int64_t *operand, AsmError *error, int line) {
    char *tok = strtok(operand_text, " \t\r\n");
    if (!tok) {
        set_error(error, line, "missing operand");
        return -1;
    }
    if (strtok(NULL, " \t\r\n") != NULL) {
        set_error(error, line, "too many operands");
        return -1;
    }
 
    int needs_label_resolution = (opcode == OP_JMP || opcode == OP_JZ || opcode == OP_JNZ || opcode == OP_CALL);
    if (parse_int64(tok, operand) == 0) {
        return 0;
    }
 
    if (!needs_label_resolution) {
        set_error(error, line, "operand must be an integer");
        return -1;
    }
 
    if (!valid_label_name(tok)) {
        set_error(error, line, "invalid label reference");
        return -1;
    }
 
    if (pass == 1) {
        *operand = 0;
        return 0;
    }
 
    Symbol *symbol = symbol_find(symbols, tok);
    if (!symbol) {
        set_error(error, line, "undefined label");
        return -1;
    }
    *operand = (int64_t)symbol->address;
    return 0;
}
 
static int process_line(char *line, int line_no, int pass, SymbolTable *symbols,
                        Bytecode *out, size_t *pc, AsmError *error) {
    for (char *p = line; *p; p++) {
        if (*p == ';' || *p == '#') {
            *p = '\0';
            break;
        }
        if (*p == ',') {
            *p = ' ';
        }
    }
 
    char *s = trim(line);
    while (*s) {
        char *colon = strchr(s, ':');
        if (!colon) {
            break;
        }
        *colon = '\0';
        char *label = trim(s);
        if (!valid_label_name(label)) {
            set_error(error, line_no, "invalid label");
            return -1;
        }
        if (pass == 1 && symbol_add(symbols, label, *pc, error, line_no) != 0) {
            return -1;
        }
        s = trim(colon + 1);
    }
 
    if (*s == '\0') {
        return 0;
    }
 
    char *mnemonic = strtok(s, " \t\r\n");
    if (!mnemonic) {
        return 0;
    }
 
    VmOpcode opcode;
    int operand_count;
    if (instruction_info(mnemonic, &opcode, &operand_count) != 0) {
        set_error(error, line_no, "unknown mnemonic");
        return -1;
    }
 
    char *operand_text = strtok(NULL, "");
    int64_t operand = 0;
    if (operand_count == 0) {
        if (operand_text && *trim(operand_text) != '\0') {
            set_error(error, line_no, "unexpected operand");
            return -1;
        }
−    } else if (parse_operand(operand_text ? operand_text : (char *)"", opcode, symbols, pass, &operand, error, line_no) != 0) {
−        return -1;
    } else {
        if (!operand_text) {
            set_error(error, line_no, "missing operand");
            return -1;
        }
        if (parse_operand(operand_text, opcode, symbols, pass, &operand, error, line_no) != 0) {
            return -1;
        }
    }
 
    if (pass == 2) {
        VmError err = bytecode_emit(out, opcode);
        if (err != VM_OK) {
            set_error(error, line_no, vm_error_string(err));
            return -1;
        }
        if (operand_count == 1) {
            err = bytecode_emit(out, operand);
            if (err != VM_OK) {
                set_error(error, line_no, vm_error_string(err));
                return -1;
            }
        }
    }
    *pc += (size_t)(1 + operand_count);
    return 0;
}
 
static int assemble_pass(const char *source, int pass, SymbolTable *symbols, Bytecode *out, AsmError *error) {
    const char *start = source;
    int line_no = 1;
    size_t pc = 0;
 
    while (*start) {
        const char *end = strchr(start, '\n');
        size_t len = end ? (size_t)(end - start) : strlen(start);
        char *line = (char *)malloc(len + 1);
        if (!line) {
            set_error(error, line_no, "out of memory");
            return -1;
        }
        memcpy(line, start, len);
        line[len] = '\0';
 
        int rc = process_line(line, line_no, pass, symbols, out, &pc, error);
        free(line);
        if (rc != 0) {
            return -1;
        }
 
        if (!end) {
            break;
        }
        start = end + 1;
        line_no++;
    }
    return 0;
}
 
int assembler_compile_string(const char *source, Bytecode *out, AsmError *error) {
    if (error) {
        error->line = 0;
        error->message[0] = '\0';
    }
    if (!source || !out) {
        set_error(error, 0, "invalid assembler argument");
        return -1;
    }
 
    SymbolTable symbols = {0};
    if (assemble_pass(source, 1, &symbols, NULL, error) != 0) {
        symbol_table_free(&symbols);
        return -1;
    }
 
    bytecode_init(out);
    if (assemble_pass(source, 2, &symbols, out, error) != 0) {
        bytecode_free(out);
        symbol_table_free(&symbols);
        return -1;
    }
 
    symbol_table_free(&symbols);
    return 0;
}
 
int assembler_compile_file(const char *path, Bytecode *out, AsmError *error) {
    FILE *f = fopen(path, "rb");
    if (!f) {
        set_error(error, 0, "could not open input file");
        return -1;
    }
 
    if (fseek(f, 0, SEEK_END) != 0) {
        fclose(f);
        set_error(error, 0, "could not seek input file");
        return -1;
    }
    long size = ftell(f);
    if (size < 0) {
        fclose(f);
        set_error(error, 0, "could not measure input file");
        return -1;
    }
    if (fseek(f, 0, SEEK_SET) != 0) {
        fclose(f);
        set_error(error, 0, "could not rewind input file");
        return -1;
    }
 
    char *source = (char *)malloc((size_t)size + 1);
    if (!source) {
        fclose(f);
        set_error(error, 0, "out of memory");
        return -1;
    }
    size_t read_count = fread(source, 1, (size_t)size, f);
    fclose(f);
    if (read_count != (size_t)size) {
        free(source);
        set_error(error, 0, "could not read input file");
        return -1;
    }
    source[size] = '\0';
 
    int rc = assembler_compile_string(source, out, error);
    free(source);
    return rc;
}
 

381 linesc

Writes examples/fib.vasm

Files at this step

drag the rail to scrub

Discussion

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

#c #gpt #gpt-5.5 #pi #quick #testing

v4-pi

← all sessions