creating uxn implementation without global state.
This commit is contained in:
JJ Bliss
+791
@@ -0,0 +1,791 @@
|
||||
use fmt;
|
||||
use os;
|
||||
use fs;
|
||||
use io;
|
||||
use strings;
|
||||
|
||||
// let console_vector: u16 = 0;
|
||||
// let ram: [0x10000] u8 = [0...];
|
||||
// let dev: [0x100] u8 = [0...];
|
||||
// let ptr: [2] u8 = [0...];
|
||||
// let stk: [2][0x100] u8 = [[0...],[0...]];
|
||||
|
||||
type uxn = struct {
|
||||
pc: u16,
|
||||
console_vector: u16,
|
||||
ram: [0x10000] u8,
|
||||
dev: [0x100] u8,
|
||||
ptr: [2] u8,
|
||||
stk: [2][0x100] u8,
|
||||
};
|
||||
|
||||
fn initialize_uxn_mem() *uxn = {
|
||||
return alloc(uxn{
|
||||
pc = 0x0100,
|
||||
console_vector = 0,
|
||||
ram = [0...],
|
||||
dev = [0...],
|
||||
ptr = [0...],
|
||||
stk = [[0...],[0...]]
|
||||
})!;
|
||||
};
|
||||
|
||||
fn emu_dei(port: u8, state: *uxn) u8 = {
|
||||
let val = state.dev[port];
|
||||
// fmt::printfln("Read {:x} from port {:x}", val, port)!;
|
||||
return val;
|
||||
};
|
||||
|
||||
|
||||
fn emu_deo(port: u8, value: u8, state: *uxn) void = {
|
||||
// fmt::printfln("Writing {:x} to port {:x}", value, port)!;
|
||||
state.dev[port] = value;
|
||||
switch(port) {
|
||||
case 0x11 =>
|
||||
let high = state.dev[0x10];
|
||||
let low = value;
|
||||
state.console_vector = short_from_bytes(high,low);
|
||||
// fmt::printfln("Setting console_vector to: {:x}", console_vector)!;
|
||||
return;
|
||||
case 0x18 =>
|
||||
fmt::print(value: rune)!;
|
||||
return;
|
||||
case 0x19 =>
|
||||
fmt::error(value)!;
|
||||
return;
|
||||
case =>
|
||||
return;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
type evalerror = !void;
|
||||
type unhandled = !u8;
|
||||
|
||||
type error = !(evalerror | unhandled);
|
||||
|
||||
type simple_op = void;
|
||||
type literal_op = struct { short: bool, ret: bool};
|
||||
type normal_op = struct { short: bool, keep: bool, ret: bool};
|
||||
|
||||
type BRK = simple_op;
|
||||
type JCI = simple_op;
|
||||
type JMI = simple_op;
|
||||
type JSI = simple_op;
|
||||
type LIT = literal_op;
|
||||
type INC = normal_op;
|
||||
type POP = normal_op;
|
||||
type NIP = normal_op;
|
||||
type SWP = normal_op;
|
||||
type ROT = normal_op;
|
||||
type DUP = normal_op;
|
||||
type OVR = normal_op;
|
||||
type EQU = normal_op;
|
||||
type NEQ = normal_op;
|
||||
type GTH = normal_op;
|
||||
type LTH = normal_op;
|
||||
type JMP = normal_op;
|
||||
type JCN = normal_op;
|
||||
type JSR = normal_op;
|
||||
type STH = normal_op;
|
||||
type LDZ = normal_op;
|
||||
type STZ = normal_op;
|
||||
type LDR = normal_op;
|
||||
type STR = normal_op;
|
||||
type LDA = normal_op;
|
||||
type STA = normal_op;
|
||||
type DEI = normal_op;
|
||||
type DEO = normal_op;
|
||||
type ADD = normal_op;
|
||||
type SUB = normal_op;
|
||||
type MUL = normal_op;
|
||||
type DIV = normal_op;
|
||||
type AND = normal_op;
|
||||
type ORA = normal_op;
|
||||
type EOR = normal_op;
|
||||
type SFT = normal_op;
|
||||
|
||||
type instruction = (BRK | JCI | JMI | JSI | LIT | INC | POP | NIP | SWP | ROT | DUP | OVR | EQU | NEQ
|
||||
| GTH | LTH | JMP | JCN | JSR | STH | LDZ | STZ | LDR | STR | LDA | STA | DEI
|
||||
| DEO | ADD | SUB | MUL | DIV | AND | ORA | EOR | SFT);
|
||||
|
||||
|
||||
fn get_instruction(byte: u8) (instruction | error) = {
|
||||
let k: bool = (byte & (0b10000000) != 0 );
|
||||
let r: bool = (byte & (0b01000000) != 0 );
|
||||
let s: bool = (byte & (0b00100000) != 0 );
|
||||
let opcode: u8 = byte & (0b00011111);
|
||||
switch(opcode) {
|
||||
case 0x00 =>
|
||||
switch(byte){
|
||||
case 0x00 =>
|
||||
return void: BRK;
|
||||
case 0x20 =>
|
||||
return void: JCI;
|
||||
case 0x40 =>
|
||||
return void: JMI;
|
||||
case 0x60 =>
|
||||
return void: JSI;
|
||||
case 0x80 => // LIT
|
||||
return LIT {short=false, ret=false};
|
||||
case 0xa0 => // LIT2
|
||||
return LIT {short=true, ret=false};
|
||||
case 0xc0 => // LITr
|
||||
return LIT {short=false, ret=true};
|
||||
case 0xe0 => // LIT2r
|
||||
return LIT {short=true, ret=true};
|
||||
case =>
|
||||
return byte: unhandled;
|
||||
};
|
||||
case 0x01 =>
|
||||
return INC {short = s, keep = k, ret = r};
|
||||
case 0x02 =>
|
||||
return POP {short = s, keep = k, ret = r};
|
||||
case 0x03 =>
|
||||
return NIP {short = s, keep = k, ret = r};
|
||||
case 0x04 =>
|
||||
return SWP {short = s, keep = k, ret = r};
|
||||
case 0x05 =>
|
||||
return ROT {short = s, keep = k, ret = r};
|
||||
case 0x06 =>
|
||||
return DUP {short = s, keep = k, ret = r};
|
||||
case 0x07 =>
|
||||
return OVR {short = s, keep = k, ret = r};
|
||||
case 0x08 =>
|
||||
return EQU {short = s, keep = k, ret = r};
|
||||
case 0x09 =>
|
||||
return NEQ {short = s, keep = k, ret = r};
|
||||
case 0x0a =>
|
||||
return GTH {short = s, keep = k, ret = r};
|
||||
case 0x0b =>
|
||||
return LTH {short = s, keep = k, ret = r};
|
||||
case 0x0c =>
|
||||
return JMP {short = s, keep = k, ret = r};
|
||||
case 0x0d =>
|
||||
return JCN {short = s, keep = k, ret = r};
|
||||
case 0x0e =>
|
||||
return JSR {short = s, keep = k, ret = r};
|
||||
case 0x0f =>
|
||||
return STH {short = s, keep = k, ret = r};
|
||||
|
||||
case 0x10 =>
|
||||
return LDZ {short = s, keep = k, ret = r};
|
||||
case 0x11 =>
|
||||
return STZ {short = s, keep = k, ret = r};
|
||||
case 0x12 =>
|
||||
return LDR {short = s, keep = k, ret = r};
|
||||
case 0x13 =>
|
||||
return STR {short = s, keep = k, ret = r};
|
||||
case 0x14 =>
|
||||
return LDA {short = s, keep = k, ret = r};
|
||||
case 0x15 =>
|
||||
return STA {short = s, keep = k, ret = r};
|
||||
case 0x16 =>
|
||||
return DEI {short = s, keep = k, ret = r};
|
||||
case 0x17 =>
|
||||
return DEO {short = s, keep = k, ret = r};
|
||||
case 0x18 =>
|
||||
return ADD {short = s, keep = k, ret = r};
|
||||
case 0x19 =>
|
||||
return SUB {short = s, keep = k, ret = r};
|
||||
case 0x1a =>
|
||||
return MUL {short = s, keep = k, ret = r};
|
||||
case 0x1b =>
|
||||
return DIV {short = s, keep = k, ret = r};
|
||||
case 0x1c =>
|
||||
return AND {short = s, keep = k, ret = r};
|
||||
case 0x1d =>
|
||||
return ORA {short = s, keep = k, ret = r};
|
||||
case 0x1e =>
|
||||
return EOR {short = s, keep = k, ret = r};
|
||||
case 0x1f =>
|
||||
return SFT {short = s, keep = k, ret = r};
|
||||
case =>
|
||||
return byte: unhandled;
|
||||
};
|
||||
};
|
||||
|
||||
fn short_from_bytes(high: u8, low: u8) u16 = {
|
||||
return (high: u16) << 8 | (low: u16);
|
||||
};
|
||||
|
||||
|
||||
fn push_to_stack(ret: bool, val: (u8 | u16), state: *uxn) void = {
|
||||
let stack = switch(ret){
|
||||
case true =>
|
||||
yield 1;
|
||||
case false =>
|
||||
yield 0;
|
||||
};
|
||||
match(val) {
|
||||
case let bval: u8 =>
|
||||
state.stk[stack][state.ptr[stack]] = bval;
|
||||
state.ptr[stack] = state.ptr[stack] + 1;
|
||||
|
||||
case let sval: u16 =>
|
||||
let low: u8 = (sval & 0xFF): u8;
|
||||
let high: u8 = (sval >> 8): u8;
|
||||
state.stk[stack][state.ptr[stack]] = high;
|
||||
state.ptr[stack] = state.ptr[stack] + 1;
|
||||
state.stk[stack][state.ptr[stack]] = low;
|
||||
state.ptr[stack] = state.ptr[stack] + 1;
|
||||
};
|
||||
};
|
||||
|
||||
// Get value from stack, offset 0 is top of stack.
|
||||
fn get_stack_val(ret: bool, short: bool, off: u8, state: *uxn) (u8 | u16) = {
|
||||
let stack = switch(ret){
|
||||
case true =>
|
||||
yield 1;
|
||||
case false =>
|
||||
yield 0;
|
||||
};
|
||||
|
||||
if(!short){
|
||||
let val: u8 = state.stk[stack][state.ptr[stack] - 1 - off];
|
||||
return val;
|
||||
} else {
|
||||
let low: u8 = state.stk[stack][state.ptr[stack]-1 - (off * 2)];
|
||||
let high: u8 = state.stk[stack][state.ptr[stack]-2 - (off * 2)];
|
||||
return short_from_bytes(high,low);
|
||||
};
|
||||
};
|
||||
|
||||
fn increment_stack(ret: bool, short: bool, state: *uxn) void = {
|
||||
let stack = switch(ret){
|
||||
case true =>
|
||||
yield 1;
|
||||
case false =>
|
||||
yield 0;
|
||||
};
|
||||
if(short){
|
||||
state.ptr[stack] = state.ptr[stack] + 2;
|
||||
} else {
|
||||
state.ptr[stack] = state.ptr[stack] + 1;
|
||||
};
|
||||
};
|
||||
fn decrement_stack(ret: bool, short: bool, state: *uxn) void = {
|
||||
let stack = switch(ret){
|
||||
case true =>
|
||||
yield 1;
|
||||
case false =>
|
||||
yield 0;
|
||||
};
|
||||
if(short){
|
||||
state.ptr[stack] = state.ptr[stack] - 2;
|
||||
} else {
|
||||
state.ptr[stack] = state.ptr[stack] - 1;
|
||||
};
|
||||
};
|
||||
|
||||
fn pop_from_stack(keep: bool, ret: bool, short: bool, state: *uxn) (u8 | u16) = {
|
||||
let val = get_stack_val(ret, short, 0, state);
|
||||
if(!keep) decrement_stack(ret, short, state);
|
||||
return val;
|
||||
};
|
||||
|
||||
fn pop_or_get(inst: normal_op, off: u8, state: *uxn) (u8 | u16) = {
|
||||
return switch(inst.keep) {
|
||||
case false =>
|
||||
yield pop_from_stack(false,inst.ret,inst.short,state);
|
||||
case true =>
|
||||
yield get_stack_val(inst.ret,inst.short, off,state);
|
||||
};
|
||||
};
|
||||
fn uxn_eval(new_pc: u16, state: *uxn) (done | error ) = {
|
||||
// let a: u16 = 0, b: u16 = 0, c: u16 = 0, x: [2]u16 = [0...], y: [2]u16 = [0...], z: [2]u16 = [0...];
|
||||
state.pc = new_pc;
|
||||
for(true){
|
||||
// fmt::printfln("Starting eval with pc: {:x}", pc)!;
|
||||
let readval = state.ram[state.pc];
|
||||
let inst: instruction = get_instruction(readval)?;
|
||||
state.pc += 1; //TODO verify all pc changes
|
||||
|
||||
match(inst) {
|
||||
// /* BRK */ case 0x00: return 1;
|
||||
case BRK =>
|
||||
// fmt::println("Break!")!;
|
||||
return done;
|
||||
// /* JCI */ case 0x20: if(DEC(0)) { IMM state.pc += a; } else pc += 2; break;
|
||||
case JCI =>
|
||||
let val: u8 = pop_from_stack(false, false, false, state): u8;
|
||||
if(val != 0) {
|
||||
state.pc += 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO, is this signed?
|
||||
}else{
|
||||
state.pc += 2;
|
||||
};
|
||||
// /* JMI */ case 0x40: IMM pc += a; break;
|
||||
case JMI =>
|
||||
state.pc = state.pc + 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO is this signed?
|
||||
// /* JSI */ case 0x60: IMM PUx(pc, 1, 1) pc += a; break;
|
||||
case JSI =>
|
||||
push_to_stack(true, state.pc + 2, state);
|
||||
state.pc = state.pc + 2 + short_from_bytes(state.ram[state.pc],state.ram[state.pc+1]); //TODO is this signed?
|
||||
|
||||
// /* LIT */ case 0x80: INC(0) = ram[pc++]; break;
|
||||
case let lit_inst: LIT =>
|
||||
push_to_stack(lit_inst.ret, state.ram[state.pc], state);
|
||||
state.pc = state.pc + 1;
|
||||
if(lit_inst.short) {
|
||||
push_to_stack(lit_inst.ret, state.ram[state.pc],state);
|
||||
state.pc = state.pc + 1;
|
||||
};
|
||||
// /* INC */ OPC(0x01,POx(a,d),PUx(a + 1,d,r))
|
||||
case let inc_inst: INC =>
|
||||
let val = match(pop_from_stack(inc_inst.keep,inc_inst.ret,inc_inst.short,state)) {
|
||||
//TODO this whole match statement seems unnecessary
|
||||
case let byte: u8 =>
|
||||
yield byte + 1;
|
||||
case let short: u16 =>
|
||||
yield short + 1;
|
||||
};
|
||||
|
||||
push_to_stack(inc_inst.ret,val,state);
|
||||
// /* POP */ OPC(0x02,ptr[r] -= 1 + d;,{})
|
||||
case let pop_inst: POP =>
|
||||
if(!pop_inst.keep){
|
||||
pop_from_stack(false,pop_inst.ret,pop_inst.short,state);
|
||||
};
|
||||
// /* NIP */ OPC(0x03,GOT(x) ptr[r] -= 1 + d;,PUT(x,r))
|
||||
case let nip_inst: NIP =>
|
||||
let top = pop_or_get(nip_inst,0,state);
|
||||
let bot = pop_or_get(nip_inst,1,state);
|
||||
push_to_stack(nip_inst.ret, top, state);
|
||||
// /* SWP */ OPC(0x04,GOT(x) GOT(y),PUT(x,r) PUT(y,r))
|
||||
case let swp_inst: SWP =>
|
||||
let top = pop_or_get(swp_inst,0,state);
|
||||
let bot = pop_or_get(swp_inst,1,state);
|
||||
|
||||
push_to_stack(swp_inst.ret, top, state);
|
||||
push_to_stack(swp_inst.ret, bot, state);
|
||||
// /* ROT */ OPC(0x05,GOT(x) GOT(y) GOT(z),PUT(y,r) PUT(x,r) PUT(z,r))
|
||||
case let rot_inst: ROT =>
|
||||
let top = pop_or_get(rot_inst,0,state);
|
||||
let mid = pop_or_get(rot_inst,1,state);
|
||||
let bot = pop_or_get(rot_inst,2,state);
|
||||
|
||||
push_to_stack(rot_inst.ret, mid, state);
|
||||
push_to_stack(rot_inst.ret, top, state);
|
||||
push_to_stack(rot_inst.ret, bot, state);
|
||||
// /* DUP */ OPC(0x06,GOT(x),PUT(x,r) PUT(x,r))
|
||||
case let dup_inst: DUP =>
|
||||
let val = pop_from_stack(dup_inst.keep, dup_inst.ret, dup_inst.short, state);
|
||||
push_to_stack(dup_inst.ret, val, state);
|
||||
push_to_stack(dup_inst.ret, val, state);
|
||||
// /* OVR */ OPC(0x07,GOT(x) GOT(y),PUT(y,r) PUT(x,r) PUT(y,r))
|
||||
case let ovr_inst: OVR =>
|
||||
let top = pop_or_get(ovr_inst,0,state);
|
||||
let bot = pop_or_get(ovr_inst,1,state);
|
||||
|
||||
push_to_stack(ovr_inst.ret, bot, state);
|
||||
push_to_stack(ovr_inst.ret, top, state);
|
||||
push_to_stack(ovr_inst.ret, bot, state);
|
||||
// /* EQU */ OPC(0x08,POx(a,d) POx(b,d),PUx(b == a,0,r))
|
||||
case let equ_inst: EQU =>
|
||||
let top = pop_or_get(equ_inst,0,state);
|
||||
let bot = pop_or_get(equ_inst,1,state);
|
||||
|
||||
//TODO, I think this works, but it feels unclean with the casting
|
||||
let val: u8 = if(top: u16 == bot: u16){
|
||||
yield 1;
|
||||
} else {
|
||||
yield 0;
|
||||
};
|
||||
push_to_stack(equ_inst.ret, val, state);
|
||||
// /* NEQ */ OPC(0x09,POx(a,d) POx(b,d),PUx(b != a,0,r))
|
||||
case let neq_inst: NEQ =>
|
||||
let top = pop_or_get(neq_inst,0,state);
|
||||
let bot = pop_or_get(neq_inst,1,state);
|
||||
|
||||
//TODO, I think this works, but it feels unclean with the casting
|
||||
let val: u8 = if(top: u16 != bot: u16){
|
||||
yield 1;
|
||||
} else {
|
||||
yield 0;
|
||||
};
|
||||
push_to_stack(neq_inst.ret, val, state);
|
||||
// /* GTH */ OPC(0x0a,POx(a,d) POx(b,d),PUx(b > a,0,r))
|
||||
case let gth_inst: GTH =>
|
||||
let top = pop_or_get(gth_inst,0,state);
|
||||
let bot = pop_or_get(gth_inst,1,state);
|
||||
|
||||
//TODO, I think this works, but it feels unclean with the casting
|
||||
let val: u8 = if(bot: u16 > top: u16){
|
||||
yield 1;
|
||||
} else {
|
||||
yield 0;
|
||||
};
|
||||
push_to_stack(gth_inst.ret, val, state);
|
||||
// /* LTH */ OPC(0x0b,POx(a,d) POx(b,d),PUx(b < a,0,r))
|
||||
case let lth_inst: LTH =>
|
||||
let top = pop_or_get(lth_inst,0,state);
|
||||
let bot = pop_or_get(lth_inst,1,state);
|
||||
|
||||
//TODO, I think this works, but it feels unclean with the casting
|
||||
let val: u8 = if(bot: u16 < top: u16){
|
||||
yield 1;
|
||||
} else {
|
||||
yield 0;
|
||||
};
|
||||
push_to_stack(lth_inst.ret, val, state);
|
||||
// /* JMP */ OPC(0x0c,POx(a,d),MOV)
|
||||
case let jmp_inst: JMP =>
|
||||
let addr = pop_or_get(jmp_inst,0,state);
|
||||
match(addr) {
|
||||
case let b: u8 =>
|
||||
state.pc = state.pc + b: u16; //TODO verify if pc changes are right
|
||||
case let s: u16 =>
|
||||
state.pc = s;
|
||||
};
|
||||
|
||||
// /* JCN */ OPC(0x0d,POx(a,d) POx(b,0),if(b) MOV)
|
||||
case let jcn_inst: JCN =>
|
||||
let addr = pop_or_get(jcn_inst,0,state);
|
||||
let cond: u8 = pop_or_get(normal_op {keep = jcn_inst.keep,
|
||||
ret = jcn_inst.ret,
|
||||
short = false},
|
||||
if(jcn_inst.short){ yield 2;} else { yield 1; }, state ): u8;
|
||||
if( cond != 0) {
|
||||
match(addr) {
|
||||
case let b: u8 =>
|
||||
let off = b: i8: i32;
|
||||
state.pc = (state.pc: i32 + off): u16; //TODO verify if pc changes are right
|
||||
case let s: u16 =>
|
||||
state.pc = s;
|
||||
};
|
||||
};
|
||||
// /* JSR */ OPC(0x0e,POx(a,d),PUx(pc,1,!r) MOV)
|
||||
case let jsr_inst: JSR =>
|
||||
let addr = pop_or_get(jsr_inst,0,state);
|
||||
push_to_stack(true, state.pc, state);
|
||||
match(addr) {
|
||||
case let b: u8 =>
|
||||
let off = b: i8: i32;
|
||||
state.pc = (state.pc: i32 + off): u16; //TODO verify if pc changes are right
|
||||
case let s: u16 =>
|
||||
state.pc = s;
|
||||
};
|
||||
|
||||
// /* STH */ OPC(0x0f,GOT(x),PUT(x,!r))
|
||||
case let sth_inst: STH =>
|
||||
let val = pop_or_get(sth_inst,0,state);
|
||||
push_to_stack(!sth_inst.ret, val, state);
|
||||
// /* LDZ */ OPC(0x10,POx(a,0),PEK(a, x, 0xff))
|
||||
case let ldz_inst: LDZ =>
|
||||
let addr: u16 = pop_from_stack(ldz_inst.keep, ldz_inst.ret, false, state): u16 & 0x00FF;
|
||||
let val = if(ldz_inst.short){
|
||||
yield short_from_bytes(state.ram[addr],state.ram[addr+1 & 0x00FF]);
|
||||
} else {
|
||||
yield state.ram[addr];
|
||||
};
|
||||
push_to_stack(ldz_inst.ret, val, state);
|
||||
// /* STZ */ OPC(0x11,POx(a,0) GOT(y),POK(a, y, 0xff))
|
||||
case let stz_inst: STZ =>
|
||||
let addr: u16 = pop_or_get(normal_op{short = false, keep = stz_inst.keep, ret = stz_inst.ret}, 0, state): u16 & 0x00FF;
|
||||
let val = if(stz_inst.short){
|
||||
let low = pop_or_get(normal_op{short = false, keep = stz_inst.keep, ret = stz_inst.ret}, 1, state): u8;
|
||||
let high = pop_or_get(normal_op{short = false, keep = stz_inst.keep, ret = stz_inst.ret}, 2, state): u8;
|
||||
yield short_from_bytes(high,low);
|
||||
|
||||
}else{
|
||||
yield pop_or_get(stz_inst, 1, state): u8;
|
||||
};
|
||||
match (val) {
|
||||
case let b: u8 =>
|
||||
state.ram[addr] = b;
|
||||
case let s: u16 =>
|
||||
let high = (s >> 8 ): u8;
|
||||
let low = s: u8;
|
||||
state.ram[addr] = high;
|
||||
state.ram[addr+1 & 0x00FF] = low;
|
||||
//TODO verify correct endianness
|
||||
};
|
||||
// /* LDR */ OPC(0x12,POx(a,0),PEK(pc + (Sint8)a, x, 0xffff))
|
||||
case let ldr_inst: LDR =>
|
||||
let reladdr = (pop_from_stack(ldr_inst.keep, ldr_inst.ret, false, state): u16): i8;
|
||||
let addr: u16 = (state.pc: u32: i32 + reladdr): u16;
|
||||
let val = if(ldr_inst.short){
|
||||
yield short_from_bytes(state.ram[addr],state.ram[addr+1]);
|
||||
} else {
|
||||
yield state.ram[addr];
|
||||
};
|
||||
push_to_stack(ldr_inst.ret, val, state);
|
||||
// /* STR */ OPC(0x13,POx(a,0) GOT(y),POK(pc + (Sint8)a, y, 0xffff))
|
||||
case let str_inst: STR =>
|
||||
let reladdr = (pop_from_stack(str_inst.keep, str_inst.ret, false, state): u16): i8;
|
||||
let addr: u16 = (state.pc: u32: i32 + reladdr): u16;
|
||||
let val = pop_from_stack(str_inst.keep, str_inst.ret, str_inst.short, state);
|
||||
match (val) {
|
||||
case let b: u8 =>
|
||||
state.ram[addr] = b;
|
||||
case let s: u16 =>
|
||||
let high = (s >> 8 ): u8;
|
||||
let low = s: u8;
|
||||
state.ram[addr] = high;
|
||||
state.ram[addr+1] = low;
|
||||
//TODO verify correct endianness
|
||||
};
|
||||
// /* LDA */ OPC(0x14,POx(a,1),PEK(a, x, 0xffff))
|
||||
case let lda_inst: LDA =>
|
||||
let addr: u16 = pop_from_stack(lda_inst.keep, lda_inst.ret, true, state): u16;
|
||||
let val = if(lda_inst.short){
|
||||
yield short_from_bytes(state.ram[addr],state.ram[addr+1]);
|
||||
} else {
|
||||
yield state.ram[addr];
|
||||
};
|
||||
push_to_stack(lda_inst.ret, val, state);
|
||||
// /* STA */ OPC(0x15,POx(a,1) GOT(y),POK(a, y, 0xffff))
|
||||
case let sta_inst: STA =>
|
||||
let addr: u16 = pop_from_stack(sta_inst.keep, sta_inst.ret, true, state): u16;
|
||||
let val = pop_from_stack(sta_inst.keep, sta_inst.ret, sta_inst.short, state);
|
||||
match (val) {
|
||||
case let b: u8 =>
|
||||
state.ram[addr] = b;
|
||||
case let s: u16 =>
|
||||
let high = (s >> 8 ): u8;
|
||||
let low = s: u8;
|
||||
state.ram[addr] = high;
|
||||
state.ram[addr+1] = low;
|
||||
//TODO verify correct endianness
|
||||
};
|
||||
// /* DEI */ OPC(0x16,POx(a,0),DEI(a, x))
|
||||
case let dei_inst: DEI =>
|
||||
// fmt::println("DEI Instruction")!;
|
||||
let port: u8 = pop_from_stack(dei_inst.keep, dei_inst.ret, false, state): u8;
|
||||
let val = if(dei_inst.short){
|
||||
yield short_from_bytes(emu_dei(port,state),emu_dei(port+1,state));
|
||||
}else{
|
||||
yield emu_dei(port,state);
|
||||
};
|
||||
push_to_stack(dei_inst.ret,val,state);
|
||||
// /* DEO */ OPC(0x17,POx(a,0) GOT(y),DEO(a, y))
|
||||
case let deo_inst: DEO =>
|
||||
let port: u8 = pop_or_get(normal_op{short = false, keep = deo_inst.keep, ret = deo_inst.ret}, 0, state): u8;
|
||||
if(deo_inst.short){
|
||||
let low = pop_or_get(normal_op{short = false, keep = deo_inst.keep, ret = deo_inst.ret}, 1, state): u8;
|
||||
let high = pop_or_get(normal_op{short = false, keep = deo_inst.keep, ret = deo_inst.ret}, 2, state): u8;
|
||||
emu_deo(port,high,state);
|
||||
emu_deo(port+1,low,state);
|
||||
}else{
|
||||
let val = pop_or_get(deo_inst, 1, state): u8;
|
||||
emu_deo(port,val,state);
|
||||
};
|
||||
// /* ADD */ OPC(0x18,POx(a,d) POx(b,d),PUx(b + a, d,r))
|
||||
case let add_inst: ADD =>
|
||||
let top = pop_or_get(add_inst,0,state);
|
||||
let bot = pop_or_get(add_inst,1,state);
|
||||
let res = if(!add_inst.short){
|
||||
yield (top: u8 + bot: u8);
|
||||
} else {
|
||||
yield (top: u16 + bot: u16);
|
||||
};
|
||||
push_to_stack(add_inst.ret, res, state);
|
||||
// /* SUB */ OPC(0x19,POx(a,d) POx(b,d),PUx(b - a, d,r))
|
||||
case let sub_inst: SUB =>
|
||||
let top = pop_or_get(sub_inst,0,state);
|
||||
let bot = pop_or_get(sub_inst,1,state);
|
||||
let res = if(!sub_inst.short){
|
||||
yield (bot: u8 - top: u8);
|
||||
} else {
|
||||
yield (bot: u16 - top: u16);
|
||||
};
|
||||
push_to_stack(sub_inst.ret, res, state);
|
||||
// /* MUL */ OPC(0x1a,POx(a,d) POx(b,d),PUx(b * a, d,r))
|
||||
case let mul_inst: MUL =>
|
||||
let top = pop_or_get(mul_inst,0,state);
|
||||
let bot = pop_or_get(mul_inst,1,state);
|
||||
let res = if(!mul_inst.short){
|
||||
yield (bot: u8 * top: u8);
|
||||
} else {
|
||||
yield (bot: u16 * top: u16);
|
||||
};
|
||||
push_to_stack(mul_inst.ret, res, state);
|
||||
// /* DIV */ OPC(0x1b,POx(a,d) POx(b,d),PUx(a ? b / a : 0, d,r))
|
||||
case let div_inst: DIV =>
|
||||
let top = pop_or_get(div_inst,0,state);
|
||||
let bot = pop_or_get(div_inst,1,state);
|
||||
|
||||
let res = if(!div_inst.short){
|
||||
assert(bot is u8);
|
||||
assert(top is u8);
|
||||
if(top: u8 == 0) yield top;
|
||||
yield (bot: u8 / top: u8): u8;
|
||||
} else {
|
||||
assert(bot is u16);
|
||||
assert(top is u16);
|
||||
if(top: u16 == 0) yield top;
|
||||
yield (bot: u16 / top: u16): u16;
|
||||
};//TODO handle rounding and edge cases with division
|
||||
push_to_stack(div_inst.ret, res, state);
|
||||
// /* AND */ OPC(0x1c,POx(a,d) POx(b,d),PUx(b & a, d,r))
|
||||
case let and_inst: AND =>
|
||||
let top = pop_or_get(and_inst,0,state);
|
||||
let bot = pop_or_get(and_inst,1,state);
|
||||
let res = if(!and_inst.short){
|
||||
yield (bot: u8 & top: u8);
|
||||
} else {
|
||||
yield (bot: u16 & top: u16);
|
||||
};
|
||||
push_to_stack(and_inst.ret, res, state);
|
||||
// /* ORA */ OPC(0x1d,POx(a,d) POx(b,d),PUx(b | a, d,r))
|
||||
case let ora_inst: ORA =>
|
||||
let top = pop_or_get(ora_inst,0,state);
|
||||
let bot = pop_or_get(ora_inst,1,state);
|
||||
let res = if(!ora_inst.short){
|
||||
yield (bot: u8 | top: u8);
|
||||
} else {
|
||||
yield (bot: u16 | top: u16);
|
||||
};
|
||||
push_to_stack(ora_inst.ret, res, state);
|
||||
// /* EOR */ OPC(0x1e,POx(a,d) POx(b,d),PUx(b ^ a, d,r))
|
||||
case let eor_inst: EOR =>
|
||||
let top = pop_or_get(eor_inst,0,state);
|
||||
let bot = pop_or_get(eor_inst,1,state);
|
||||
let res = if(!eor_inst.short){
|
||||
yield (bot: u8 ^ top: u8);
|
||||
} else {
|
||||
yield (bot: u16 ^ top: u16);
|
||||
};
|
||||
push_to_stack(eor_inst.ret, res, state);
|
||||
// /* SFT */ OPC(0x1f,POx(a,0) POx(b,d),PUx(b >> (a & 0xf) << (a >> 4), d,r))
|
||||
case let sft_inst: SFT =>
|
||||
let shifts: u8 = pop_or_get(normal_op{short = false, keep = sft_inst.keep, ret = sft_inst.ret}, 0, state): u8;
|
||||
let rightshifts = shifts & 0b00001111;
|
||||
let leftshifts = (shifts & 0b11110000) >> 4;
|
||||
if(sft_inst.short){ //TODO, this seems like it can be cleaned up a bit
|
||||
let low = pop_or_get(normal_op{short = false, keep = sft_inst.keep, ret = sft_inst.ret}, 1, state): u8;
|
||||
let high = pop_or_get(normal_op{short = false, keep = sft_inst.keep, ret = sft_inst.ret}, 2, state): u8;
|
||||
let val = short_from_bytes(high,low);
|
||||
let res = (val >> rightshifts ) << leftshifts;
|
||||
push_to_stack(sft_inst.ret, res, state);
|
||||
}else{
|
||||
let val = pop_or_get(sft_inst, 1, state): u8;
|
||||
let res = (val >> rightshifts ) << leftshifts;
|
||||
push_to_stack(sft_inst.ret, res, state);
|
||||
};
|
||||
|
||||
|
||||
case =>
|
||||
return readval: unhandled;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// return evalerror;
|
||||
};
|
||||
|
||||
fn console_input(c: u8, ctype: u8, state: *uxn) (done | error) = {
|
||||
state.dev[0x12] = c;
|
||||
state.dev[0x17] = ctype;
|
||||
if(state.console_vector != 0){
|
||||
// fmt::println("Evaluating Console Vector")!;
|
||||
uxn_eval(state.console_vector, state)?;
|
||||
// fmt::println("Done Evaluating Console Vector")!;
|
||||
}; //TODO implement eval
|
||||
return done;
|
||||
};
|
||||
|
||||
|
||||
|
||||
// Converts an error into a user-friendly string
|
||||
fn strerror(err: error) str = {
|
||||
match (err) {
|
||||
case evalerror =>
|
||||
return "Reached unexpected part of eval code";
|
||||
case let val: unhandled =>
|
||||
return fmt::asprintf("Unknown Opcode read: {:x}", val: u8)!;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
export fn uxnrun() void = {
|
||||
if(len(os::args) < 2){
|
||||
fmt::printf("usage: %s file.rom [args..]\n")!;
|
||||
return;
|
||||
};
|
||||
let path = os::args[1];
|
||||
//Open rom file
|
||||
let romfile = match (os::open(path,fs::flag::RDONLY)) {
|
||||
case let file: io::file =>
|
||||
yield file;
|
||||
case let err: fs::error =>
|
||||
fmt::fatalf("Error opening {}: {}", path, fs::strerror(err));
|
||||
};
|
||||
let state: *uxn = initialize_uxn_mem();
|
||||
//Copy rom into ram
|
||||
let bytesread = match (io::read(romfile,state.ram[0x100..0xff00])){
|
||||
case let bytes: size =>
|
||||
yield bytes;
|
||||
case let eof: io::EOF =>
|
||||
fmt::fatalf("Empty Rom");
|
||||
case let err: io::error =>
|
||||
fmt::fatalf("Error reading: {}", io::strerror(err));
|
||||
};
|
||||
io::close(romfile)!; //TODO, isn't there some kind of oversized roms?
|
||||
// fread(&ram[0x100], 0xff00, 1, f), fclose(f);
|
||||
let hasargs = len(os::args) > 2;
|
||||
if(hasargs){
|
||||
state.dev[0x17] = 1;
|
||||
};
|
||||
// dev[0x17] = argc > 2;
|
||||
|
||||
let eval = match (uxn_eval(0x100, state)) {
|
||||
case done =>
|
||||
yield done;
|
||||
case let val: u8 =>
|
||||
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
||||
};
|
||||
//TODO see if the above needs to not run if console vector not set
|
||||
if(state.console_vector != 0){
|
||||
let args = os::args[2..];
|
||||
let i: u8 = 0;
|
||||
let argcount = len(args): u8;
|
||||
for (let arg .. args){
|
||||
// fmt::println("Console input args")!;
|
||||
for(let char: u8 .. strings::toutf8(arg)){
|
||||
// fmt::printfln("Console input arg char: {:x}", char)!;
|
||||
match (console_input(char,2,state)) {
|
||||
case done =>
|
||||
yield done;
|
||||
case let val: u8 =>
|
||||
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
||||
};
|
||||
};
|
||||
let ctype: u8 = if(i == (argcount - 1)){
|
||||
yield 4;
|
||||
} else {
|
||||
yield 3;
|
||||
};
|
||||
match (console_input('\n',ctype,state)) {
|
||||
case done =>
|
||||
yield done;
|
||||
case let val: u8 =>
|
||||
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
||||
};
|
||||
i+=1; //TODO using i here seems inelegant
|
||||
};
|
||||
for( state.dev[0x0f] == 0; i+=1 ){
|
||||
let buf: [1]u8 = [0];
|
||||
let count = io::read(os::stdin, buf)!;
|
||||
// fmt::println("Read input")!;
|
||||
if(count != 0) {
|
||||
match (console_input(buf[0],1,state)) {
|
||||
case done =>
|
||||
yield done;
|
||||
case let val: u8 =>
|
||||
fmt::fatalf("Unhandled Opcode: {:x}", val);
|
||||
};
|
||||
// fmt::println("Retuned from console_input")!;
|
||||
};
|
||||
};
|
||||
// match (console_input('\n',4,state)) { //TODO should this run?
|
||||
// case done =>
|
||||
// yield done;
|
||||
// case let val: u8 =>
|
||||
// fmt::fatalf("Unhandled Opcode: {:x}", val);
|
||||
// };
|
||||
};
|
||||
fmt::println("Done with uxn")!;
|
||||
|
||||
return;
|
||||
};
|
||||
Reference in New Issue
Block a user