bradford-hamilton-apple-1/internal/vm/mem.go

package vm

// block represents a 64kiB memory block
type block [64 * 1024]byte

func newBlock() [64 * 1024]byte {
	return [64 * 1024]byte{}
}

// load loads a program into memory at the provided address space
func (b block) load(addr uint16, data []byte) {
	end := int(addr) + len(data)

	for i := int(addr); i < end; i++ {
		b[int(addr)+i] = data[i]
	}
}
internal/vm: add the first few opcode handlers Still a little iffy on the code design, although this seems like it could be a desirable pattern. This way I would have to write an opcode handler for all the cases and register it to the “op”. That way step calls are super simple from Appleone’s point of view -> get the operation and that operation has everything needed to execute on the vm. 2020-05-30 17:03:58 +00:00			`package vm`

			`// block represents a 64kiB memory block`
			`type block [64 * 1024]byte`

			`func newBlock() [64 * 1024]byte {`
			`return [64 * 1024]byte{}`
			`}`

			`// load loads a program into memory at the provided address space`
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. 2020-06-01 03:47:05 +00:00			`func (b block) load(addr uint16, data []byte) {`
internal/vm: add the first few opcode handlers Still a little iffy on the code design, although this seems like it could be a desirable pattern. This way I would have to write an opcode handler for all the cases and register it to the “op”. That way step calls are super simple from Appleone’s point of view -> get the operation and that operation has everything needed to execute on the vm. 2020-05-30 17:03:58 +00:00			`end := int(addr) + len(data)`

			`for i := int(addr); i < end; i++ {`
			`b[int(addr)+i] = data[i]`
			`}`
			`}`