From 69e69acc6fc5d244c10d1d858d8e6e8a8dc9ca96 Mon Sep 17 00:00:00 2001
From: Ian Gulliver <git@flamingcow.io>
Date: Tue, 16 Nov 2021 15:33:03 -1000
Subject: [PATCH] More private

---
 ophandler.go | 90 ++++++++++++++++++++++++++--------------------------
 state.go     |  5 +++
 2 files changed, 50 insertions(+), 45 deletions(-)

diff --git a/ophandler.go b/ophandler.go
index e35d8b7..5188539 100644
--- a/ophandler.go
+++ b/ophandler.go
@@ -3,147 +3,147 @@ package vm
 type opHandler func(*State, *Instruction)
 
 var opHandlers = map[OpCodeType]opHandler{
-	OpNoOp:   (*State).NoOp,
-	OpCall:   (*State).Call,
-	OpReturn: (*State).Return,
+	OpNoOp:   (*State).handleNoOp,
+	OpCall:   (*State).handleCall,
+	OpReturn: (*State).handleReturn,
 
-	OpMove: (*State).Move,
+	OpMove: (*State).handleMove,
 
-	OpAdd:            (*State).Add,
-	OpSubtract:       (*State).Subtract,
-	OpMultiply:       (*State).Multiply,
-	OpDivideUnsigned: (*State).DivideUnsigned,
-	OpDivideSigned:   (*State).DivideSigned,
+	OpAdd:            (*State).handleAdd,
+	OpSubtract:       (*State).handleSubtract,
+	OpMultiply:       (*State).handleMultiply,
+	OpDivideUnsigned: (*State).handleDivideUnsigned,
+	OpDivideSigned:   (*State).handleDivideSigned,
 
-	OpIsEqual:                      (*State).IsEqual,
-	OpIsLessThanUnsigned:           (*State).IsLessThanUnsigned,
-	OpIsLessThanSigned:             (*State).IsLessThanSigned,
-	OpIsGreaterThanUnsigned:        (*State).IsGreaterThanUnsigned,
-	OpIsGreaterThanSigned:          (*State).IsGreaterThanSigned,
-	OpIsLessThanOrEqualUnsigned:    (*State).IsLessThanOrEqualUnsigned,
-	OpIsLessThanOrEqualSigned:      (*State).IsLessThanOrEqualSigned,
-	OpIsGreaterThanOrEqualUnsigned: (*State).IsGreaterThanOrEqualUnsigned,
-	OpIsGreaterThanOrEqualSigned:   (*State).IsGreaterThanOrEqualSigned,
+	OpIsEqual:                      (*State).handleIsEqual,
+	OpIsLessThanUnsigned:           (*State).handleIsLessThanUnsigned,
+	OpIsLessThanSigned:             (*State).handleIsLessThanSigned,
+	OpIsGreaterThanUnsigned:        (*State).handleIsGreaterThanUnsigned,
+	OpIsGreaterThanSigned:          (*State).handleIsGreaterThanSigned,
+	OpIsLessThanOrEqualUnsigned:    (*State).handleIsLessThanOrEqualUnsigned,
+	OpIsLessThanOrEqualSigned:      (*State).handleIsLessThanOrEqualSigned,
+	OpIsGreaterThanOrEqualUnsigned: (*State).handleIsGreaterThanOrEqualUnsigned,
+	OpIsGreaterThanOrEqualSigned:   (*State).handleIsGreaterThanOrEqualSigned,
 
-	OpJump:        (*State).Jump,
-	OpJumpIfTrue:  (*State).JumpIfTrue,
-	OpJumpIfFalse: (*State).JumpIfFalse,
+	OpJump:        (*State).handleJump,
+	OpJumpIfTrue:  (*State).handleJumpIfTrue,
+	OpJumpIfFalse: (*State).handleJumpIfFalse,
 }
 
-func (state *State) NoOp(instr *Instruction) {
+func (state *State) handleNoOp(instr *Instruction) {
 }
 
-func (state *State) Call(instr *Instruction) {
+func (state *State) handleCall(instr *Instruction) {
 	in := state.readSigned(&instr.Operand1)
 	state.call(in)
 }
 
-func (state *State) Return(instr *Instruction) {
+func (state *State) handleReturn(instr *Instruction) {
 	state.ret()
 }
 
-func (state *State) Move(instr *Instruction) {
+func (state *State) handleMove(instr *Instruction) {
 	in := state.readUnsigned(&instr.Operand2)
 	state.writeUnsigned(&instr.Operand1, in)
 }
 
-func (state *State) Add(instr *Instruction) {
+func (state *State) handleAdd(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.writeUnsigned(&instr.Operand1, in1+in2)
 }
 
-func (state *State) Subtract(instr *Instruction) {
+func (state *State) handleSubtract(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.writeUnsigned(&instr.Operand1, in1-in2)
 }
 
-func (state *State) Multiply(instr *Instruction) {
+func (state *State) handleMultiply(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.writeUnsigned(&instr.Operand1, in1*in2)
 }
 
-func (state *State) DivideUnsigned(instr *Instruction) {
+func (state *State) handleDivideUnsigned(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.writeUnsigned(&instr.Operand1, in1/in2)
 }
 
-func (state *State) DivideSigned(instr *Instruction) {
+func (state *State) handleDivideSigned(instr *Instruction) {
 	in1 := state.readSigned(&instr.Operand1)
 	in2 := state.readSigned(&instr.Operand2)
 	state.writeSigned(&instr.Operand1, in1/in2)
 }
 
-func (state *State) IsEqual(instr *Instruction) {
+func (state *State) handleIsEqual(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.comparisonResult = (in1 == in2)
 }
 
-func (state *State) IsLessThanUnsigned(instr *Instruction) {
+func (state *State) handleIsLessThanUnsigned(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.comparisonResult = (in1 < in2)
 }
 
-func (state *State) IsLessThanSigned(instr *Instruction) {
+func (state *State) handleIsLessThanSigned(instr *Instruction) {
 	in1 := state.readSigned(&instr.Operand1)
 	in2 := state.readSigned(&instr.Operand2)
 	state.comparisonResult = (in1 < in2)
 }
 
-func (state *State) IsGreaterThanUnsigned(instr *Instruction) {
+func (state *State) handleIsGreaterThanUnsigned(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.comparisonResult = (in1 > in2)
 }
 
-func (state *State) IsGreaterThanSigned(instr *Instruction) {
+func (state *State) handleIsGreaterThanSigned(instr *Instruction) {
 	in1 := state.readSigned(&instr.Operand1)
 	in2 := state.readSigned(&instr.Operand2)
 	state.comparisonResult = (in1 > in2)
 }
 
-func (state *State) IsLessThanOrEqualUnsigned(instr *Instruction) {
+func (state *State) handleIsLessThanOrEqualUnsigned(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.comparisonResult = (in1 <= in2)
 }
 
-func (state *State) IsLessThanOrEqualSigned(instr *Instruction) {
+func (state *State) handleIsLessThanOrEqualSigned(instr *Instruction) {
 	in1 := state.readSigned(&instr.Operand1)
 	in2 := state.readSigned(&instr.Operand2)
 	state.comparisonResult = (in1 <= in2)
 }
 
-func (state *State) IsGreaterThanOrEqualUnsigned(instr *Instruction) {
+func (state *State) handleIsGreaterThanOrEqualUnsigned(instr *Instruction) {
 	in1 := state.readUnsigned(&instr.Operand1)
 	in2 := state.readUnsigned(&instr.Operand2)
 	state.comparisonResult = (in1 >= in2)
 }
 
-func (state *State) IsGreaterThanOrEqualSigned(instr *Instruction) {
+func (state *State) handleIsGreaterThanOrEqualSigned(instr *Instruction) {
 	in1 := state.readSigned(&instr.Operand1)
 	in2 := state.readSigned(&instr.Operand2)
 	state.comparisonResult = (in1 >= in2)
 }
 
-func (state *State) Jump(instr *Instruction) {
+func (state *State) handleJump(instr *Instruction) {
 	in := state.readSigned(&instr.Operand1)
-	state.instructionIndex += in - 1
+	state.jump(in)
 }
 
-func (state *State) JumpIfTrue(instr *Instruction) {
+func (state *State) handleJumpIfTrue(instr *Instruction) {
 	if state.comparisonResult == true {
-		state.Jump(instr)
+		state.handleJump(instr)
 	}
 }
 
-func (state *State) JumpIfFalse(instr *Instruction) {
+func (state *State) handleJumpIfFalse(instr *Instruction) {
 	if state.comparisonResult == false {
-		state.Jump(instr)
+		state.handleJump(instr)
 	}
 }
diff --git a/state.go b/state.go
index 5fc263d..808ef9b 100644
--- a/state.go
+++ b/state.go
@@ -158,3 +158,8 @@ func (state *State) ret() {
 		state.running = false
 	}
 }
+
+func (state *State) jump(instructionOffset int64) {
+	// -1 accounts for the +1 processInstruction()
+	state.instructionIndex += instructionOffset - 1
+}