clojure: implementing jmp in a simple stack based vm - clojure

Question

New to clojure, I am currently implementing a simple stack based vm in clojure just for practice and fun.
I tried to be as functional as possible. And I constructed the following code:
(defmulti execute-byte (fn [stack b] b))
(defmethod execute-byte 0x00 [stack _] ;; nop
stack)
(defmethod execute-byte 0x01 [stack _] ;; unimplemented
())
(defmethod execute-byte 0x02 [stack _] ;; del
(rest stack))
(defmethod execute-byte 0x03 [stack _] ;; jmp, honestly I don't know how to implement this
())
(defmethod execute-byte 0x10 [stack _] ;; add
(let [f (first stack)
s (second stack)]
(cons (+ f s) (nthrest stack 2))))
(defmethod execute-byte 0x11 [stack _] ;; sub
(let [f (first stack)
s (second stack)]
(cons (- f s) (nthrest stack 2))))
(defmethod execute-byte 0x12 [stack _] ;; multi
(let [f (first stack)
s (second stack)]
(cons (* f s) (nthrest stack 2))))
(defmethod execute-byte 0x13 [stack _] ;; div
(let [f (first stack)
s (second stack)]
(cons (/ f s) (nthrest stack 2))))
(defmethod execute-byte :default [stack bc] ;; just a testing workaround
(cons bc stack))
(defn execute-single-stack-step
[[inst stack]]
[(rest inst) (execute-byte stack (first inst))])
(defn execute-bytes
[inst stack step]
(last (take step (iterate execute-single-stack-step [inst stack]))))
and it kind of works. "Kind of" because it currently functions only as a reversed polish notation calculator
(execute-bytes [0x50 0x50 0x10] [] 4) ;; equivalent to [0x50 0x50 +] and gets [() (160)] as a result
I want the vm at least to be able to perform "jmp", reading a value popped from the stack and move the "cursor" to where the value refers, but it seems impossible with my current design. (the current design functions only like "reduce", and there is no such "cursor" at all).
For a better representation of the method I used
(execute-bytes [0x50 0x50 0x10] [] 1)
;;[[80 80 16] []]
(execute-bytes [0x50 0x50 0x10] [] 2)
;;[(80 16) (80)]
(execute-bytes [0x50 0x50 0x10] [] 3)
;;[(16) (80 80)]
(execute-bytes [0x50 0x50 0x10] [] 4)
;;[() (160)]
so is there any way I can implement "jmp" by this method?

Answer 1

I managed to make it work.
For a demonstration of the result:
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 1) ;; push 0x10 push 0x10 add jump 0x00
[[] [1 16 1 16 16 3 0] 0]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 2)
[(16) [1 16 1 16 16 3 0] 2]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 3)
[(16 16) [1 16 1 16 16 3 0] 4]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 4)
[(32) [1 16 1 16 16 3 0] 5]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 5)
[(32) [1 16 1 16 16 3 0] 0]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 6)
[(16 32) [1 16 1 16 16 3 0] 2]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 7)
[(16 16 32) [1 16 1 16 16 3 0] 4]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 8)
[(32 32) [1 16 1 16 16 3 0] 5]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 9)
[(32 32) [1 16 1 16 16 3 0] 0]
lunadial.logic> (execute-bytes [0x01 0x10 0x01 0x10 0x10 0x03 0x00] [] 10)
[(16 32 32) [1 16 1 16 16 3 0] 2]
and the code:
(defmulti execute-byte (fn [stack inst point] (nth inst point)))
(defmethod execute-byte 0x00 [stack inst point] ;; nop
[stack inst (inc point)])
(defmethod execute-byte 0x01 [stack inst point] ;; push
(let [the-bc-after (nth inst (inc point))]
[(cons the-bc-after stack) inst (inc (inc point))]))
(defmethod execute-byte 0x02 [stack inst point] ;; del
[(rest stack) inst (inc point)])
(defmethod execute-byte 0x03 [stack inst point] ;; jmp
(let [the-bc-after (nth inst (inc point))]
[stack inst the-bc-after]))
(defmethod execute-byte 0x10 [stack inst point] ;; add
(let [f (first stack)
s (second stack)]
[(cons (+ f s) (nthrest stack 2)) inst (inc point)]))
(defmethod execute-byte 0x11 [stack inst point] ;; sub
(let [f (first stack)
s (second stack)]
[(cons (- f s) (nthrest stack 2)) inst (inc point)]))
(defmethod execute-byte 0x12 [stack inst point] ;; multi
(let [f (first stack)
s (second stack)]
[(cons (* f s) (nthrest stack 2)) inst (inc point)]))
(defmethod execute-byte 0x13 [stack inst point] ;; div
(let [f (first stack)
s (second stack)]
[(cons (/ f s) (nthrest stack 2)) inst (inc point)]))
(defmethod execute-byte :default [stack inst point] ;; just a testing workaround
[(cons (nth inst point) stack) inst (inc point)])
(defn execute-single-stack-step ;; the iterator wrapper for the multimethod
[[stack inst point]]
(execute-byte stack inst point))
(defn execute-bytes
[inst stack step]
(last (take step (iterate execute-single-stack-step [stack inst 0]))))
I just need to pass all the instructions and pointer.. and everything into the function, and modify the multimethods. It does not look elegant, but it works.