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 16 / 28
asm.cchange 1/1
#include "asm.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <strings.h>
 
typedef enum {
    ARG_NONE,
    ARG_INT64,
    ARG_LOCAL,
    ARG_JUMP
} ArgType;
 
typedef struct {
    const char *mnemonic;
    Opcode opcode;
    ArgType arg_type;
} OpcodeInfo;
 
static const OpcodeInfo OPCODES[] = {
    {"HALT",  OP_HALT,  ARG_NONE},
    {"PUSH",  OP_PUSH,  ARG_INT64},
    {"POP",   OP_POP,   ARG_NONE},
    {"DUP",   OP_DUP,   ARG_NONE},
    {"SWAP",  OP_SWAP,  ARG_NONE},
    {"ADD",   OP_ADD,   ARG_NONE},
    {"SUB",   OP_SUB,   ARG_NONE},
    {"MUL",   OP_MUL,   ARG_NONE},
    {"DIV",   OP_DIV,   ARG_NONE},
    {"MOD",   OP_MOD,   ARG_NONE},
    {"NEG",   OP_NEG,   ARG_NONE},
    {"EQ",    OP_EQ,    ARG_NONE},
    {"LT",    OP_LT,    ARG_NONE},
    {"GT",    OP_GT,    ARG_NONE},
    {"JMP",   OP_JMP,   ARG_JUMP},
    {"JZ",    OP_JZ,    ARG_JUMP},
    {"JNZ",   OP_JNZ,   ARG_JUMP},
    {"CALL",  OP_CALL,  ARG_JUMP},
    {"RET",   OP_RET,   ARG_NONE},
    {"LOAD",  OP_LOAD,  ARG_LOCAL},
    {"STORE", OP_STORE, ARG_LOCAL},
    {"PRINT", OP_PRINT, ARG_NONE},
    {NULL, 0, ARG_NONE}
};
 
typedef struct {
    char name[64];
    uint32_t offset;
} Label;
 
#define MAX_LABELS 512
 
typedef struct {
    Label labels[MAX_LABELS];
    size_t count;
} SymbolTable;
 
static void trim(char *s) {
    if (!s) return;
    char *p = s;
    while (isspace((unsigned char)*p)) p++;
    if (p != s) memmove(s, p, strlen(p) + 1);
    size_t len = strlen(s);
    while (len > 0 && isspace((unsigned char)s[len - 1])) {
        s[--len] = '\0';
    }
}
 
static void strip_comment(char *s) {
    if (!s) return;
    for (size_t i = 0; s[i] != '\0'; i++) {
        if (s[i] == '#' || s[i] == ';') {
            s[i] = '\0';
            break;
        }
        if (s[i] == '/' && s[i+1] == '/') {
            s[i] = '\0';
            break;
        }
    }
}
 
static bool is_valid_label_name(const char *name) {
    if (!name || *name == '\0') return false;
    if (!isalpha((unsigned char)*name) && *name != '_') return false;
    for (size_t i = 1; name[i] != '\0'; i++) {
        if (!isalnum((unsigned char)name[i]) && name[i] != '_') return false;
    }
    return true;
}
 
static bool is_number(const char *str) {
    if (!str || *str == '\0') return false;
    if (*str == '+' || *str == '-') str++;
    if (*str == '\0') return false;
    if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
        const char *p = str + 2;
        if (*p == '\0') return false;
        while (*p) {
            if (!isxdigit((unsigned char)*p)) return false;
            p++;
        }
        return true;
    }
    while (*str) {
        if (!isdigit((unsigned char)*str)) return false;
        str++;
    }
    return true;
}
 
static const OpcodeInfo *find_opcode(const char *name) {
    if (!name) return NULL;
    for (size_t i = 0; OPCODES[i].mnemonic != NULL; i++) {
        if (strcasecmp(OPCODES[i].mnemonic, name) == 0) {
            return &OPCODES[i];
        }
    }
    return NULL;
}
 
static bool add_label(SymbolTable *syms, const char *name, uint32_t offset) {
    if (syms->count >= MAX_LABELS) return false;
    for (size_t i = 0; i < syms->count; i++) {
        if (strcmp(syms->labels[i].name, name) == 0) {
            return false; // Duplicate
        }
    }
    strncpy(syms->labels[syms->count].name, name, sizeof(syms->labels[syms->count].name) - 1);
    syms->labels[syms->count].name[sizeof(syms->labels[syms->count].name) - 1] = '\0';
    syms->labels[syms->count].offset = offset;
    syms->count++;
    return true;
}
 
static int find_label(const SymbolTable *syms, const char *name) {
    for (size_t i = 0; i < syms->count; i++) {
        if (strcmp(syms->labels[i].name, name) == 0) {
            return (int)i;
        }
    }
    return -1;
}
 
static void set_error(AsmError *err, AsmResult status, int line, const char *msg) {
    if (!err) return;
    err->status = status;
    err->error_line = line;
    if (msg) {
        strncpy(err->error_msg, msg, sizeof(err->error_msg) - 1);
        err->error_msg[sizeof(err->error_msg) - 1] = '\0';
    } else {
        err->error_msg[0] = '\0';
    }
}
 
static bool append_bytes(uint8_t **buf, size_t *size, size_t *capacity, const void *data, size_t n) {
    if (*size + n > *capacity) {
        size_t new_cap = (*capacity == 0) ? 256 : *capacity * 2;
        while (new_cap < *size + n) new_cap *= 2;
        uint8_t *new_buf = realloc(*buf, new_cap);
        if (!new_buf) return false;
        *buf = new_buf;
        *capacity = new_cap;
    }
    memcpy(*buf + *size, data, n);
    *size += n;
    return true;
}
 
AsmResult assemble_string(const char *source, uint8_t **out_code, size_t *out_size, AsmError *err) {
    if (!source || !out_code || !out_size) {
        set_error(err, ASM_ERR_SYNTAX_ERROR, 0, "Invalid NULL parameter");
        return ASM_ERR_SYNTAX_ERROR;
    }
 
    SymbolTable syms = { .count = 0 };
 
    // PASS 1: Calculate offsets and populate symbol table
    uint32_t current_offset = 0;
    int line_num = 0;
    const char *line_start = source;
 
    while (*line_start != '\0') {
        line_num++;
        const char *line_end = strchr(line_start, '\n');
        size_t line_len = line_end ? (size_t)(line_end - line_start) : strlen(line_start);
 
        char linebuf[512];
        if (line_len >= sizeof(linebuf)) {
            set_error(err, ASM_ERR_SYNTAX_ERROR, line_num, "Line too long");
            return ASM_ERR_SYNTAX_ERROR;
        }
        memcpy(linebuf, line_start, line_len);
        linebuf[line_len] = '\0';
 
        strip_comment(linebuf);
        trim(linebuf);
 
        if (linebuf[0] != '\0') {
            char *colon = strchr(linebuf, ':');
            char *inst_str = linebuf;
 
            if (colon) {
                *colon = '\0';
                char *label_name = linebuf;
                trim(label_name);
 
                if (!is_valid_label_name(label_name)) {
                    set_error(err, ASM_ERR_SYNTAX_ERROR, line_num, "Invalid label name");
                    return ASM_ERR_SYNTAX_ERROR;
                }
 
                if (!add_label(&syms, label_name, current_offset)) {
                    set_error(err, ASM_ERR_DUPLICATE_LABEL, line_num, "Duplicate label definition");
                    return ASM_ERR_DUPLICATE_LABEL;
                }
 
                inst_str = colon + 1;
                trim(inst_str);
            }
 
            if (inst_str[0] != '\0') {
                char op_token[64] = {0};
                char arg_token[128] = {0};
                int scanned = sscanf(inst_str, "%63s %127s", op_token, arg_token);
 
                if (scanned >= 1) {
                    const OpcodeInfo *info = find_opcode(op_token);
                    if (!info) {
                        set_error(err, ASM_ERR_UNKNOWN_INSTRUCTION, line_num, "Unknown instruction");
                        return ASM_ERR_UNKNOWN_INSTRUCTION;
                    }
 
                    if (info->arg_type != ARG_NONE && scanned < 2) {
                        set_error(err, ASM_ERR_INVALID_OPERAND, line_num, "Missing required operand");
                        return ASM_ERR_INVALID_OPERAND;
                    }
 
                    switch (info->arg_type) {
                        case ARG_NONE:  current_offset += 1; break;
                        case ARG_INT64: current_offset += 9; break;
                        case ARG_LOCAL: current_offset += 2; break;
                        case ARG_JUMP:  current_offset += 5; break;
                    }
                }
            }
        }
 
        line_start = line_end ? line_end + 1 : line_start + line_len;
    }
 
    // PASS 2: Emit binary bytecode
    uint8_t *code = NULL;
    size_t code_size = 0;
    size_t code_cap = 0;
 
    line_num = 0;
    line_start = source;
 
    while (*line_start != '\0') {
        line_num++;
        const char *line_end = strchr(line_start, '\n');
        size_t line_len = line_end ? (size_t)(line_end - line_start) : strlen(line_start);
 
        char linebuf[512];
        memcpy(linebuf, line_start, line_len);
        linebuf[line_len] = '\0';
 
        strip_comment(linebuf);
        trim(linebuf);
 
        if (linebuf[0] != '\0') {
            char *colon = strchr(linebuf, ':');
            char *inst_str = linebuf;
 
            if (colon) {
                inst_str = colon + 1;
                trim(inst_str);
            }
 
            if (inst_str[0] != '\0') {
                char op_token[64] = {0};
                char arg_token[128] = {0};
                int scanned = sscanf(inst_str, "%63s %127s", op_token, arg_token);
 
                if (scanned >= 1) {
                    const OpcodeInfo *info = find_opcode(op_token);
                    uint8_t op_byte = (uint8_t)info->opcode;
 
                    if (!append_bytes(&code, &code_size, &code_cap, &op_byte, 1)) {
                        free(code);
                        set_error(err, ASM_ERR_OUT_OF_MEMORY, line_num, "Out of memory");
                        return ASM_ERR_OUT_OF_MEMORY;
                    }
 
                    if (info->arg_type == ARG_INT64) {
                        char *endptr;
                        int64_t val = (int64_t)strtoll(arg_token, &endptr, 0);
                        if (*endptr != '\0') {
                            free(code);
                            set_error(err, ASM_ERR_INVALID_OPERAND, line_num, "Invalid integer operand");
                            return ASM_ERR_INVALID_OPERAND;
                        }
                        if (!append_bytes(&code, &code_size, &code_cap, &val, 8)) {
                            free(code);
                            set_error(err, ASM_ERR_OUT_OF_MEMORY, line_num, "Out of memory");
                            return ASM_ERR_OUT_OF_MEMORY;
                        }
                    } else if (info->arg_type == ARG_LOCAL) {
                        char *endptr;
                        long val = strtol(arg_token, &endptr, 0);
                        if (*endptr != '\0' || val < 0 || val >= VM_LOCALS_COUNT) {
                            free(code);
                            set_error(err, ASM_ERR_INVALID_OPERAND, line_num, "Invalid local variable index");
                            return ASM_ERR_INVALID_OPERAND;
                        }
                        uint8_t uval = (uint8_t)val;
                        if (!append_bytes(&code, &code_size, &code_cap, &uval, 1)) {
                            free(code);
                            set_error(err, ASM_ERR_OUT_OF_MEMORY, line_num, "Out of memory");
                            return ASM_ERR_OUT_OF_MEMORY;
                        }
                    } else if (info->arg_type == ARG_JUMP) {
                        uint32_t target_offset = 0;
                        if (is_number(arg_token)) {
                            char *endptr;
                            target_offset = (uint32_t)strtoul(arg_token, &endptr, 0);
                            if (*endptr != '\0') {
                                free(code);
                                set_error(err, ASM_ERR_INVALID_OPERAND, line_num, "Invalid jump offset");
                                return ASM_ERR_INVALID_OPERAND;
                            }
                        } else {
                            int idx = find_label(&syms, arg_token);
                            if (idx < 0) {
                                free(code);
                                set_error(err, ASM_ERR_UNDEFINED_LABEL, line_num, "Undefined label");
                                return ASM_ERR_UNDEFINED_LABEL;
                            }
                            target_offset = syms.labels[idx].offset;
                        }
                        if (!append_bytes(&code, &code_size, &code_cap, &target_offset, 4)) {
                            free(code);
                            set_error(err, ASM_ERR_OUT_OF_MEMORY, line_num, "Out of memory");
                            return ASM_ERR_OUT_OF_MEMORY;
                        }
                    }
                }
            }
        }
 
        line_start = line_end ? line_end + 1 : line_start + line_len;
    }
 
    *out_code = code;
    *out_size = code_size;
    set_error(err, ASM_OK, 0, NULL);
    return ASM_OK;
}
 
AsmResult assemble_file(const char *filename, uint8_t **out_code, size_t *out_size, AsmError *err) {
    if (!filename) {
        set_error(err, ASM_ERR_SYNTAX_ERROR, 0, "NULL filename");
        return ASM_ERR_SYNTAX_ERROR;
    }
 
    FILE *f = fopen(filename, "rb");
    if (!f) {
        set_error(err, ASM_ERR_SYNTAX_ERROR, 0, "Could not open file");
        return ASM_ERR_SYNTAX_ERROR;
    }
 
    fseek(f, 0, SEEK_END);
    long len = ftell(f);
    fseek(f, 0, SEEK_SET);
 
    if (len < 0) {
        fclose(f);
        set_error(err, ASM_ERR_SYNTAX_ERROR, 0, "File seek error");
        return ASM_ERR_SYNTAX_ERROR;
    }
 
    char *buf = malloc((size_t)len + 1);
    if (!buf) {
        fclose(f);
        set_error(err, ASM_ERR_OUT_OF_MEMORY, 0, "Out of memory");
        return ASM_ERR_OUT_OF_MEMORY;
    }
 
    size_t read_bytes = fread(buf, 1, (size_t)len, f);
    fclose(f);
    buf[read_bytes] = '\0';
 
    AsmResult res = assemble_string(buf, out_code, out_size, err);
    free(buf);
    return res;
}
 
const char *asm_result_to_string(AsmResult result) {
    switch (result) {
        case ASM_OK: return "OK";
        case ASM_ERR_UNKNOWN_INSTRUCTION: return "Unknown instruction";
        case ASM_ERR_INVALID_OPERAND: return "Invalid operand";
        case ASM_ERR_UNDEFINED_LABEL: return "Undefined label";
        case ASM_ERR_DUPLICATE_LABEL: return "Duplicate label";
        case ASM_ERR_SYNTAX_ERROR: return "Syntax error";
        case ASM_ERR_OUT_OF_MEMORY: return "Out of memory";
        default: return "Unknown assembly error";
    }
}
 
413 linesc
Writes …/fact.vasm
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