Sorted out addressing modes.

src/Sim6502.jl

@@ -1,11 +1,17 @@
+__precompile__(true)
+
 module Sim6502
 
+using MacroTools
+
 import Base.fetch
+import Base.pointer
 import Base: +, -
 
 include("utils.jl")
 include("cpu.jl")
 include("memory.jl")
+include("boilerplate.jl")
 include("instructions.jl")
 
 end # module

src/boilerplate.jl

@@ -0,0 +1,4 @@
+#===================================================================================================
+Here we keep some macros for doing boilerplate code generation...
+===================================================================================================#
+

src/cpu.jl

@@ -22,7 +22,7 @@ fetch(c::CPU, reg::Symbol) = getfield(c, reg)
 store!(c::CPU, reg::Symbol, val::Integer) = setfield!(c, reg, val)
 export fetch, store!
 
-counter!(c::CPU, ℓ::UInt8) = (c.PC += ℓ)
+counter!(c::CPU, ℓ::Unsigned) = (c.PC += ℓ)
 export counter!
 
 

src/instructions.jl

@@ -1,8 +1,44 @@
-
-
+#=====================================================================================================
+Some conventions:
+    All instructions are based on methods where arguments are passed explicitly (rather than from
+    the stack). These base methods affect the registers (or memory) as they should, but do not
+    affect the program counter as they are not reading from the stack.
+
+    Zero-argument instruction methods read memory from the stack, and affect the PC register as
+    they should.
+=====================================================================================================#
+
+# these can be passed to instructions to specify addressing modes when appropriate
+abstract type AddressingMode end
+abstract type DirectMode <: AddressingMode end
+abstract type IndirectMode <: AddressingMode end
+struct Direct <: DirectMode end
+struct DirectX <: DirectMode end
+struct DirectY <: DirectMode end
+struct IndirectX <: IndirectMode end
+struct IndirectY <: IndirectMode end
+
+export AddressingMode, DirectMode, IndirectMode, Direct, DirectX, DirectY, IndirectX, IndirectY
+
+
+# utility functions used frequently in instructions
 checkNflag!(c::CPU, val::UInt8) = val ≥ 0x80 ? status!(c, :N, true) : status!(c, :N, false)
 checkZflag!(c::CPU, val::UInt8) = val == 0x00 ? status!(c, :Z, true) : status!(c, :Z, false)
 
+# pointers that occur in different addressing modes
+pointer(::Type{Direct}, ptr::Π, c::CPU, m::Memory) = ptr
+pointer(::Type{DirectX}, ptr::Π, c::CPU, m::Memory) = ptr + c.X
+pointer(::Type{DirectY}, ptr::Π, c::CPU, m::Memory) = ptr + c.Y
+pointer(::Type{IndirectX}, ptr::Π, c::CPU, m::Memory) = Π(deref(UInt16, ptr + c.X, m))
+pointer(::Type{IndirectY}, ptr::Π, c::CPU, m::Memory) = Π(deref(UInt16, ptr, m) + c.Y)
+
+# these dereference in a way appropriate for Indirect
+deref{T<:AddressingMode}(::Type{T}, ptr::Π, c::CPU, m::Memory) = deref(pointer(T, ptr, c, m), m)
+
+function store!{T<:AddressingMode}(::Type{T}, ptr::Π, c::CPU, m::Memory, val::UInt8)
+    store!(m, pointer(T, ptr, c, m), val)
+end
+
 
 #===================================================================================================
     <load, store instructions>
@@ -13,40 +49,44 @@ function ld!(c::CPU, reg::Symbol, val::UInt8)
     v = store!(c, reg, val)
     checkNflag!(c, v)
     checkZflag!(c, v)
-    counter!(c, 0x02)
     v
 end
 
-# immediate mode
+function ld!{T<:AddressingMode}(c::CPU, m::Memory, reg::Symbol, ::Type{T}, ptr::Π)
+    ld!(c, reg, deref(T, ptr, c, m))
+end
+ld!(c::CPU, m::Memory, reg::Symbol, ptr::Π) = ld!(c, m, reg, Direct, ptr)
+
+# TODO get rid of boilerplate stuff
 lda!(c::CPU, val::UInt8) = ld!(c, :A, val)
 ldx!(c::CPU, val::UInt8) = ld!(c, :X, val)
 ldy!(c::CPU, val::UInt8) = ld!(c, :Y, val)
 
-# template for ld instructions in zero page or absolute mode
-ld!(c::CPU, m::Memory, reg::Symbol, ptr::Π) = ld!(c, reg, ptr ↦ m)
-
-lda!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :A, ptr)
-ldx!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :X, ptr)
-ldy!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :Y, ptr)
+lda!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = ld!(c, m, :A, T, ptr)
+ldx!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = ld!(c, m, :X, T, ptr)
+ldy!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = ld!(c, m, :Y, T, ptr)
 
-# zero page,X,Y and absolute,X,Y; note this also works with A, even though that's not a real instruction!
-ld!(c::CPU, m::Memory, reg::Symbol, ptr::Π, idx::Symbol) = ld!(c, m, reg, (ptr + fetch(c,idx)) ↦ m)
-
-lda!(c::CPU, m::Memory, ptr::Π, idx::Symbol) = ld!(c, m, :A, ptr, idx)
-ldx!(c::CPU, m::Memory, ptr::Π, idx::Symbol) = ld!(c, m, :X, ptr, idx)
-ldy!(c::CPU, m::Memory, ptr::Π, idx::Symbol) = ld!(c, m, :Y, ptr, idx)
+lda!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :A, Direct, ptr)
+ldx!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :X, Direct, ptr)
+ldy!(c::CPU, m::Memory, ptr::Π) = ld!(c, m, :Y, Direct, ptr)
 
 export ld!, lda!, ldx!, ldy!
 
 
 #---------------------STA, STX, STY------------------------------------------------
 # template for st in zero page or absolute mode
-st!(c::CPU, m::Memory, reg::Symbol, ptr::Π) = store!(m, ptr, fetch(c, reg))
+function st!(c::CPU, m::Memory, reg::Symbol, ::Type{T}, ptr::Π) where T<:AddressingMode
+    store!(m, pointer(T, ptr, c, m), fetch(c, reg))
+end
+st!(c::CPU, m::Memory, reg::Symbol, ptr::Π) = st!(c, m, reg, Direct, ptr)
+
+sta!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = st!(c, m, :A, T, ptr)
+stx!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = st!(c, m, :X, T, ptr)
+sty!{T<:AddressingMode}(c::CPU, m::Memory, ::Type{T}, ptr::Π) = st!(c, m, :Y, T, ptr)
 
-# zero page or absolute mode
-sta!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :A, ptr)
-stx!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :X, ptr)
-sty!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :Y, ptr)
+sta!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :A, Direct, ptr)
+stx!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :X, Direct, ptr)
+sty!(c::CPU, m::Memory, ptr::Π) = st!(c, m, :Y, Direct, ptr)
 
 export st!, sta!, stx!, sty!
 #===================================================================================================

src/memory.jl

@@ -6,40 +6,71 @@ struct Memory
 
     Memory(ℓ::Integer=65536) = Memory(zeros(UInt8, ℓ))
 end
+export Memory
 
 reset!(m::Memory) = (m.v .= zeros(UInt8, length(m.v)))
+export reset!
 
+fetch(m::Memory, idx::T) where T<:Unsigned = m.v[idx+one(T)]
+fetch(m::Memory, idx::AbstractVector{T}) where T<:Unsigned = m.v[idx+one(T)]
+
+Base.getindex(m::Memory, T) = fetch(m, T)
+
+Base.setindex!(m::Memory, val::UInt8, idx::T) where T<:Unsigned = (m.v[idx+one(T)] = val)
 
 
 #===================================================================================================
     <pointers>
 ===================================================================================================#
 abstract type AbstractΠ end  # uses capital Π
 
+# note that, somewhat confusingly, T is the type of the pointer, not the value being pointed to
 type Π{T<:Unsigned} <: AbstractΠ
-    addr::T
+    addr::UInt16
 
     Π{T}(addr::Unsigned) where T<:Unsigned = new(addr)
 end
 export Π
 
+Π(addr::T) where T<:Unsigned = Π{T}(addr)
+
 const Π8 = Π{UInt8}  # zero page pointer
 const Π16 = Π{UInt16}  # standard 6502 memory pointer
 export Π8, Π16
 
 dereference{T}(ptr::Π{T}, m::Memory) = m.v[ptr.addr+one(T)]
 deref(ptr::Π, m::Memory) = dereference(ptr, m)
-↦(ptr::Π, m::Memory) = dereference(ptr, m)  # this symbol is \mapsto
+(↦)(ptr::Π, m::Memory) = dereference(ptr, m)  # this symbol is \mapsto
+
+dereference(::Type{UInt8}, ptr::Π, m::Memory)::UInt8 = dereference(ptr, Π)
+deref(::Type{UInt8}, ptr::Π, m::Memory) = dereference(ptr, Π)
+
+# these are for dereferencing length 2 arrays into single UInt16's
+function dereference{T}(::Type{UInt16}, ptr::Π{T}, m::Memory)::UInt16
+    least_sig = deref(ptr, m)
+    most_sig = deref(ptr + one(T), m)
+    (convert(UInt16, most_sig) << 8) + least_sig
+end
+deref(::Type{UInt16}, ptr::Π, m::Memory) = dereference(UInt16, ptr, m)
+(⇾)(ptr::Π, m::Memory) = dereference(UInt16, ptr, m)  # this symbol is \rightarrowtriangle
+
+# dereference arrays
+function dereference{T}(ptr::Π{T}, m::Memory, ℓ::Integer)
+    start_idx = ptr.addr + one(T)
+    end_idx = start_idx + ℓ - 1
+    m.v[start_idx:end_idx]
+end
+deref(ptr::Π, m::Memory, ℓ::Integer) = dereference(ptr, m, ℓ)
 
-store!(m::Memory, ptr::Π{T}, val::UInt8) = (m.v[ptr.addr+one(T)] = val)
+store!{T}(m::Memory, ptr::Π{T}, val::UInt8) = (m.v[ptr.addr+one(T)] = val)
 
 (+){T}(ptr1::Π{T}, ptr2::Π{T}) = Π{T}(ptr1.addr + ptr2.addr)
 (-){T}(ptr1::Π{T}, ptr2::Π{T}) = Π{T}(ptr1.addr - ptr2.addr)
 
 (+){T}(ptr::Π{T}, val::Unsigned) = Π{T}(ptr.addr + convert(T, val))
 (-){T}(ptr::Π{T}, val::Unsigned) = Π{T}(ptr.addr - convert(T, val))
 
-export dereference, deref, ↦, store!, +, -
+export dereference, deref, ↦, ⇾, store!, +, -
 #===================================================================================================
     </pointers>
 ===================================================================================================#

test/instructions.jl

@@ -1,25 +1,19 @@
 using Sim6502
+using BenchmarkTools
 
 c = CPU()
+m = Memory()
 
+macro p(expr)
+    esc(:($expr; println(c)))
+end
 
-tick!(c::CPU) = (adc!(c, 0xff); c)
-
-println(c)
-adc!(c, 0xff)
-println(c)
-adc!(c, 0x01)
-println(c)
-adc!(c, 0xff)
-println(c)
-adc!(c, 0xff)
-println(c)
-
-
-lda!(c, 0xa0)
-println(c)
-ldx!(c, 0x01)
-println(c)
-ldy!(c, 0x02)
-println(c)
+@p ldx!(c, 0x01)
+@p lda!(c, 0x05)
+@p sta!(c, m, Π(0x01))
+@p lda!(c, 0x06)
+@p sta!(c, m, Π(0x02))
+@p ldy!(c, 0x0a)
+@p sty!(c, m, Π(0x0605))
+@p lda!(c, m, IndirectX, Π(0x00))