From 2a17dda142a6c9ee53fc91a77b47278fff552087 Mon Sep 17 00:00:00 2001
From: Bradford Lamson-Scribner <brad.lamson@gmail.com>
Date: Sun, 31 May 2020 21:47:05 -0600
Subject: [PATCH] internal/vm/{cpu,mem,opcodes,vm}: stick to using byte instead
 of uint8

I can never decide on these things but I generally
prefer using `byte` in go.
---
 internal/vm/cpu.go     | 26 +++++++++++++-------------
 internal/vm/mem.go     |  2 +-
 internal/vm/opcodes.go |  8 ++++----
 internal/vm/vm.go      |  2 +-
 4 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/internal/vm/cpu.go b/internal/vm/cpu.go
index dd03aed..32bcdd3 100644
--- a/internal/vm/cpu.go
+++ b/internal/vm/cpu.go
@@ -58,14 +58,14 @@ const (
 // | + ------------ Overflow
 // +--------------- Negative
 const (
-	flagDefault           uint8 = 0B_00110000
-	flagNegative          uint8 = 0B_10000000
-	flagOverflow          uint8 = 0B_01000000
-	flagBreak             uint8 = 0B_00010000
-	flagDecimalMode       uint8 = 0B_00001000
-	flagDisableInterrupts uint8 = 0B_00000100
-	flagZero              uint8 = 0B_00000010
-	flagCarry             uint8 = 0B_00000001
+	flagDefault           byte = 0B_00110000
+	flagNegative          byte = 0B_10000000
+	flagOverflow          byte = 0B_01000000
+	flagBreak             byte = 0B_00010000
+	flagDecimalMode       byte = 0B_00001000
+	flagDisableInterrupts byte = 0B_00000100
+	flagZero              byte = 0B_00000010
+	flagCarry             byte = 0B_00000001
 )
 
 // StackBottom represents the start of the stack
@@ -73,12 +73,12 @@ const StackBottom uint16 = 0x0100 // 256
 
 // Mos6502 TODO: docs
 type Mos6502 struct {
-	sp uint8  // register - stack pointer
+	sp byte   // register - stack pointer
 	pc uint16 // register - program counter
-	a  uint8  // register - accumulator
-	x  uint8  // register - x index
-	y  uint8  // register - y index
-	ps uint8  // register - processor status
+	a  byte   // register - accumulator
+	x  byte   // register - x index
+	y  byte   // register - y index
+	ps byte   // register - processor status
 }
 
 // newCPU initializes and returns a new Mos6502 CPU
diff --git a/internal/vm/mem.go b/internal/vm/mem.go
index 9e59e34..8f14f53 100644
--- a/internal/vm/mem.go
+++ b/internal/vm/mem.go
@@ -8,7 +8,7 @@ func newBlock() [64 * 1024]byte {
 }
 
 // load loads a program into memory at the provided address space
-func (b block) load(addr uint16, data []uint8) {
+func (b block) load(addr uint16, data []byte) {
 	end := int(addr) + len(data)
 
 	for i := int(addr); i < end; i++ {
diff --git a/internal/vm/opcodes.go b/internal/vm/opcodes.go
index 50cd5ac..5f2403f 100644
--- a/internal/vm/opcodes.go
+++ b/internal/vm/opcodes.go
@@ -8,13 +8,13 @@ import (
 // opcode, how many bytes it occupies (it's size), as well as it's addressing mode.
 type op struct {
 	name     string
-	opcode   uint8
-	size     uint8
+	opcode   byte
+	size     byte
 	addrMode addrMode
 	exec     func(a *Appleone, o op) error
 }
 
-func newOp(name string, opcode, size uint8, addrMode addrMode, exec func(a *Appleone, o op) error) op {
+func newOp(name string, opcode, size byte, addrMode addrMode, exec func(a *Appleone, o op) error) op {
 	return op{
 		name:     name,
 		opcode:   opcode,
@@ -35,7 +35,7 @@ func opByCode(b byte) (op, error) {
 
 // opcodes represent all of the Apple 1 opcodes available. Each 8 bit opcode is mapped to a corresponding
 // "op" which is just a struct holding metadata about the operation.
-var opcodes = map[uint8]op{
+var opcodes = map[byte]op{
 	// BRK Force Break
 	// addressing    assembler    opc  bytes  cyles
 	// --------------------------------------------
diff --git a/internal/vm/vm.go b/internal/vm/vm.go
index f53d603..1dde2fb 100644
--- a/internal/vm/vm.go
+++ b/internal/vm/vm.go
@@ -74,7 +74,7 @@ func (a *Appleone) getAddr(o op) (uint16, error) {
 	}
 }
 
-func (a *Appleone) getOperand(o op) (uint8, error) {
+func (a *Appleone) getOperand(o op) (byte, error) {
 	if o.addrMode == accumulator {
 		return a.cpu.a, nil
 	}