homepage/content/toys/triscit/triscit.mjs

154 lines
4.7 KiB
JavaScript

import * as Binutils from "./binutils.mjs"
const FLAG_NEGATIVE = 1 << 0
const FLAG_HALT = 1 << 1
const FLAG_ABLAZE = 1 << 2
class Instruction {
constructor(name, args, description) {
this.Name = name
this.Args = args
this.Description = description
}
}
const Instructions = [
new Instruction("NOOP", [], "Do nothing"),
new Instruction("PRNT", ["x"], "Print string at x"),
new Instruction("READ", ["x"], "Read input, store in x"),
new Instruction("CMPS", ["x", "y"], "Compare string x to string y"),
new Instruction("JNEQ", ["x"], "If not equal, set PC to x"),
new Instruction("JUMP", ["x"], "Set PC to x"),
new Instruction("HALT", [], "Terminate program"),
new Instruction("HACF", [], "Halt And Catch Fire (never use this!)"),
]
function disassemble(program) {
let b = program[0]
let inst = Instructions[b]
if (inst) {
let nargs = inst.Args.length
let args = []
for (let i = 0; i < nargs; i++) {
args.push(program[i+1])
}
if (1+nargs <= program.length) {
// Only return an opcode if there was enough data for its arguments as well
return {length: 1+nargs, name: inst.Name, args: args}
}
}
let data = Binutils.CString(program, true)
let s = Binutils.Stringify(data)
return {length: data.length, name: "DATA", args: [s]}
}
class CPU {
/**
* @param {Uint8Array} program Program to load
* @param {string} input input string
* @param {Number} pc initial program counter
* @param {Number} flags initial flags
*/
constructor(program, input, output="", pc=0, flags=0) {
this.Program = program
this.Input = input
this.Output = output
this.PC = pc
this.Flags = flags
}
Clone() {
return new CPU(this.Program, this.Input, this.Output, this.PC, this.Flags)
}
DisassembleProgram() {
let ret = []
let prog1 = this.Program.slice(0, this.PC)
let addr = 0
for (let prog of [prog1, this.Program]) {
while (addr < prog.length) {
let subprog = prog.slice(addr)
let inst = disassemble(subprog)
ret.push({
addr,
buf: this.Program.slice(addr, addr+inst.length),
name: inst.name,
args: inst.args,
})
addr += inst.length
}
}
return ret
}
Step() {
let prog = this.Program.slice(this.PC)
let inst = disassemble(prog)
let flags = this.Flags
this.Flags = 0
switch (inst.name) {
case "JUMP":
this.PC = inst.args[0]
return
case "JNEQ":
if (flags && FLAG_NEGATIVE) {
this.PC = inst.args[0]
return
}
break
case "READ": {
let addr = inst.args[0]
let b = new TextEncoder().encode(this.Input + "\0")
let newproglen = Math.max(this.Program.length, addr+b.length)
let newprog = new Uint8Array(newproglen)
for (let i = 0; i < addr; i++) {
newprog[i] = this.Program[i]
}
for (let i = 0; i < b.length; i++) {
newprog[addr+i] = b[i]
}
for (let i = addr+b.length; i < this.Program.length; i++) {
newprog[i] = this.Program[i]
}
this.Program = newprog
break
}
case "PRNT": {
let addr = inst.args[0]
let prog = this.Program.slice(addr)
this.Output = Binutils.CString(prog)
break
}
case "CMPS": {
let decoder = new TextDecoder()
let a = decoder.decode(Binutils.CString(this.Program.slice(inst.args[0])))
let b = decoder.decode(Binutils.CString(this.Program.slice(inst.args[1])))
if (a != b) {
this.Flags = FLAG_NEGATIVE
}
break
}
case "HALT":
// Don't modify PC
this.Flags = FLAG_HALT
return
case "HACF":
this.Flags = FLAG_HALT | FLAG_ABLAZE
return
case "DATA":
// Keep stepping through data one byte at a time trying to execute something
inst.length = 1
break
}
this.PC += inst.length
}
}
export {
FLAG_NEGATIVE, FLAG_HALT, FLAG_ABLAZE,
Instructions,
CPU,
}