Simplified file structure

src/cpu/CPU.go

@@ -0,0 +1,11 @@
+package cpu
+
+// CPU represents the processor.
+type CPU struct {
+	All           []Register
+	General       []Register
+	Input         []Register
+	Output        []Register
+	SyscallInput  []Register
+	SyscallOutput []Register
+}

src/cpu/Register.go

@@ -0,0 +1,11 @@
+package cpu
+
+import "fmt"
+
+// Register represents the number of the register.
+type Register uint8
+
+// String returns the human readable name of the register.
+func (r Register) String() string {
+	return fmt.Sprintf("r%d", r)
+}

src/cpu/Register_test.go

@@ -0,0 +1,13 @@
+package cpu_test
+
+import (
+	"testing"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+	"git.akyoto.dev/go/assert"
+)
+
+func TestRegisterString(t *testing.T) {
+	register := cpu.Register(1)
+	assert.Equal(t, "r1", register.String())
+}

src/cpu/State.go

@@ -0,0 +1,55 @@
+package cpu
+
+// State contains information about which registers are currently in use.
+type State struct {
+	Reserved uint64
+	Used     uint64
+}
+
+// Free will reset the reserved and used status which means the register can be allocated again.
+func (s *State) Free(reg Register) {
+	s.Reserved &= ^(1 << reg)
+	s.Used &= ^(1 << reg)
+}
+
+// IsReserved returns true if the register was marked for future use.
+func (s *State) IsReserved(reg Register) bool {
+	return s.Reserved&(1<<reg) != 0
+}
+
+// IsUsed returns true if the register is currently in use and holds a value.
+func (s *State) IsUsed(reg Register) bool {
+	return s.Used&(1<<reg) != 0
+}
+
+// Reserve reserves a register for future use.
+func (s *State) Reserve(reg Register) {
+	s.Reserved |= (1 << reg)
+}
+
+// Use marks a register to be currently in use which means it must be preserved across function calls.
+func (s *State) Use(reg Register) {
+	s.Used |= (1 << reg)
+}
+
+// FindFree tries to find a free register in the given slice of registers.
+func (s *State) FindFree(registers []Register) (Register, bool) {
+	for _, reg := range registers {
+		if !s.IsReserved(reg) && !s.IsUsed(reg) {
+			return reg, true
+		}
+	}
+
+	return 0, false
+}
+
+// MustFindFree tries to find a free register and panics if it could not be found.
+func (s *State) MustFindFree(registers []Register) Register {
+	register, exists := s.FindFree(registers)
+
+	if !exists {
+		panic("no free registers")
+	}
+
+	return register
+}

src/cpu/State_test.go

@@ -0,0 +1,45 @@
+package cpu_test
+
+import (
+	"testing"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+	"git.akyoto.dev/go/assert"
+)
+
+func TestRegisterState(t *testing.T) {
+	s := cpu.State{}
+	assert.False(t, s.IsReserved(0))
+	assert.False(t, s.IsUsed(0))
+	s.Reserve(0)
+	assert.True(t, s.IsReserved(0))
+	assert.False(t, s.IsUsed(0))
+	s.Use(0)
+	assert.True(t, s.IsReserved(0))
+	assert.True(t, s.IsUsed(0))
+	s.Free(0)
+	assert.False(t, s.IsReserved(0))
+	assert.False(t, s.IsUsed(0))
+}
+
+func TestFindFree(t *testing.T) {
+	s := cpu.State{}
+	s.Reserve(0)
+	s.Use(1)
+
+	reg, found := s.FindFree([]cpu.Register{0, 1, 2, 3})
+	assert.True(t, found)
+	assert.Equal(t, reg, 2)
+
+	_, found = s.FindFree([]cpu.Register{0, 1})
+	assert.False(t, found)
+}
+
+func TestMustFindFree(t *testing.T) {
+	s := cpu.State{}
+	s.Reserve(0)
+	s.Use(1)
+
+	reg := s.MustFindFree([]cpu.Register{0, 1, 2, 3})
+	assert.Equal(t, reg, 2)
+}