jeeves/uzn
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

still only half working but here you go

Browse source
This commit is contained in:
Jeeves 2024-04-22 13:55:32 -06:00
parent d4a3a6fb77
commit 4903ea72fb
5 changed files with 644 additions and 606 deletions

BIN
hello.rom Normal file
View file

Binary file not shown.

BIN
hello.rom.sym Normal file
View file

Binary file not shown.

18
hello.tal Normal file
View file

@ -0,0 +1,18 @@
|10 @Console &vector $2 &read $1 &pad $5 &write $1 &error $1
|100
@on-reset ( -> )
;my-string print-text
BRK
@print-text ( str* -- )
&while
LDAk .Console/write DEO
INC2 LDAk ?&while
POP2
JMP2r
@my-string
"Hello 20 "World! 00

623
src/main.zig
View file

@ -1,6 +1,8 @@
const std = @import("std");
const silkdot = @import("silkdot");
const Uxn = @import("uxn.zig");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
@ -17,616 +19,25 @@ pub fn main() !void {
const rom = try file.readToEndAlloc(allocator, 0xFF00);
defer allocator.free(rom);
const mem: [0x10000]u8 = undefined;
const ws: [0x100]u8 = undefined;
const rs: [0x100]u8 = undefined;
var uxn = Uxn{
.mem = .{ .m = mem },
.ws = .{ .s = ws },
.rs = .{ .s = rs },
.pc = 0x100,
};
@memcpy(uxn.mem.m[0x100 .. 0x100 + rom.len], rom);
var uxn = Uxn{ .pc = 0x100 };
@memcpy(uxn.mem.m[0x100 .. rom.len + 0x100], rom);
var term = try silkdot.Terminal.init(allocator);
defer term.deinit();
// var term = try silkdot.Terminal.init(allocator);
// defer term.deinit();
var running = true;
while (running) {
const events = try term.getEvents();
defer allocator.free(events);
for (events) |ev| switch (ev) {
.keyboard => {
if (ev.keyboard.code == 'q') running = false;
},
else => {},
};
uxn.loop();
try term.draw();
// const events = try term.getEvents();
// defer allocator.free(events);
// for (events) |ev| switch (ev) {
// .keyboard => {
// if (ev.keyboard.code == 'q') running = false;
// },
// else => {},
// };
std.debug.print("{any} {X}\n", .{ uxn.pc, uxn.mem.m[uxn.pc] });
if (uxn.eval()) running = false;
// try term.draw();
}
} else return error.NoRom;
}
pub const Uxn = struct {
mem: Memory = .{ .m = undefined },
ws: Stack = .{ .s = undefined },
rs: Stack = .{ .s = undefined },
pc: u16,
dev: [0x100]u8,
const Memory = struct {
m: [0x10000]u8,
pub fn peek(self: *Memory, comptime T: type, idx: u16) T {
return switch (T) {
u8 => self.m[idx],
u16 => @as(u16, @intCast(self.m[idx])) << 8 | self.m[idx +% 1],
else => unreachable,
};
}
pub fn poke(self: *Memory, comptime T: type, idx: u16, val: T) void {
switch (T) {
u8 => self.m[idx] = val,
u16 => {
self.m[idx] = @truncate(val >> 8);
self.m[idx +% 1] = @truncate(val & 0xFF);
},
else => unreachable,
}
}
};
const Stack = struct {
s: [0x100]u8,
sp: u8 = 0,
pub fn peek(self: *Stack, comptime T: type) T {
return switch (T) {
u8 => self.s[self.sp],
u16 => @as(u16, @intCast(self.s[self.sp])) << 8 | self.s[self.sp +% 1],
else => unreachable,
};
}
pub fn poke(self: *Stack, comptime T: type, v: T) void {
switch (T) {
u8 => self.s[self.sp] = v,
u16 => {
self.s[self.sp] = @truncate(v >> 8);
self.s[self.sp +% 1] = @truncate(v & 0xFF);
},
else => unreachable,
}
}
pub fn pop(self: *Stack, comptime T: type) T {
self.sp -%= @intCast(@divExact(@typeInfo(T).Int.bits, 8));
return self.peek(T);
}
pub fn push(self: *Stack, comptime T: type, v: T) void {
self.poke(T, v);
self.sp +%= @intCast(@divExact(@typeInfo(T).Int.bits, 8));
}
};
pub fn loop(self: *Uxn) void {
switch (self.mem.m[self.pc]) {
0x00 => {}, // BRK
0x01 => inc(&self.ws, u8, false), // INC
0x02 => pop(&self.ws, u8, false), // POP
0x03 => nip(&self.ws, u8, false), // NIP
0x04 => swp(&self.ws, u8, false), // SWP
0x05 => rot(&self.ws, u8, false), // ROT
0x06 => dup(&self.ws, u8, false), // DUP
0x07 => ovr(&self.ws, u8, false), // OVR
0x08 => equ(&self.ws, u8, false), // EQU
0x09 => neq(&self.ws, u8, false), // NEQ
0x0A => gth(&self.ws, u8, false), // GTH
0x0B => lth(&self.ws, u8, false), // LTH
0x0C => self.jmp(&self.ws, u8, false), // JMP
0x0D => self.jcn(&self.ws, u8, false), // JCN
0x0E => self.jsr(&self.ws, u8, false), // JSR
0x0F => self.sth(false, u8, false), // STH
0x10 => self.ldz(&self.ws, u8, false), // LDZ
0x11 => self.stz(&self.ws, u8, false), // STZ
0x12 => self.ldr(&self.ws, u8, false), // LDR
0x13 => self.str(&self.ws, u8, false), // STR
0x14 => self.lda(&self.ws, u8, false), // LDA
0x15 => self.sta(&self.ws, u8, false), // STA
0x16 => dei(&self.ws, u8, false), // DEI
0x17 => deo(&self.ws, u8, false), // DEO
0x18 => add(&self.ws, u8, false), // ADD
0x19 => sub(&self.ws, u8, false), // SUB
0x1A => mul(&self.ws, u8, false), // MUL
0x1B => div(&self.ws, u8, false), // DIV
0x1C => @"and"(&self.ws, u8, false), // AND
0x1D => ora(&self.ws, u8, false), // ORA
0x1E => eor(&self.ws, u8, false), // EOR
0x1F => sft(&self.ws, u8, false), // SFT
0x20 => {}, // JCI
0x21 => inc(&self.ws, u16, false), // INC2
0x22 => pop(&self.ws, u16, false), // POP2
0x23 => nip(&self.ws, u16, false), // NIP2
0x24 => swp(&self.ws, u16, false), // SWP2
0x25 => rot(&self.ws, u16, false), // ROT2
0x26 => dup(&self.ws, u16, false), // DUP2
0x27 => ovr(&self.ws, u16, false), // OVR2
0x28 => equ(&self.ws, u16, false), // EQU2
0x29 => neq(&self.ws, u16, false), // NEQ2
0x2A => gth(&self.ws, u16, false), // GTH2
0x2B => lth(&self.ws, u16, false), // LTH2
0x2C => self.jmp(&self.ws, u16, false), // JMP2
0x2D => self.jcn(&self.ws, u16, false), // JCN2
0x2E => self.jsr(&self.ws, u16, false), // JSR2
0x2F => self.sth(false, u16, false), // STH2
0x30 => self.ldz(&self.ws, u16, false), // LDZ2
0x31 => self.stz(&self.ws, u16, false), // STZ2
0x32 => self.ldr(&self.ws, u16, false), // LDR2
0x33 => self.str(&self.ws, u16, false), // STR2
0x34 => self.lda(&self.ws, u16, false), // LDA2
0x35 => self.sta(&self.ws, u16, false), // STA2
0x36 => dei(&self.ws, u16, false), // DEI2
0x37 => deo(&self.ws, u16, false), // DEO2
0x38 => add(&self.ws, u16, false), // ADD2
0x39 => sub(&self.ws, u16, false), // SUB2
0x3A => mul(&self.ws, u16, false), // MUL2
0x3B => div(&self.ws, u16, false), // DIV2
0x3C => @"and"(&self.ws, u16, false), // AND2
0x3D => ora(&self.ws, u16, false), // ORA2
0x3E => eor(&self.ws, u16, false), // EOR2
0x3F => sft(&self.ws, u16, false), // SFT2
0x40 => {}, // JMI
0x41 => inc(&self.rs, u8, false), // INCr
0x42 => pop(&self.rs, u8, false), // POPr
0x43 => nip(&self.rs, u8, false), // NIPr
0x44 => swp(&self.rs, u8, false), // SWPr
0x45 => rot(&self.rs, u8, false), // ROTr
0x46 => dup(&self.rs, u8, false), // DUPr
0x47 => ovr(&self.rs, u8, false), // OVRr
0x48 => equ(&self.rs, u8, false), // EQUr
0x49 => neq(&self.rs, u8, false), // NEQr
0x4A => gth(&self.rs, u8, false), // GTHr
0x4B => lth(&self.rs, u8, false), // LTHr
0x4C => self.jmp(&self.rs, u8, false), // JMPr
0x4D => self.jcn(&self.rs, u8, false), // JCNr
0x4E => self.jsr(&self.rs, u8, false), // JSRr
0x4F => self.sth(true, u8, false), // STHr
0x50 => self.ldz(&self.rs, u8, false), // LDZr
0x51 => self.stz(&self.rs, u8, false), // STZr
0x52 => self.ldr(&self.rs, u8, false), // LDRr
0x53 => self.str(&self.rs, u8, false), // STRr
0x54 => self.lda(&self.rs, u8, false), // LDAr
0x55 => self.sta(&self.rs, u8, false), // STAr
0x56 => dei(&self.rs, u8, false), // DEIr
0x57 => deo(&self.rs, u8, false), // DEOr
0x58 => add(&self.rs, u8, false), // ADDr
0x59 => sub(&self.rs, u8, false), // SUBr
0x5A => mul(&self.rs, u8, false), // MULr
0x5B => div(&self.rs, u8, false), // DIVr
0x5C => @"and"(&self.rs, u8, false), // ANDr
0x5D => ora(&self.rs, u8, false), // ORAr
0x5E => eor(&self.rs, u8, false), // EORr
0x5F => sft(&self.rs, u8, false), // SFTr
0x60 => {}, // JSI
0x61 => inc(&self.rs, u16, false), // INC2r
0x62 => pop(&self.rs, u16, false), // POP2r
0x63 => nip(&self.rs, u16, false), // NIP2r
0x64 => swp(&self.rs, u16, false), // SWP2r
0x65 => rot(&self.rs, u16, false), // ROT2r
0x66 => dup(&self.rs, u16, false), // DUP2r
0x67 => ovr(&self.rs, u16, false), // OVR2r
0x68 => equ(&self.rs, u16, false), // EQU2r
0x69 => neq(&self.rs, u16, false), // NEQ2r
0x6A => gth(&self.rs, u16, false), // GTH2r
0x6B => lth(&self.rs, u16, false), // LTH2r
0x6C => self.jmp(&self.rs, u16, false), // JMP2r
0x6D => self.jcn(&self.rs, u16, false), // JCN2r
0x6E => self.jsr(&self.rs, u16, false), // JSR2r
0x6F => self.sth(true, u16, false), // STH2r
0x70 => self.ldz(&self.rs, u16, false), // LDZ2r
0x71 => self.stz(&self.rs, u16, false), // STZ2r
0x72 => self.ldr(&self.rs, u16, false), // LDR2r
0x73 => self.str(&self.rs, u16, false), // STR2r
0x74 => self.lda(&self.rs, u16, false), // LDA2r
0x75 => self.sta(&self.rs, u16, false), // STA2r
0x76 => dei(&self.rs, u16, false), // DEI2r
0x77 => deo(&self.rs, u16, false), // DEO2r
0x78 => add(&self.rs, u16, false), // ADD2r
0x79 => sub(&self.rs, u16, false), // SUB2r
0x7A => mul(&self.rs, u16, false), // MUL2r
0x7B => div(&self.rs, u16, false), // DIV2r
0x7C => @"and"(&self.rs, u16, false), // AND2r
0x7D => ora(&self.rs, u16, false), // ORA2r
0x7E => eor(&self.rs, u16, false), // EOR2r
0x7F => sft(&self.rs, u16, false), // SFT2r
0x80 => {}, // LIT
0x81 => inc(&self.ws, u8, true), // INCk
0x82 => pop(&self.ws, u8, true), // POPk
0x83 => nip(&self.ws, u8, true), // NIPk
0x84 => swp(&self.ws, u8, true), // SWPk
0x85 => rot(&self.ws, u8, true), // ROTk
0x86 => dup(&self.ws, u8, true), // DUPk
0x87 => ovr(&self.ws, u8, true), // OVRk
0x88 => equ(&self.ws, u8, true), // EQUk
0x89 => neq(&self.ws, u8, true), // NEQk
0x8A => gth(&self.ws, u8, true), // GTHk
0x8B => lth(&self.ws, u8, true), // LTHk
0x8C => self.jmp(&self.ws, u8, true), // JMPk
0x8D => self.jcn(&self.ws, u8, true), // JCNk
0x8E => self.jsr(&self.ws, u8, true), // JSRk
0x8F => self.sth(false, u8, true), // STHk
0x90 => self.ldz(&self.ws, u8, true), // LDZk
0x91 => self.stz(&self.ws, u8, true), // STZk
0x92 => self.ldr(&self.ws, u8, true), // LDRk
0x93 => self.str(&self.ws, u8, true), // STRk
0x94 => self.lda(&self.ws, u8, true), // LDAk
0x95 => self.sta(&self.ws, u8, true), // STAk
0x96 => dei(&self.ws, u8, true), // DEIk
0x97 => deo(&self.ws, u8, true), // DEOk
0x98 => add(&self.ws, u8, true), // ADDk
0x99 => sub(&self.ws, u8, true), // SUBk
0x9A => mul(&self.ws, u8, true), // MULk
0x9B => div(&self.ws, u8, true), // DIVk
0x9C => @"and"(&self.ws, u8, true), // ANDk
0x9D => ora(&self.ws, u8, true), // ORAk
0x9E => eor(&self.ws, u8, true), // EORk
0x9F => sft(&self.ws, u8, true), // SFTk
0xA0 => {}, // LIT2
0xA1 => inc(&self.ws, u16, true), // INC2k
0xA2 => pop(&self.ws, u16, true), // POP2k
0xA3 => nip(&self.ws, u16, true), // NIP2k
0xA4 => swp(&self.ws, u16, true), // SWP2k
0xA5 => rot(&self.ws, u16, true), // ROT2k
0xA6 => dup(&self.ws, u16, true), // DUP2k
0xA7 => ovr(&self.ws, u16, true), // OVR2k
0xA8 => equ(&self.ws, u16, true), // EQU2k
0xA9 => neq(&self.ws, u16, true), // NEQ2k
0xAA => gth(&self.ws, u16, true), // GTH2k
0xAB => lth(&self.ws, u16, true), // LTH2k
0xAC => self.jmp(&self.ws, u16, true), // JMP2k
0xAD => self.jcn(&self.ws, u16, true), // JCN2k
0xAE => self.jsr(&self.ws, u16, true), // JSR2k
0xAF => self.sth(false, u16, true), // STH2k
0xB0 => self.ldz(&self.ws, u16, true), // LDZ2k
0xB1 => self.stz(&self.ws, u16, true), // STZ2k
0xB2 => self.ldr(&self.ws, u16, true), // LDR2k
0xB3 => self.str(&self.ws, u16, true), // STR2k
0xB4 => self.lda(&self.ws, u16, true), // LDA2k
0xB5 => self.sta(&self.ws, u16, true), // STA2k
0xB6 => dei(&self.ws, u16, true), // DEI2k
0xB7 => deo(&self.ws, u16, true), // DEO2k
0xB8 => add(&self.ws, u16, true), // ADD2k
0xB9 => sub(&self.ws, u16, true), // SUB2k
0xBA => mul(&self.ws, u16, true), // MUL2k
0xBB => div(&self.ws, u16, true), // DIV2k
0xBC => @"and"(&self.ws, u16, true), // AND2k
0xBD => ora(&self.ws, u16, true), // ORA2k
0xBE => eor(&self.ws, u16, true), // EOR2k
0xBF => sft(&self.ws, u16, true), // SFT2k
0xC0 => {}, // LITr
0xC1 => inc(&self.rs, u8, true), // INCkr
0xC2 => pop(&self.rs, u8, true), // POPkr
0xC3 => nip(&self.rs, u8, true), // NIPkr
0xC4 => swp(&self.rs, u8, true), // SWPkr
0xC5 => rot(&self.rs, u8, true), // ROTkr
0xC6 => dup(&self.rs, u8, true), // DUPkr
0xC7 => ovr(&self.rs, u8, true), // OVRkr
0xC8 => equ(&self.rs, u8, true), // EQUkr
0xC9 => neq(&self.rs, u8, true), // NEQkr
0xCA => gth(&self.rs, u8, true), // GTHkr
0xCB => lth(&self.rs, u8, true), // LTHkr
0xCC => self.jmp(&self.rs, u8, true), // JMPkr
0xCD => self.jcn(&self.rs, u8, true), // JCNkr
0xCE => self.jsr(&self.rs, u8, true), // JSRkr
0xCF => self.sth(true, u8, true), // STHkr
0xD0 => self.ldz(&self.rs, u8, true), // LDZkr
0xD1 => self.stz(&self.rs, u8, true), // STZkr
0xD2 => self.ldr(&self.rs, u8, true), // LDRkr
0xD3 => self.str(&self.rs, u8, true), // STRkr
0xD4 => self.lda(&self.rs, u8, true), // LDAkr
0xD5 => self.sta(&self.rs, u8, true), // STAkr
0xD6 => dei(&self.rs, u8, true), // DEIkr
0xD7 => deo(&self.rs, u8, true), // DEOkr
0xD8 => add(&self.rs, u8, true), // ADDkr
0xD9 => sub(&self.rs, u8, true), // SUBkr
0xDA => mul(&self.rs, u8, true), // MULkr
0xDB => div(&self.rs, u8, true), // DIVkr
0xDC => @"and"(&self.rs, u8, true), // ANDkr
0xDD => ora(&self.rs, u8, true), // ORAkr
0xDE => eor(&self.rs, u8, true), // EORkr
0xDF => sft(&self.rs, u8, true), // SFTkr
0xE0 => {}, // LIT2r
0xE1 => inc(&self.rs, u16, true), // INC2kr
0xE2 => pop(&self.rs, u16, true), // POP2kr
0xE3 => nip(&self.rs, u16, true), // NIP2kr
0xE4 => swp(&self.rs, u16, true), // SWP2kr
0xE5 => rot(&self.rs, u16, true), // ROT2kr
0xE6 => dup(&self.rs, u16, true), // DUP2kr
0xE7 => ovr(&self.rs, u16, true), // OVR2kr
0xE8 => equ(&self.rs, u16, true), // EQU2kr
0xE9 => neq(&self.rs, u16, true), // NEQ2kr
0xEA => gth(&self.rs, u16, true), // GTH2kr
0xEB => lth(&self.rs, u16, true), // LTH2kr
0xEC => self.jmp(&self.rs, u16, true), // JMP2kr
0xED => self.jcn(&self.rs, u16, true), // JCN2kr
0xEE => self.jsr(&self.rs, u16, true), // JSR2kr
0xEF => self.sth(true, u16, true), // STH2kr
0xF0 => self.ldz(&self.rs, u16, true), // LDZ2kr
0xF1 => self.stz(&self.rs, u16, true), // STZ2kr
0xF2 => self.ldr(&self.rs, u16, true), // LDR2kr
0xF3 => self.str(&self.rs, u16, true), // STR2kr
0xF4 => self.lda(&self.rs, u16, true), // LDA2kr
0xF5 => self.sta(&self.rs, u16, true), // STA2kr
0xF6 => dei(&self.rs, u16, true), // DEI2kr
0xF7 => deo(&self.rs, u16, true), // DEO2kr
0xF8 => add(&self.rs, u16, true), // ADD2kr
0xF9 => sub(&self.rs, u16, true), // SUB2kr
0xFA => mul(&self.rs, u16, true), // MUL2kr
0xFB => div(&self.rs, u16, true), // DIV2kr
0xFC => @"and"(&self.rs, u16, true), // AND2kr
0xFD => ora(&self.rs, u16, true), // ORA2kr
0xFE => eor(&self.rs, u16, true), // EOR2kr
0xFF => sft(&self.rs, u16, true), // SFT2kr
}
self.pc +%= 1;
}
fn brk() void {}
fn inc(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a +% 1);
}
fn pop(stack: *Stack, comptime T: type, comptime keep: bool) void {
if (keep) return;
_ = stack.pop(T);
}
fn nip(stack: *Stack, comptime T: type, comptime keep: bool) void {
_ = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
}
fn swp(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
stack.push(T, a);
}
fn rot(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
const c = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
stack.push(T, c);
stack.push(T, a);
}
fn dup(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a);
}
fn ovr(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a);
stack.push(T, b);
stack.push(T, a);
}
fn equ(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a == b) stack.push(T, 1) else stack.push(T, 0);
}
fn neq(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a != b) stack.push(T, 1) else stack.push(T, 0);
}
fn gth(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a > b) stack.push(T, 1) else stack.push(T, 0);
}
fn lth(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a < b) stack.push(T, 1) else stack.push(T, 0);
}
fn jmp(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn jcn(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const cond = if (keep) stack.peek(T) else stack.pop(T);
const addr = if (keep) stack.peek(T) else stack.pop(T);
if (cond == 0) return;
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn jsr(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
self.rs.push(u16, self.pc);
const addr = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn sth(self: *Uxn, comptime swap: bool, comptime T: type, comptime keep: bool) void {
var src = if (swap) self.rs else self.ws;
var dst = if (swap) self.ws else self.rs;
const a = if (keep) src.peek(T) else src.pop(T);
dst.push(T, a);
}
fn ldz(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
stack.push(T, self.mem.peek(T, addr));
}
fn stz(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, addr, val);
}
fn ldr(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = self.mem.peek(T, @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @intCast(addr))));
stack.push(T, val);
}
fn str(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))), val);
}
fn lda(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u16) else stack.pop(u16);
stack.push(T, self.mem.peek(T, addr));
}
fn sta(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u16) else stack.pop(u16);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, addr, val);
}
fn dei(stack: *Stack, comptime T: type, comptime keep: bool) void {
_ = stack;
_ = T;
_ = keep;
}
fn deo(stack: *Stack, comptime T: type, comptime keep: bool) void {
_ = stack;
_ = T;
_ = keep;
}
fn add(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a +% b);
}
fn sub(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a -% b);
}
fn mul(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a *% b);
}
fn div(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a / b);
}
fn @"and"(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a & b);
}
fn ora(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a | b);
}
fn eor(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a ^ b);
}
fn sft(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => {
const right: u3 = @truncate(b & 0b00001111);
const left: u3 = @truncate((b & 0b11110000) >> 4);
stack.push(T, (a >> right) << left);
},
u16 => {
const right: u4 = @truncate(b & 0b0000000011111111);
const left: u4 = @truncate((b & 0b1111111100000000) >> 8);
stack.push(T, (a >> right) << left);
},
else => unreachable,
}
}
};
test "memory peek/poke" {
var mem = Uxn.Memory{ .m = undefined };
mem.poke(u16, 0, 0xABCD);
mem.poke(u8, 2, 0xAA);
try std.testing.expectEqual(0xABCD, mem.peek(u16, 0));
try std.testing.expectEqual(0xAA, mem.peek(u8, 2));
}
test "stack push/pop" {
var stack = Uxn.Stack{ .s = undefined };
stack.push(u16, 0xABCD);
stack.push(u8, 0xAA);
try std.testing.expectEqual(0xAA, stack.pop(u8));
try std.testing.expectEqual(0xABCD, stack.pop(u16));
}
// test "arithmetic instructions" {
// var uxn = Uxn{
// .mem = .{ .m = undefined },
// .ws = .{ .s = undefined },
// .rs = .{ .s = undefined },
// .pc = 0,
// };
// uxn.mem.m[0] = 0x18;
// uxn.mem.m[1] = 0x19;
// uxn.mem.m[2] = 0x1A;
// uxn.mem.m[3] = 0x1B;
// uxn.ws.push(u8, 4);
// uxn.ws.push(u8, 20);
// uxn.ws.push(u8, 6);
// uxn.loop();
// uxn.loop();
// try std.testing.expectEqual(18, uxn.ws.pop(u8));
// }

609
src/uxn.zig Normal file
View file

@ -0,0 +1,609 @@
const std = @import("std");
const Uxn = @This();
mem: Memory = .{ .m = undefined },
ws: Stack = .{ .s = undefined },
rs: Stack = .{ .s = undefined },
dev: [0x100]u8 = undefined,
pc: u16,
const Memory = struct {
m: [0x10000]u8,
pub fn peek(self: *Memory, comptime T: type, idx: u16) T {
return switch (T) {
u8 => self.m[idx],
u16 => @as(u16, @intCast(self.m[idx])) << 8 | self.m[idx +% 1],
else => unreachable,
};
}
pub fn poke(self: *Memory, comptime T: type, idx: u16, val: T) void {
switch (T) {
u8 => self.m[idx] = val,
u16 => {
self.m[idx] = @truncate(val >> 8);
self.m[idx +% 1] = @truncate(val & 0xFF);
},
else => unreachable,
}
}
};
const Stack = struct {
s: [0x100]u8,
sp: u8 = 0,
pub fn peek(self: *Stack, comptime T: type) T {
return switch (T) {
u8 => self.s[self.sp],
u16 => @as(u16, @intCast(self.s[self.sp])) << 8 | self.s[self.sp +% 1],
else => unreachable,
};
}
pub fn poke(self: *Stack, comptime T: type, v: T) void {
switch (T) {
u8 => self.s[self.sp] = v,
u16 => {
self.s[self.sp] = @truncate(v >> 8);
self.s[self.sp +% 1] = @truncate(v & 0xFF);
},
else => unreachable,
}
}
pub fn pop(self: *Stack, comptime T: type) T {
self.sp -%= @intCast(@divExact(@typeInfo(T).Int.bits, 8));
return self.peek(T);
}
pub fn push(self: *Stack, comptime T: type, v: T) void {
self.poke(T, v);
self.sp +%= @intCast(@divExact(@typeInfo(T).Int.bits, 8));
}
};
pub fn eval(self: *Uxn) bool {
switch (self.mem.m[self.pc]) {
0x00 => return true, // BRK
0x01 => inc(&self.ws, u8, false), // INC
0x02 => pop(&self.ws, u8, false), // POP
0x03 => nip(&self.ws, u8, false), // NIP
0x04 => swp(&self.ws, u8, false), // SWP
0x05 => rot(&self.ws, u8, false), // ROT
0x06 => dup(&self.ws, u8, false), // DUP
0x07 => ovr(&self.ws, u8, false), // OVR
0x08 => equ(&self.ws, u8, false), // EQU
0x09 => neq(&self.ws, u8, false), // NEQ
0x0A => gth(&self.ws, u8, false), // GTH
0x0B => lth(&self.ws, u8, false), // LTH
0x0C => self.jmp(&self.ws, u8, false), // JMP
0x0D => self.jcn(&self.ws, u8, false), // JCN
0x0E => self.jsr(&self.ws, u8, false), // JSR
0x0F => self.sth(false, u8, false), // STH
0x10 => self.ldz(&self.ws, u8, false), // LDZ
0x11 => self.stz(&self.ws, u8, false), // STZ
0x12 => self.ldr(&self.ws, u8, false), // LDR
0x13 => self.str(&self.ws, u8, false), // STR
0x14 => self.lda(&self.ws, u8, false), // LDA
0x15 => self.sta(&self.ws, u8, false), // STA
0x16 => self.dei(&self.ws, u8, false), // DEI
0x17 => self.deo(&self.ws, u8, false), // DEO
0x18 => add(&self.ws, u8, false), // ADD
0x19 => sub(&self.ws, u8, false), // SUB
0x1A => mul(&self.ws, u8, false), // MUL
0x1B => div(&self.ws, u8, false), // DIV
0x1C => @"and"(&self.ws, u8, false), // AND
0x1D => ora(&self.ws, u8, false), // ORA
0x1E => eor(&self.ws, u8, false), // EOR
0x1F => sft(&self.ws, u8, false), // SFT
0x20 => {}, // JCI
0x21 => inc(&self.ws, u16, false), // INC2
0x22 => pop(&self.ws, u16, false), // POP2
0x23 => nip(&self.ws, u16, false), // NIP2
0x24 => swp(&self.ws, u16, false), // SWP2
0x25 => rot(&self.ws, u16, false), // ROT2
0x26 => dup(&self.ws, u16, false), // DUP2
0x27 => ovr(&self.ws, u16, false), // OVR2
0x28 => equ(&self.ws, u16, false), // EQU2
0x29 => neq(&self.ws, u16, false), // NEQ2
0x2A => gth(&self.ws, u16, false), // GTH2
0x2B => lth(&self.ws, u16, false), // LTH2
0x2C => self.jmp(&self.ws, u16, false), // JMP2
0x2D => self.jcn(&self.ws, u16, false), // JCN2
0x2E => self.jsr(&self.ws, u16, false), // JSR2
0x2F => self.sth(false, u16, false), // STH2
0x30 => self.ldz(&self.ws, u16, false), // LDZ2
0x31 => self.stz(&self.ws, u16, false), // STZ2
0x32 => self.ldr(&self.ws, u16, false), // LDR2
0x33 => self.str(&self.ws, u16, false), // STR2
0x34 => self.lda(&self.ws, u16, false), // LDA2
0x35 => self.sta(&self.ws, u16, false), // STA2
0x36 => self.dei(&self.ws, u16, false), // DEI2
0x37 => self.deo(&self.ws, u16, false), // DEO2
0x38 => add(&self.ws, u16, false), // ADD2
0x39 => sub(&self.ws, u16, false), // SUB2
0x3A => mul(&self.ws, u16, false), // MUL2
0x3B => div(&self.ws, u16, false), // DIV2
0x3C => @"and"(&self.ws, u16, false), // AND2
0x3D => ora(&self.ws, u16, false), // ORA2
0x3E => eor(&self.ws, u16, false), // EOR2
0x3F => sft(&self.ws, u16, false), // SFT2
0x40 => {}, // JMI
0x41 => inc(&self.rs, u8, false), // INCr
0x42 => pop(&self.rs, u8, false), // POPr
0x43 => nip(&self.rs, u8, false), // NIPr
0x44 => swp(&self.rs, u8, false), // SWPr
0x45 => rot(&self.rs, u8, false), // ROTr
0x46 => dup(&self.rs, u8, false), // DUPr
0x47 => ovr(&self.rs, u8, false), // OVRr
0x48 => equ(&self.rs, u8, false), // EQUr
0x49 => neq(&self.rs, u8, false), // NEQr
0x4A => gth(&self.rs, u8, false), // GTHr
0x4B => lth(&self.rs, u8, false), // LTHr
0x4C => self.jmp(&self.rs, u8, false), // JMPr
0x4D => self.jcn(&self.rs, u8, false), // JCNr
0x4E => self.jsr(&self.rs, u8, false), // JSRr
0x4F => self.sth(true, u8, false), // STHr
0x50 => self.ldz(&self.rs, u8, false), // LDZr
0x51 => self.stz(&self.rs, u8, false), // STZr
0x52 => self.ldr(&self.rs, u8, false), // LDRr
0x53 => self.str(&self.rs, u8, false), // STRr
0x54 => self.lda(&self.rs, u8, false), // LDAr
0x55 => self.sta(&self.rs, u8, false), // STAr
0x56 => self.dei(&self.rs, u8, false), // DEIr
0x57 => self.deo(&self.rs, u8, false), // DEOr
0x58 => add(&self.rs, u8, false), // ADDr
0x59 => sub(&self.rs, u8, false), // SUBr
0x5A => mul(&self.rs, u8, false), // MULr
0x5B => div(&self.rs, u8, false), // DIVr
0x5C => @"and"(&self.rs, u8, false), // ANDr
0x5D => ora(&self.rs, u8, false), // ORAr
0x5E => eor(&self.rs, u8, false), // EORr
0x5F => sft(&self.rs, u8, false), // SFTr
0x60 => {
self.rs.push(u16, self.pc +% 2);
self.pc +%= 2 + self.mem.peek(u16, self.pc +% 1);
}, // JSI
0x61 => inc(&self.rs, u16, false), // INC2r
0x62 => pop(&self.rs, u16, false), // POP2r
0x63 => nip(&self.rs, u16, false), // NIP2r
0x64 => swp(&self.rs, u16, false), // SWP2r
0x65 => rot(&self.rs, u16, false), // ROT2r
0x66 => dup(&self.rs, u16, false), // DUP2r
0x67 => ovr(&self.rs, u16, false), // OVR2r
0x68 => equ(&self.rs, u16, false), // EQU2r
0x69 => neq(&self.rs, u16, false), // NEQ2r
0x6A => gth(&self.rs, u16, false), // GTH2r
0x6B => lth(&self.rs, u16, false), // LTH2r
0x6C => self.jmp(&self.rs, u16, false), // JMP2r
0x6D => self.jcn(&self.rs, u16, false), // JCN2r
0x6E => self.jsr(&self.rs, u16, false), // JSR2r
0x6F => self.sth(true, u16, false), // STH2r
0x70 => self.ldz(&self.rs, u16, false), // LDZ2r
0x71 => self.stz(&self.rs, u16, false), // STZ2r
0x72 => self.ldr(&self.rs, u16, false), // LDR2r
0x73 => self.str(&self.rs, u16, false), // STR2r
0x74 => self.lda(&self.rs, u16, false), // LDA2r
0x75 => self.sta(&self.rs, u16, false), // STA2r
0x76 => self.dei(&self.rs, u16, false), // DEI2r
0x77 => self.deo(&self.rs, u16, false), // DEO2r
0x78 => add(&self.rs, u16, false), // ADD2r
0x79 => sub(&self.rs, u16, false), // SUB2r
0x7A => mul(&self.rs, u16, false), // MUL2r
0x7B => div(&self.rs, u16, false), // DIV2r
0x7C => @"and"(&self.rs, u16, false), // AND2r
0x7D => ora(&self.rs, u16, false), // ORA2r
0x7E => eor(&self.rs, u16, false), // EOR2r
0x7F => sft(&self.rs, u16, false), // SFT2r
0x80 => {
self.ws.push(u8, self.mem.m[self.pc +% 1]);
self.pc +%= 1;
}, // LIT
0x81 => inc(&self.ws, u8, true), // INCk
0x82 => pop(&self.ws, u8, true), // POPk
0x83 => nip(&self.ws, u8, true), // NIPk
0x84 => swp(&self.ws, u8, true), // SWPk
0x85 => rot(&self.ws, u8, true), // ROTk
0x86 => dup(&self.ws, u8, true), // DUPk
0x87 => ovr(&self.ws, u8, true), // OVRk
0x88 => equ(&self.ws, u8, true), // EQUk
0x89 => neq(&self.ws, u8, true), // NEQk
0x8A => gth(&self.ws, u8, true), // GTHk
0x8B => lth(&self.ws, u8, true), // LTHk
0x8C => self.jmp(&self.ws, u8, true), // JMPk
0x8D => self.jcn(&self.ws, u8, true), // JCNk
0x8E => self.jsr(&self.ws, u8, true), // JSRk
0x8F => self.sth(false, u8, true), // STHk
0x90 => self.ldz(&self.ws, u8, true), // LDZk
0x91 => self.stz(&self.ws, u8, true), // STZk
0x92 => self.ldr(&self.ws, u8, true), // LDRk
0x93 => self.str(&self.ws, u8, true), // STRk
0x94 => self.lda(&self.ws, u8, true), // LDAk
0x95 => self.sta(&self.ws, u8, true), // STAk
0x96 => self.dei(&self.ws, u8, true), // DEIk
0x97 => self.deo(&self.ws, u8, true), // DEOk
0x98 => add(&self.ws, u8, true), // ADDk
0x99 => sub(&self.ws, u8, true), // SUBk
0x9A => mul(&self.ws, u8, true), // MULk
0x9B => div(&self.ws, u8, true), // DIVk
0x9C => @"and"(&self.ws, u8, true), // ANDk
0x9D => ora(&self.ws, u8, true), // ORAk
0x9E => eor(&self.ws, u8, true), // EORk
0x9F => sft(&self.ws, u8, true), // SFTk
0xA0 => {
self.ws.push(u16, self.mem.m[self.pc +% 1]);
self.pc +%= 2;
}, // LIT2
0xA1 => inc(&self.ws, u16, true), // INC2k
0xA2 => pop(&self.ws, u16, true), // POP2k
0xA3 => nip(&self.ws, u16, true), // NIP2k
0xA4 => swp(&self.ws, u16, true), // SWP2k
0xA5 => rot(&self.ws, u16, true), // ROT2k
0xA6 => dup(&self.ws, u16, true), // DUP2k
0xA7 => ovr(&self.ws, u16, true), // OVR2k
0xA8 => equ(&self.ws, u16, true), // EQU2k
0xA9 => neq(&self.ws, u16, true), // NEQ2k
0xAA => gth(&self.ws, u16, true), // GTH2k
0xAB => lth(&self.ws, u16, true), // LTH2k
0xAC => self.jmp(&self.ws, u16, true), // JMP2k
0xAD => self.jcn(&self.ws, u16, true), // JCN2k
0xAE => self.jsr(&self.ws, u16, true), // JSR2k
0xAF => self.sth(false, u16, true), // STH2k
0xB0 => self.ldz(&self.ws, u16, true), // LDZ2k
0xB1 => self.stz(&self.ws, u16, true), // STZ2k
0xB2 => self.ldr(&self.ws, u16, true), // LDR2k
0xB3 => self.str(&self.ws, u16, true), // STR2k
0xB4 => self.lda(&self.ws, u16, true), // LDA2k
0xB5 => self.sta(&self.ws, u16, true), // STA2k
0xB6 => self.dei(&self.ws, u16, true), // DEI2k
0xB7 => self.deo(&self.ws, u16, true), // DEO2k
0xB8 => add(&self.ws, u16, true), // ADD2k
0xB9 => sub(&self.ws, u16, true), // SUB2k
0xBA => mul(&self.ws, u16, true), // MUL2k
0xBB => div(&self.ws, u16, true), // DIV2k
0xBC => @"and"(&self.ws, u16, true), // AND2k
0xBD => ora(&self.ws, u16, true), // ORA2k
0xBE => eor(&self.ws, u16, true), // EOR2k
0xBF => sft(&self.ws, u16, true), // SFT2k
0xC0 => {
self.rs.push(u8, self.mem.m[self.pc +% 1]);
self.pc +%= 1;
}, // LITr
0xC1 => inc(&self.rs, u8, true), // INCkr
0xC2 => pop(&self.rs, u8, true), // POPkr
0xC3 => nip(&self.rs, u8, true), // NIPkr
0xC4 => swp(&self.rs, u8, true), // SWPkr
0xC5 => rot(&self.rs, u8, true), // ROTkr
0xC6 => dup(&self.rs, u8, true), // DUPkr
0xC7 => ovr(&self.rs, u8, true), // OVRkr
0xC8 => equ(&self.rs, u8, true), // EQUkr
0xC9 => neq(&self.rs, u8, true), // NEQkr
0xCA => gth(&self.rs, u8, true), // GTHkr
0xCB => lth(&self.rs, u8, true), // LTHkr
0xCC => self.jmp(&self.rs, u8, true), // JMPkr
0xCD => self.jcn(&self.rs, u8, true), // JCNkr
0xCE => self.jsr(&self.rs, u8, true), // JSRkr
0xCF => self.sth(true, u8, true), // STHkr
0xD0 => self.ldz(&self.rs, u8, true), // LDZkr
0xD1 => self.stz(&self.rs, u8, true), // STZkr
0xD2 => self.ldr(&self.rs, u8, true), // LDRkr
0xD3 => self.str(&self.rs, u8, true), // STRkr
0xD4 => self.lda(&self.rs, u8, true), // LDAkr
0xD5 => self.sta(&self.rs, u8, true), // STAkr
0xD6 => self.dei(&self.rs, u8, true), // DEIkr
0xD7 => self.deo(&self.rs, u8, true), // DEOkr
0xD8 => add(&self.rs, u8, true), // ADDkr
0xD9 => sub(&self.rs, u8, true), // SUBkr
0xDA => mul(&self.rs, u8, true), // MULkr
0xDB => div(&self.rs, u8, true), // DIVkr
0xDC => @"and"(&self.rs, u8, true), // ANDkr
0xDD => ora(&self.rs, u8, true), // ORAkr
0xDE => eor(&self.rs, u8, true), // EORkr
0xDF => sft(&self.rs, u8, true), // SFTkr
0xE0 => {
self.rs.push(u16, self.mem.m[self.pc +% 1]);
self.pc +%= 2;
}, // LIT2r
0xE1 => inc(&self.rs, u16, true), // INC2kr
0xE2 => pop(&self.rs, u16, true), // POP2kr
0xE3 => nip(&self.rs, u16, true), // NIP2kr
0xE4 => swp(&self.rs, u16, true), // SWP2kr
0xE5 => rot(&self.rs, u16, true), // ROT2kr
0xE6 => dup(&self.rs, u16, true), // DUP2kr
0xE7 => ovr(&self.rs, u16, true), // OVR2kr
0xE8 => equ(&self.rs, u16, true), // EQU2kr
0xE9 => neq(&self.rs, u16, true), // NEQ2kr
0xEA => gth(&self.rs, u16, true), // GTH2kr
0xEB => lth(&self.rs, u16, true), // LTH2kr
0xEC => self.jmp(&self.rs, u16, true), // JMP2kr
0xED => self.jcn(&self.rs, u16, true), // JCN2kr
0xEE => self.jsr(&self.rs, u16, true), // JSR2kr
0xEF => self.sth(true, u16, true), // STH2kr
0xF0 => self.ldz(&self.rs, u16, true), // LDZ2kr
0xF1 => self.stz(&self.rs, u16, true), // STZ2kr
0xF2 => self.ldr(&self.rs, u16, true), // LDR2kr
0xF3 => self.str(&self.rs, u16, true), // STR2kr
0xF4 => self.lda(&self.rs, u16, true), // LDA2kr
0xF5 => self.sta(&self.rs, u16, true), // STA2kr
0xF6 => self.dei(&self.rs, u16, true), // DEI2kr
0xF7 => self.deo(&self.rs, u16, true), // DEO2kr
0xF8 => add(&self.rs, u16, true), // ADD2kr
0xF9 => sub(&self.rs, u16, true), // SUB2kr
0xFA => mul(&self.rs, u16, true), // MUL2kr
0xFB => div(&self.rs, u16, true), // DIV2kr
0xFC => @"and"(&self.rs, u16, true), // AND2kr
0xFD => ora(&self.rs, u16, true), // ORA2kr
0xFE => eor(&self.rs, u16, true), // EOR2kr
0xFF => sft(&self.rs, u16, true), // SFT2kr
}
self.pc +%= 1;
return false;
}
fn brk() void {}
fn inc(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a +% 1);
}
fn pop(stack: *Stack, comptime T: type, comptime keep: bool) void {
if (keep) return;
_ = stack.pop(T);
}
fn nip(stack: *Stack, comptime T: type, comptime keep: bool) void {
_ = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
}
fn swp(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
stack.push(T, a);
}
fn rot(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
const c = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, b);
stack.push(T, c);
stack.push(T, a);
}
fn dup(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a);
}
fn ovr(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a);
stack.push(T, b);
stack.push(T, a);
}
fn equ(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a == b) stack.push(T, 1) else stack.push(T, 0);
}
fn neq(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a != b) stack.push(T, 1) else stack.push(T, 0);
}
fn gth(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a > b) stack.push(T, 1) else stack.push(T, 0);
}
fn lth(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
if (a < b) stack.push(T, 1) else stack.push(T, 0);
}
fn jmp(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn jcn(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const cond = if (keep) stack.peek(T) else stack.pop(T);
const addr = if (keep) stack.peek(T) else stack.pop(T);
if (cond == 0) return;
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn jsr(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
self.rs.push(u16, self.pc);
const addr = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => self.pc = @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))),
u16 => self.pc = addr,
else => unreachable,
}
}
fn sth(self: *Uxn, comptime swap: bool, comptime T: type, comptime keep: bool) void {
var src = if (swap) self.rs else self.ws;
var dst = if (swap) self.ws else self.rs;
const a = if (keep) src.peek(T) else src.pop(T);
dst.push(T, a);
}
fn ldz(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
stack.push(T, self.mem.peek(T, addr));
}
fn stz(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, addr, val);
}
fn ldr(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = self.mem.peek(T, @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @intCast(addr))));
stack.push(T, val);
}
fn str(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u8) else stack.pop(u8);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, @intCast(@as(i32, @intCast(self.pc)) + @as(i8, @bitCast(addr))), val);
}
fn lda(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u16) else stack.pop(u16);
stack.push(T, self.mem.peek(T, addr));
}
fn sta(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const addr = if (keep) stack.peek(u16) else stack.pop(u16);
const val = if (keep) stack.peek(T) else stack.pop(T);
self.mem.poke(T, addr, val);
}
fn dei(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const d = if (keep) stack.peek(u8) else stack.pop(u8);
stack.push(T, self.dev[d]);
}
fn deo(self: *Uxn, stack: *Stack, comptime T: type, comptime keep: bool) void {
const d = if (keep) stack.peek(u8) else stack.pop(u8);
const v = if (keep) stack.peek(T) else stack.pop(T);
std.debug.print("DEO: v{X} d{X}\n", .{ v, d });
switch (T) {
u8 => self.dev[d] = v,
u16 => {
self.dev[d] = @truncate(v >> 8);
self.dev[d +% 1] = @truncate(v & 0xFF);
},
else => unreachable,
}
}
fn add(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a +% b);
}
fn sub(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a -% b);
}
fn mul(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a *% b);
}
fn div(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a / b);
}
fn @"and"(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a & b);
}
fn ora(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a | b);
}
fn eor(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
stack.push(T, a ^ b);
}
fn sft(stack: *Stack, comptime T: type, comptime keep: bool) void {
const a = if (keep) stack.peek(T) else stack.pop(T);
const b = if (keep) stack.peek(T) else stack.pop(T);
switch (T) {
u8 => {
const right: u3 = @truncate(b & 0b00001111);
const left: u3 = @truncate((b & 0b11110000) >> 4);
stack.push(T, (a >> right) << left);
},
u16 => {
const right: u4 = @truncate(b & 0b0000000011111111);
const left: u4 = @truncate((b & 0b1111111100000000) >> 8);
stack.push(T, (a >> right) << left);
},
else => unreachable,
}
}
// TODO move the mem/stack to just below their respective definitions
test "memory peek/poke" {
var mem = Memory{ .m = undefined };
mem.poke(u16, 0, 0xABCD);
mem.poke(u8, 2, 0xAA);
try std.testing.expectEqual(0xABCD, mem.peek(u16, 0));
try std.testing.expectEqual(0xAA, mem.peek(u8, 2));
}
test "stack push/pop" {
var stack = Stack{ .s = undefined };
stack.push(u16, 0xABCD);
stack.push(u8, 0xAA);
try std.testing.expectEqual(0xAA, stack.pop(u8));
try std.testing.expectEqual(0xABCD, stack.pop(u16));
}
// test "arithmetic instructions" {
// var uxn = Uxn{
// .mem = .{ .m = undefined },
// .ws = .{ .s = undefined },
// .rs = .{ .s = undefined },
// .pc = 0,
// };
// uxn.mem.m[0] = 0x18;
// uxn.mem.m[1] = 0x19;
// uxn.mem.m[2] = 0x1A;
// uxn.mem.m[3] = 0x1B;
// uxn.ws.push(u8, 4);
// uxn.ws.push(u8, 20);
// uxn.ws.push(u8, 6);
// uxn.loop();
// uxn.loop();
// try std.testing.expectEqual(18, uxn.ws.pop(u8));
// }