adventofcode/2019/intcode-processor/processor.go

393 lines
7.8 KiB
Go

package intcodeprocessor
import (
"errors"
"fmt"
helpers "git.bullercodeworks.com/brian/adventofcode/helpers"
"io/ioutil"
"math"
"os"
"strings"
)
const (
OP_ADD = 1
OP_MLT = 2
OP_INP = 3
OP_OUT = 4
OP_JIT = 5
OP_JIF = 6
OP_ILT = 7
OP_IEQ = 8
OP_RBS = 9
OP_EXT = 99
)
const (
MODE_POS = iota
MODE_IMM
MODE_REL
)
const (
RET_ERR = iota - 1
RET_OK
RET_DONE
)
type Program struct {
originalCode []int
code []int
ptr int
relBase int
state int
error error
bail bool
waitingForInput bool
input chan int
waitingForOutput bool
output chan int
debug bool
}
func ReadIntCodeFile(fn string) []int {
dat, err := ioutil.ReadFile(fn)
if err != nil {
fmt.Println("Error reading program file:", err.Error())
os.Exit(1)
}
var prog []int
stringDat := strings.TrimSpace(string(dat))
for _, v := range strings.Split(stringDat, ",") {
prog = append(prog, helpers.Atoi(v))
}
return prog
}
func NewProgram(prog []int) *Program {
p := new(Program)
p.originalCode = make([]int, len(prog))
p.code = make([]int, len(prog))
copy(p.originalCode, prog)
p.Reset()
return p
}
func (p *Program) EnableDebug() {
p.debug = true
}
func (p *Program) DisableDebug() {
p.debug = false
}
func (p *Program) DebugLog(l string) {
if p.debug {
fmt.Print(l)
}
}
func (p *Program) Reset() {
copy(p.code, p.originalCode)
p.ptr = 0
p.state = RET_OK
p.error = nil
p.waitingForInput = false
p.waitingForOutput = false
p.input = make(chan int)
p.output = make(chan int)
p.relBase = 0
}
func (p *Program) GetCode() []int {
return p.code
}
func (p *Program) State() int {
return p.state
}
func (p *Program) Error() error {
return p.error
}
func (p *Program) ForceQuit() {
p.bail = true
close(p.input)
close(p.output)
}
func (p *Program) Run() int {
for {
p.state = p.Step()
if p.state != RET_OK {
return p.state
}
}
}
func (p *Program) Step() int {
if p.bail {
p.error = errors.New("Force Quit")
return RET_ERR
}
if len(p.code) < p.ptr {
p.error = errors.New("Pointer Exception")
return RET_ERR
}
p.DebugLog(p.String() + "\n")
intcode := p.readNext()
p.ptr++
switch p.opCode(intcode) {
case OP_ADD:
v1, v2, v3 := p.readNextThree()
p.DebugLog(fmt.Sprintf("ADD %d (%d, %d, %d)\n", intcode, v1, v2, v3))
p.ptr = p.ptr + 3
p.opAdd(intcode, v1, v2, v3)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_MLT:
v1, v2, v3 := p.readNextThree()
p.DebugLog(fmt.Sprintf("MLT %d (%d, %d, %d)\n", intcode, v1, v2, v3))
p.ptr = p.ptr + 3
p.opMult(intcode, v1, v2, v3)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_INP:
v1 := p.readNext()
p.DebugLog(fmt.Sprintf("INP %d (%d)\n", intcode, v1))
p.ptr++
p.opInp(intcode, v1)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_OUT:
v1 := p.readNext()
p.ptr++
p.DebugLog(fmt.Sprintf("OUT %d (%d)\n", intcode, v1))
p.opOut(intcode, v1)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_JIT:
v1, v2 := p.readNextTwo()
p.DebugLog(fmt.Sprintf("JIT %d (%d, %d)\n", intcode, v1, v2))
p.ptr = p.ptr + 2
p.opJumpIfTrue(intcode, v1, v2)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_JIF:
v1, v2 := p.readNextTwo()
p.DebugLog(fmt.Sprintf("JIF %d (%d, %d)\n", intcode, v1, v2))
p.ptr = p.ptr + 2
p.opJumpIfFalse(intcode, v1, v2)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_ILT:
v1, v2, dest := p.readNextThree()
p.DebugLog(fmt.Sprintf("ILT %d (%d, %d, %d)\n", intcode, v1, v2, dest))
p.ptr = p.ptr + 3
p.opIfLessThan(intcode, v1, v2, dest)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_IEQ:
v1, v2, dest := p.readNextThree()
p.DebugLog(fmt.Sprintf("IEQ %d (%d, %d, %d)\n", intcode, v1, v2, dest))
p.ptr = p.ptr + 3
p.opIfEqual(intcode, v1, v2, dest)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_RBS:
v1 := p.readNext()
p.DebugLog(fmt.Sprintf("RBS %d (%d)\n", intcode, v1))
p.ptr = p.ptr + 1
p.opModRelBase(intcode, v1)
if p.error != nil {
return RET_ERR
}
return RET_OK
case OP_EXT:
p.DebugLog(fmt.Sprintf("EXT %d\n", intcode))
return RET_DONE
}
p.error = errors.New(fmt.Sprintf("Invalid OpCode (%d)", intcode))
p.DebugLog(p.String())
return RET_ERR
}
func (p *Program) GetCurrentOpCode() int {
return p.code[p.ptr]
}
func (p *Program) GetProgramValueAt(idx int) int {
p.ensureLength(idx)
return p.code[idx]
}
func (p *Program) SetProgramValueAt(idx, val int) {
p.ensureLength(idx)
p.code[idx] = val
}
func (p *Program) NeedsInput() bool {
return p.waitingForInput
}
func (p *Program) NeedsOutput() bool {
return p.waitingForOutput
}
func (p *Program) opCode(intcode int) int {
return intcode % 100
}
func (p *Program) paramMode(intcode, pNum int) int {
plc := math.Pow10(pNum + 2)
return ((intcode - p.opCode(intcode)) / int(plc)) % 10
}
func (p *Program) ensureLength(idx int) {
for len(p.code) < idx+1 {
p.code = append(p.code, 0)
}
}
func (p *Program) readNext() int {
p.ensureLength(p.ptr)
return p.code[p.ptr]
}
func (p *Program) readNextTwo() (int, int) {
p.ensureLength(p.ptr + 1)
return p.code[p.ptr], p.code[p.ptr+1]
}
func (p *Program) readNextThree() (int, int, int) {
p.ensureLength(p.ptr + 2)
return p.code[p.ptr], p.code[p.ptr+1], p.code[p.ptr+2]
}
func (p *Program) get(mode, v int) int {
if mode == MODE_POS {
p.ensureLength(v)
return p.code[v]
} else if mode == MODE_REL {
p.ensureLength(p.relBase + v)
return p.code[p.relBase+v]
}
return v
}
func (p *Program) set(mode, idx, v int) {
if mode == MODE_POS {
p.ensureLength(idx)
p.code[idx] = v
} else if mode == MODE_REL {
p.ensureLength(p.relBase + idx)
p.code[p.relBase+idx] = v
}
}
func (p *Program) Input(v int) {
p.input <- v
p.waitingForInput = false
}
func (p *Program) Output() int {
v := <-p.output
p.waitingForOutput = false
return v
}
func (p *Program) opAdd(intcode, a1, a2, dest int) {
a1md, a2md, destmd := p.paramMode(intcode, 0), p.paramMode(intcode, 1), p.paramMode(intcode, 2)
p.set(destmd, dest, p.get(a1md, a1)+p.get(a2md, a2))
}
func (p *Program) opMult(intcode, a1, a2, dest int) {
a1md, a2md, destmd := p.paramMode(intcode, 0), p.paramMode(intcode, 1), p.paramMode(intcode, 2)
p.set(destmd, dest, p.get(a1md, a1)*p.get(a2md, a2))
}
func (p *Program) opInp(intcode, dest int) {
destmd := p.paramMode(intcode, 0)
p.waitingForInput = true
p.set(destmd, dest, <-p.input)
p.waitingForInput = false
}
func (p *Program) opOut(intcode, val int) {
valmd := p.paramMode(intcode, 0)
ret := p.get(valmd, val)
p.waitingForOutput = true
p.output <- ret
}
func (p *Program) opJumpIfTrue(intcode, v1, v2 int) {
v1md, v2md := p.paramMode(intcode, 0), p.paramMode(intcode, 1)
if p.get(v1md, v1) != 0 {
p.ptr = p.get(v2md, v2)
}
}
func (p *Program) opJumpIfFalse(intcode, v1, v2 int) {
v1md, v2md := p.paramMode(intcode, 0), p.paramMode(intcode, 1)
if p.get(v1md, v1) == 0 {
p.ptr = p.get(v2md, v2)
}
}
func (p *Program) opIfLessThan(intcode, v1, v2, dest int) {
v1md, v2md, destmd := p.paramMode(intcode, 0), p.paramMode(intcode, 1), p.paramMode(intcode, 2)
if p.get(v1md, v1) < p.get(v2md, v2) {
p.set(destmd, dest, 1)
} else {
p.set(destmd, dest, 0)
}
}
func (p *Program) opIfEqual(intcode, v1, v2, dest int) {
v1md, v2md, destmd := p.paramMode(intcode, 0), p.paramMode(intcode, 1), p.paramMode(intcode, 2)
if p.get(v1md, v1) == p.get(v2md, v2) {
p.set(destmd, dest, 1)
} else {
p.set(destmd, dest, 0)
}
}
func (p *Program) opModRelBase(intcode, v1 int) {
v1md := p.paramMode(intcode, 0)
p.relBase = p.relBase + p.get(v1md, v1)
}
func (p Program) String() string {
var ret string
ret = ret + fmt.Sprintf("(PTR: %d, RBS: %d)\n", p.ptr, p.relBase)
for k := range p.code {
if k == p.ptr {
ret = fmt.Sprintf("%s [%d]", ret, p.code[k])
} else {
ret = fmt.Sprintf("%s %d", ret, p.code[k])
}
}
return ret
}