simplification of the memory sub-system

- preparation for adding 7800 emulation

cpu (6507) package uncoupled from upstream dependencies

- cpu no longer logs execution of KIL instruction
- randomisation of registers on startup can be handled by the called of
  the cpu's Reset() function
- address errors are filtered by an optional IsAddressError() function
  in the Memory interface implementation
- Error field removed from execution.Result type

all references to interface{} replaced with any

debugger/dbgmem/dbgmem.go

@@ -34,7 +34,7 @@ type DbgMem struct {
 }
 
 // GetAddressInfo allows addressing by symbols in addition to numerically.
-func (dbgmem DbgMem) GetAddressInfo(address interface{}, read bool) *AddressInfo {
+func (dbgmem DbgMem) GetAddressInfo(address any, read bool) *AddressInfo {
 	ai := &AddressInfo{Read: read}
 
 	var searchTable symbols.SearchTable
@@ -102,7 +102,7 @@ var PokeError = errors.New("cannot poke address")
 
 // Peek returns the contents of the memory address, without triggering any side
 // effects. The supplied address can be numeric of symbolic.
-func (dbgmem DbgMem) Peek(address interface{}) (*AddressInfo, error) {
+func (dbgmem DbgMem) Peek(address any) (*AddressInfo, error) {
 	ai := dbgmem.GetAddressInfo(address, true)
 	if ai == nil {
 		return nil, fmt.Errorf("%w: %v", PeekError, address)
@@ -126,7 +126,7 @@ func (dbgmem DbgMem) Peek(address interface{}) (*AddressInfo, error) {
 
 // Poke writes a value at the specified address. The supplied address be
 // numeric or symbolic.
-func (dbgmem DbgMem) Poke(address interface{}, data uint8) (*AddressInfo, error) {
+func (dbgmem DbgMem) Poke(address any, data uint8) (*AddressInfo, error) {
 	// although the words "read" and "write" might lead us to think that we
 	// "peek" from "read" addresses and "poke" to "write" addresses, it is in
 	// fact necessary to treat "poke" addresses as "read" addresses

debugger/halt_breakpoints.go

@@ -288,7 +288,7 @@ func (bp *breakpoints) parseCommand(tokens *commandline.Tokens) error {
 	// - if it is not a valid type value, try to change the target
 	tok, present := tokens.Get()
 	for present {
-		var val interface{}
+		var val any
 		var err error
 
 		// try to interpret the token depending on the type of value the target

debugger/halt_targets.go

@@ -27,7 +27,7 @@ import (
 // the case of the CPU program counter target, the underlying type is a uint16.
 //
 // !!TODO: candidate for generic / comparable type
-type targetValue interface{}
+type targetValue any
 
 type target struct {
 	// a label for the label

debugger/print.go

@@ -29,7 +29,7 @@ import (
 // all print operations from the debugger should be made with the this printLine()
 // function. output will be normalised and sent to the attached terminal as
 // required.
-func (dbg *Debugger) printLine(sty terminal.Style, s string, a ...interface{}) {
+func (dbg *Debugger) printLine(sty terminal.Style, s string, a ...any) {
 	// resolve placeholders if there are arguments to insert
 	if len(a) > 0 {
 		s = fmt.Sprintf(s, a...)

disassembly/decode.go

@@ -22,7 +22,6 @@ import (
 	"github.com/jetsetilly/gopher2600/hardware/cpu"
 	"github.com/jetsetilly/gopher2600/hardware/cpu/instructions"
 	"github.com/jetsetilly/gopher2600/hardware/memory/cartridge/mapper"
-	"github.com/jetsetilly/gopher2600/hardware/memory/cpubus"
 	"github.com/jetsetilly/gopher2600/hardware/memory/memorymap"
 	"github.com/jetsetilly/gopher2600/logger"
 )
@@ -49,7 +48,7 @@ func (dsm *Disassembly) bless(mc *cpu.CPU, mem *disasmMemory) error {
 	for b := range dsm.disasmEntries.Entries {
 		// get reset address from starting bank, taking into account the
 		// possibility that bank is smalled thank 4096 bytes
-		resetVector := cpubus.Reset & (uint16(len(mem.banks[b].Data) - 1))
+		resetVector := cpu.Reset & (uint16(len(mem.banks[b].Data) - 1))
 		resetAddr := (uint16(mem.banks[b].Data[resetVector+1]) << 8) | uint16(mem.banks[b].Data[resetVector])
 
 		// make sure reset address is valid

disassembly/disassembly.go

@@ -27,7 +27,6 @@ import (
 	"github.com/jetsetilly/gopher2600/hardware/cpu"
 	"github.com/jetsetilly/gopher2600/hardware/cpu/execution"
 	"github.com/jetsetilly/gopher2600/hardware/memory/cartridge/mapper"
-	"github.com/jetsetilly/gopher2600/hardware/memory/cpubus"
 	"github.com/jetsetilly/gopher2600/hardware/memory/memorymap"
 	"github.com/jetsetilly/gopher2600/hardware/television"
 )
@@ -139,7 +138,7 @@ func (dsm *Disassembly) FromMemory() error {
 		return fmt.Errorf("disassembly: %w", err)
 	}
 
-	startingBank := dsm.vcs.Mem.Cart.GetBank(cpubus.Reset).Number
+	startingBank := dsm.vcs.Mem.Cart.GetBank(cpu.Reset).Number
 
 	mem := newDisasmMemory(startingBank, copiedBanks)
 	if mem == nil {
@@ -168,7 +167,7 @@ func (dsm *Disassembly) FromMemory() error {
 	}
 
 	// create a new NoFlowControl CPU to help disassemble memory
-	mc := cpu.NewCPU(nil, mem)
+	mc := cpu.NewCPU(mem)
 	mc.NoFlowControl = true
 
 	dsm.crit.Unlock()

disassembly/symbols/canonise.go

@@ -34,16 +34,16 @@ func (sym *Symbols) canonise(cart *cartridge.Cartridge) {
 	// note that because Read and Write in the cpubus package are sparse
 	// arrays we need to filter out the empty entries. (the Read and Write
 	// structures used to be maps and we didn't need to do this)
-	for k, v := range cpubus.TIAReadSymbols {
+	for k, v := range cpubus.TIAReadRegisters {
 		sym.read.add(SourceSystem, k, string(v))
 	}
-	for k, v := range cpubus.RIOTReadSymbols {
+	for k, v := range cpubus.RIOTReadRegisters {
 		sym.read.add(SourceSystem, k, string(v))
 	}
-	for k, v := range cpubus.TIAWriteSymbols {
+	for k, v := range cpubus.TIAWriteRegisters {
 		sym.write.add(SourceSystem, k, string(v))
 	}
-	for k, v := range cpubus.RIOTWriteSymbols {
+	for k, v := range cpubus.RIOTWriteRegisters {
 		sym.write.add(SourceSystem, k, string(v))
 	}
 

gopher2600.go

@@ -80,7 +80,7 @@ const (
 
 type stateRequest struct {
 	req  stateReq
-	args interface{}
+	args any
 }
 
 // the gui create function. paired with reqCreateGUI state request.

gui/gui.go

@@ -28,11 +28,11 @@ type FeatureReq string
 
 // FeatureReqData represents the information associated with a FeatureReq. See
 // commentary for the defined FeatureReq values for the underlying type.
-type FeatureReqData interface{}
+type FeatureReqData any
 
 // List of valid feature requests. argument must be of the type specified or
-// else the interface{} type conversion will fail and the application will
-// probably crash.
+// else the 'any' type conversion will fail and the application will probably
+// crash.
 //
 // Note that, like the name suggests, these are requests, they may or may not
 // be satisfied depending other conditions in the GUI.

gui/sdlimgui/caching/caching.go

@@ -40,7 +40,7 @@ type cachedVCS struct {
 
 // plumbing is necessary to make sure that pointers to memory etc. are correct
 func (vcs cachedVCS) plumb(env *environment.Environment) {
-	vcs.CPU.Plumb(env, vcs.Mem)
+	vcs.CPU.Plumb(vcs.Mem)
 	vcs.Mem.Plumb(env, true)
 	vcs.RIOT.Plumb(env, vcs.Mem.RIOT, vcs.Mem.TIA)
 	vcs.TIA.Plumb(env, nil, vcs.Mem.TIA, vcs.RIOT.Ports, vcs.CPU)

gui/sdlimgui/imgui_fuzzy.go

@@ -62,7 +62,7 @@ func (fz *fuzzyFilter) activate() {
 	fz.active = true
 }
 
-func (fz *fuzzyFilter) draw(label string, choices interface{}, onChange func(int), allowEmptyFilter bool) bool {
+func (fz *fuzzyFilter) draw(label string, choices any, onChange func(int), allowEmptyFilter bool) bool {
 	if !fz.active {
 		fz.active = true
 		fz.refocusKeyboard = true

gui/sdlimgui/service.go

@@ -446,7 +446,7 @@ func (img *SdlImgui) renderFrame() {
 // bug described here with suggested fix:
 //
 // https://stackoverflow.com/questions/34967628/sdl2-window-turns-black-on-resize
-func (img *SdlImgui) serviceWindowEvent(ev sdl.Event, userdata interface{}) bool {
+func (img *SdlImgui) serviceWindowEvent(ev sdl.Event, userdata any) bool {
 	switch ev := ev.(type) {
 	case *sdl.WindowEvent:
 		switch ev.Event {

gui/sdlimgui/win_collisions.go

@@ -61,14 +61,14 @@ func (win *winCollisions) debuggerDraw() bool {
 }
 
 func (win *winCollisions) draw() {
-	cxm0p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM0P])
-	cxm1p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM1P])
-	cxp0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXP0FB])
-	cxp1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXP1FB])
-	cxm0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM0FB])
-	cxm1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM1FB])
-	cxblpf, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXBLPF])
-	cxppmm, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXPPMM])
+	cxm0p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM0P])
+	cxm1p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM1P])
+	cxp0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXP0FB])
+	cxp1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXP1FB])
+	cxm0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM0FB])
+	cxm1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM1FB])
+	cxblpf, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXBLPF])
+	cxppmm, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXPPMM])
 
 	if imgui.BeginTableV("##collisions", 2, imgui.TableFlagsNone, imgui.Vec2{}, 0.0) {
 		imgui.TableNextRow()
@@ -79,7 +79,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXM0P", cxm0p, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXM0P], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXM0P], v)
 				})
 			})
 
@@ -91,7 +91,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXM1P", cxm1p, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXM1P], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXM1P], v)
 				})
 			})
 
@@ -103,7 +103,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXP0FB", cxp0fb, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXP0FB], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXP0FB], v)
 				})
 			})
 
@@ -115,7 +115,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXP1FB", cxp1fb, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXP1FB], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXP1FB], v)
 				})
 			})
 
@@ -127,7 +127,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXM0FB", cxm0fb, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXM0FB], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXM0FB], v)
 				})
 			})
 
@@ -139,7 +139,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXM1FB", cxm1fb, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXM1FB], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXM1FB], v)
 				})
 			})
 
@@ -151,7 +151,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXBLPF", cxblpf, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXBLPF], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXBLPF], v)
 				})
 			})
 
@@ -163,7 +163,7 @@ func (win *winCollisions) draw() {
 		drawRegister("##CXPPMM", cxppmm, vcs.TIADrivenPins, win.img.cols.collisionBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.CXPPMM], v)
+					win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.CXPPMM], v)
 				})
 			})
 

gui/sdlimgui/win_dbgscr.go

@@ -699,14 +699,14 @@ func (win *winDbgScr) drawReflectionTooltip() {
 
 			// TODO: these bits are the current bits and not the bits under the cursor
 
-			cxm0p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM0P])
-			cxm1p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM1P])
-			cxp0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXP0FB])
-			cxp1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXP1FB])
-			cxm0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM0FB])
-			cxm1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXM1FB])
-			cxblpf, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXBLPF])
-			cxppmm, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.CXPPMM])
+			cxm0p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM0P])
+			cxm1p, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM1P])
+			cxp0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXP0FB])
+			cxp1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXP1FB])
+			cxm0fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM0FB])
+			cxm1fb, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXM1FB])
+			cxblpf, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXBLPF])
+			cxppmm, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.CXPPMM])
 
 			imguiLabel("CXM0P ")
 			drawRegister("##CXM0P", cxm0p, vcs.TIADrivenPins, win.img.cols.collisionBit, nil)

gui/sdlimgui/win_dbgscr_paint.go

@@ -143,19 +143,19 @@ func (ff *floodFill) resolve(offsetIdx int) {
 		ff.win.img.dbg.PushFunctionImmediate(func() {
 			switch ref.VideoElement {
 			case video.ElementBackground:
-				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddress[cpubus.COLUBK], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
+				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddressByRegister[cpubus.COLUBK], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
 			case video.ElementPlayfield:
 				fallthrough
 			case video.ElementBall:
-				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddress[cpubus.COLUPF], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
+				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddressByRegister[cpubus.COLUPF], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
 			case video.ElementPlayer0:
 				fallthrough
 			case video.ElementMissile0:
-				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddress[cpubus.COLUP0], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
+				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddressByRegister[cpubus.COLUP0], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
 			case video.ElementPlayer1:
 				fallthrough
 			case video.ElementMissile1:
-				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddress[cpubus.COLUP1], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
+				ff.win.img.dbg.PushDeepPoke(cpubus.WriteAddressByRegister[cpubus.COLUP1], px, ff.to, 0xfe, func() { ff.resolve(offsetIdx + 1) })
 			}
 		})
 	})

gui/sdlimgui/win_ports.go

@@ -177,11 +177,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT0")
 
 		imgui.TableNextColumn()
-		inpt0, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT0])
+		inpt0, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT0])
 		drawRegister("##INPT0", inpt0, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT0], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT0], v)
 					if err != nil {
 						panic(err)
 					}
@@ -193,11 +193,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT1")
 
 		imgui.TableNextColumn()
-		inpt1, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT1])
+		inpt1, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT1])
 		drawRegister("##INPT1", inpt1, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT1], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT1], v)
 					if err != nil {
 						panic(err)
 					}
@@ -211,11 +211,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT2")
 
 		imgui.TableNextColumn()
-		inpt2, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT2])
+		inpt2, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT2])
 		drawRegister("##INPT2", inpt2, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT2], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT2], v)
 					if err != nil {
 						panic(err)
 					}
@@ -227,11 +227,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT3")
 
 		imgui.TableNextColumn()
-		inpt3, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT3])
+		inpt3, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT3])
 		drawRegister("##INPT3", inpt3, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT3], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT3], v)
 					if err != nil {
 						panic(err)
 					}
@@ -245,11 +245,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT4")
 
 		imgui.TableNextColumn()
-		inpt4, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT4])
+		inpt4, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT4])
 		drawRegister("##INPT4", inpt4, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT4], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT4], v)
 					if err != nil {
 						panic(err)
 					}
@@ -261,11 +261,11 @@ func (win *winPorts) draw() {
 		imguiLabel("INPT5")
 
 		imgui.TableNextColumn()
-		inpt5, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddress[cpubus.INPT5])
+		inpt5, _ := win.img.cache.VCS.Mem.Peek(cpubus.ReadAddressByRegister[cpubus.INPT5])
 		drawRegister("##INPT5", inpt5, vcs.TIADrivenPins, win.img.cols.portsBit,
 			func(v uint8) {
 				win.img.dbg.PushFunction(func() {
-					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddress[cpubus.INPT5], v)
+					err := win.img.dbg.VCS().Mem.Poke(cpubus.ReadAddressByRegister[cpubus.INPT5], v)
 					if err != nil {
 						panic(err)
 					}