Implemented and tested memory views.

src/boilerplate.jl

@@ -4,6 +4,9 @@ Here we keep some macros for doing boilerplate code generation...
 # TODO deal with page crossings!!!
 
 opfuncname(opcode::UInt8) = Symbol(string("op", hexstring(opcode), "!"))
+opstring(fname::Symbol) = strip(string(fname), '!')
+
+assemblydict(opname::Symbol, opcode::UInt8) = :(ASSEMBLY_DICT[$(opstring(opname))] = $opcode)
 
 
 function opdict(opcode::UInt8, nbytes::Int, ncycles::Int)
@@ -124,17 +127,16 @@ end
 
 
 
-
-
-
 macro opdef(opname::Symbol, defblock::Expr)
     @capture(defblock, begin defs__ end)
     defs = [tuple(ex.args...) for ex ∈ defs]
     funcdefs = [opdef(d[1], opname, d[2]) for d ∈ defs]
     dictries = [opdict(d[2], d[3], d[4]) for d ∈ defs]
+    assemblies = [assemblydict(opname, d[2]) for d ∈ defs]
     esc(quote
         $(funcdefs...)
         $(dictries...)
+        $(assemblies...)
     end)
 end
 

src/memory.jl

@@ -47,6 +47,8 @@ function Base.setindex!(m::Memory, v::AbstractVector{UInt8}, idx::AbstractVector
     m.v[idx+one(T)] = v
 end
 
+Base.view(m::Memory, idx) = view(m.v, idx + 0x0001)
+Base.view(m::Memory, ptr::Π) = view(m, ptr.addr)
 
 #===================================================================================================
     <referencing>
@@ -55,6 +57,9 @@ dereference{T}(ptr::Π{T}, m::Memory) = m[ptr]
 deref(ptr::Π, m::Memory) = dereference(ptr, m)
 (↦)(ptr::Π, m::Memory) = dereference(ptr, m)  # this symbol is \mapsto
 
+# note that the views always return SubArray, even for a single element
+derefview(ptr::Π, m::Memory) = view(m, ptr)
+
 dereference(::Type{UInt8}, ptr::Π, m::Memory)::UInt8 = dereference(ptr, Π)
 deref(::Type{UInt8}, ptr::Π, m::Memory) = dereference(ptr, Π)
 
@@ -75,6 +80,13 @@ function dereference{T}(ptr::Π{T}, m::Memory, ℓ::Integer)
 end
 deref(ptr::Π, m::Memory, ℓ::Integer) = dereference(ptr, m, ℓ)
 
+# returns SubArray
+function derefview{T}(ptr::Π{T}, m::Memory, ℓ::Integer)
+    start_idx = ptr.addr + one(T)
+    end_idx = start_idx + ℓ - 1
+    view(m.v, start_idx:end_idx)
+end
+
 store!{T}(m::Memory, ptr::Π{T}, val::UInt8) = (m[ptr.addr] = val)
 # this stores backwards from the supplied memory address
 function storeback!{T}(m::Memory, ptr::Π{T}, val::UInt16)

src/opcodes.jl

@@ -12,6 +12,11 @@ bytes2arg(bytes::AbstractVector{UInt8}) = bincat(bytes[1], bytes[2])
 # this gets the arguments to the op given the pointer to the instruction and nbytes total
 deref_opargs(cs::Chipset, ptr::Π, nbytes::Integer) = deref(ptr+0x01, cs.ram, nbytes-1)
 
+# this has been tested and so far yields inferior performance
+function derefview_opargs(cs::Chipset, ptr::Π, nbytes::Integer)
+    derefview(ptr+0x01, cs.ram, nbytes-1)
+end
+
 
 #===================================================================================================
     <execution>
@@ -54,6 +59,9 @@ const OpFunc = FunctionWrapper{UInt8,Tuple{Chipset,Vector{UInt8}}}
 # for the time being opcode 0x00 would throw an error
 const OPCODES = Vector{Tuple{OpFunc,Int,Int}}(N_OPCODES)
 
+# this is for the assembler
+const ASSEMBLY_DICT = Dict{String,UInt8}(); sizehint!(ASSEMBLY_DICT, N_OPCODES)
+
 # format is
 #    mode, opcode, nbytes, ncycles
 

test/opcodes.jl

@@ -30,6 +30,7 @@ function makechipset()
     cs
 end
 
+# TODO investigate allocs!!!
 
 function makebenches()
     ref = @benchmarkable begin