422 lines
8.5 KiB
Go
422 lines
8.5 KiB
Go
package intcodeprocessor
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
helpers "git.bullercodeworks.com/brian/adventofcode/helpers"
|
|
)
|
|
|
|
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
|
|
|
|
Pause bool
|
|
Bail bool
|
|
WaitingForInput bool
|
|
InputChan chan int
|
|
WaitingForOutput bool
|
|
OutputChan chan int
|
|
|
|
Debug bool
|
|
DebugToFile 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) SaveState(slot string) error {
|
|
f, err := os.OpenFile("saveslot-"+slot+".sav", os.O_CREATE|os.O_WRONLY, 0644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
enc := json.NewEncoder(f)
|
|
enc.Encode(p)
|
|
return nil
|
|
}
|
|
|
|
func (p *Program) LoadState(slot string) error {
|
|
hold, err := ioutil.ReadFile("saveslot-" + slot + ".sav")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
json.NewDecoder(bytes.NewBuffer(hold)).Decode(&p)
|
|
return nil
|
|
}
|
|
|
|
func (p *Program) Pointer() int {
|
|
return p.Ptr
|
|
}
|
|
|
|
func (p *Program) DebugLog(l string) {
|
|
if p.Debug {
|
|
fmt.Print(l)
|
|
}
|
|
}
|
|
|
|
func (p *Program) OutputToFile(l string) {
|
|
f, err := os.OpenFile("debug-log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
defer f.Close()
|
|
_, err = fmt.Fprintln(f, l)
|
|
}
|
|
|
|
func (p *Program) Reset() {
|
|
copy(p.Code, p.OriginalCode)
|
|
p.Ptr = 0
|
|
p.State = RET_OK
|
|
p.Error = nil
|
|
p.Pause = false
|
|
p.WaitingForInput = false
|
|
p.WaitingForOutput = false
|
|
p.InputChan = make(chan int)
|
|
p.OutputChan = make(chan int)
|
|
p.RelBase = 0
|
|
}
|
|
|
|
func (p *Program) ForceQuit() {
|
|
p.Bail = true
|
|
close(p.InputChan)
|
|
close(p.OutputChan)
|
|
}
|
|
|
|
func (p *Program) Run() int {
|
|
for {
|
|
p.State = p.Step()
|
|
if p.State != RET_OK {
|
|
return p.State
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Program) Step() int {
|
|
for p.Pause {
|
|
time.Sleep(1)
|
|
}
|
|
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()
|
|
debug := fmt.Sprintf("ADD %d (%d, %d, %d)\n", intcode, v1, v2, v3)
|
|
p.DebugLog(debug)
|
|
if p.DebugToFile {
|
|
p.OutputToFile(fmt.Sprintf("%d: %s", p.Ptr, debug))
|
|
}
|
|
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()
|
|
debug := fmt.Sprintf("IEQ %d (%d, %d, %d)\n", intcode, v1, v2, dest)
|
|
p.DebugLog(debug)
|
|
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.InputChan <- v
|
|
//p.WaitingForInput = false
|
|
}
|
|
|
|
func (p *Program) Output() int {
|
|
v := <-p.OutputChan
|
|
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.InputChan)
|
|
p.WaitingForInput = false
|
|
}
|
|
|
|
func (p *Program) opOut(intcode, val int) {
|
|
valmd := p.paramMode(intcode, 0)
|
|
ret := p.get(valmd, val)
|
|
p.WaitingForOutput = true
|
|
p.OutputChan <- 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
|
|
}
|