uzn/src/main.zig

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var uxn = Uxn{
        .mem = try allocator.alloc(u8, 0xFFFF),
        .ws = try allocator.alloc(u8, 0xFF),
        .rs = try allocator.alloc(u8, 0xFF),
        .wsp = 0,
        .rsp = 0,
        .pc = 0x0100,
    };
    defer allocator.free(uxn.mem);
    defer allocator.free(uxn.ws);
    defer allocator.free(uxn.rs);

    while (true) uxn.loop();
}

pub const Uxn = struct {
    mem: [0xFFFF]u8,
    // ws: [0xFF]u8,
    // rs: [0xFF]u8,
    // wsp: u8,
    // rsp: u8,
    ws: Stack,
    rs: Stack,
    pc: u16,

    const Stack = struct {
        s: *[0xFF]u8,
        sp: *u8,
    };

    pub fn loop(self: *Uxn) void {
        switch (self.mem[self.pc]) {
            0x00 => {}, // BRK
            0x01 => inc(&self.ws, false, false), // INC
            0x02 => pop(&self.ws, false, false), // POP
            0x03 => nip(&self.ws, false, false), // NIP
            0x04 => swp(&self.ws, false, false), // SWP
            0x05 => {}, // ROT
            0x06 => {}, // DUP
            0x07 => {}, // OVR
            0x08 => {}, // EQU
            0x09 => {}, // NEQ
            0x0A => {}, // GTH
            0x0B => {}, // LTH
            0x0C => {}, // JMP
            0x0D => {}, // JCN
            0x0E => {}, // JSR
            0x0F => {}, // STH
            0x10 => {}, // LDZ
            0x11 => {}, // STZ
            0x12 => {}, // LDR
            0x13 => {}, // STR
            0x14 => {}, // LDA
            0x15 => {}, // STA
            0x16 => {}, // DEI
            0x17 => {}, // DEO
            0x18 => {}, // ADD
            0x19 => {}, // SUB
            0x1A => {}, // MUL
            0x1B => {}, // DIV
            0x1C => {}, // AND
            0x1D => {}, // ORA
            0x1E => {}, // EOR
            0x1F => {}, // SFT
        }
    }

    fn brk() void {}

    fn inc(stack: *Stack, comptime short: bool, comptime keep: bool) void {
        _ = short;
        if (keep) {
            stack.s[stack.sp +% 1] = stack.s[stack.sp] +% 1;
            stack.sp +%= 1;
        } else {
            stack.s[stack.sp] +%= 1;
        }
    }

    fn pop(stack: *Stack, comptime short: bool, comptime keep: bool) void {
        if (!keep) {
            if (short) stack.sp -%= 2 else stack.sp -%= 1;
        }
    }

    fn nip(stack: *Stack, comptime short: bool, comptime keep: bool) void {
        _ = short;
        if (!keep) {
            stack.sp -%= 1;
            stack.s[stack.sp] = stack.s[stack.sp +% 1];
        }
    }

    fn swp(stack: *Stack, comptime short: bool, comptime keep: bool) void {
        _ = short;
        if (keep) {
            stack.s[stack.sp +% 1] = stack.s[stack.sp];
            stack.s[stack.sp +% 2] = stack.s[stack.sp -% 1];
        } else {
            const a = stack.s[stack.sp -% 1];
            stack.s[stack.sp -% 1] = stack.s[stack.sp];
            stack.sp = a;
        }
    }

    fn dup() void {}
    fn ovr() void {}
    fn equ() void {}
    fn neq() void {}
    fn gth() void {}
    fn lth() void {}
    fn jmp() void {}
    fn jcn() void {}
    fn jsr() void {}
    fn sth() void {}
    fn ldz() void {}
    fn stz() void {}
    fn ldr() void {}
    fn str() void {}
    fn lda() void {}
    fn sta() void {}
    fn dei() void {}
    fn deo() void {}
    fn add() void {}
    fn sub() void {}
    fn mul() void {}
    fn div() void {}
    fn @"and"() void {}
    fn ora() void {}
    fn eor() void {}
    fn sft() void {}
};