some primitive MONitor thing

assets/bios/mon.js

@@ -9,6 +9,7 @@ M (hex addr) : shows a byte on the address
 N : Increment the memory pointer, then show the byte on the address
 W (hex string) : write given byte string to the memory starting from the current pointer. If the length of the
                     hex string is odd, error will be thrown. The pointer will auto-increment.
+P : prints current pointer
 
 Prompt on successful: .
 Prompt on error: ?
@@ -16,86 +17,125 @@ Prompt on error: ?
  */
 
 
-let uhex = (i, len) => { return (i >>> 0).toString(16).toUpperCase().padStart(len||2, '0').slice(-(len||2)) }
+let uhex = (i, t) => (i >>> 0).toString(16).toUpperCase().padStart(t||2, '0').slice(-(t||2))
+
+sys.sleep(256)
 
 println(`/MONITOR/  ${sys.maxmem()} BYTES SYSTEM`)
 
 let prompt = ['?','.']
 
-let mode = "M"
-let ptr = 0
-let previousError = undefined
+let P = 0
+let pE = undefined
+
+let peek = (p) => {
+    // TODO add open bus behaviour
+    try {
+        return sys.peek(p)
+    }
+    catch (e) {
+        return (p & 0xFFFFFF) >>> 16
+    }
+}
 
 while (1) {
-    print(prompt[+!previousError])
+    print(prompt[+!pE])
     let buf = read().split(' ')
     let cmd = buf[0].toUpperCase()
 
+    let putNinc = b => { if (P >= 0) { sys.poke(P++, b) } else { sys.poke(P--, b) } }
+    let getNinc = () => { if (P >= 0) { return sys.peek(P++) } else { return sys.poke(P--) } }
+
     if ("M" == cmd) {
         let addr = parseInt(buf[1], 16)
         let addr2 = parseInt(buf[2], 16)
         if (Number.isNaN(addr)) {
-            println((uhex(ptr, 4))+' : '+uhex(sys.peek(ptr)))
-            previousError = undefined
+            println((uhex(P, 6))+' : '+uhex(peek(P)))
+            pE = undefined
         }
         else {
-            let oldptr = ptr
-            ptr = addr
+            let oldP = P
+            P = addr
             if (Number.isNaN(addr2)) {
-                println(uhex(sys.peek(ptr)))
-                previousError = undefined
+                println(uhex(peek(P)))
+                pE = undefined
             }
             else if (Math.abs(addr2) <= Math.abs(addr))
-                previousError = "Range error: end is greater than start"
+                pE = "Range error: end is greater than start"
             else {
                 for (let i = 0; i <= Math.abs(addr2) - Math.abs(addr); i++) {
                     if (i % 16 == 0 && i > 0) { println() }
-                    if (i % 16 == 0) { print((uhex(ptr, 4))+' : ') }
-                    print(uhex(sys.peek(ptr)) + ' ')
-                    if (addr < 0 && addr2 < 0) { ptr-- } else { ptr++ }
+                    if (i % 16 == 0) { print((uhex(P, 6))+' : ') }
+                    print(uhex(peek(P)) + ' ')
+                    if (addr < 0 && addr2 < 0) { P-- } else { P++ }
                 }
                 println()
-                previousError = undefined
+                pE = undefined
             }
-            ptr = oldptr
+            P = oldP
         }
     }
     else if ("N" == cmd) {
-        ptr++
-        println((uhex(ptr, 4))+' : '+uhex(sys.peek(ptr)))
-        previousError = undefined
+        if (P >= 0) { P++ } else { P-- }
+        println((uhex(P, 6))+' : '+uhex(peek(P)))
+        pE = undefined
     }
     else if ("J" == cmd) {
         let addr = parseInt(buf[1], 16)
         if (Number.isNaN(addr))
-            previousError = "Jump address unspecified"
+            pE = "Jump address unspecified"
         else {
-            ptr = addr
-            previousError = undefined
+            P = addr
+            pE = undefined
         }
     }
+    else if ("P" == cmd) {
+        println(` ${P} ($${uhex(P, 6)})`)
+        pE = undefined
+    }
     else if ("W" == cmd) {
         let arg = buf[1]
         if (arg == undefined)
-            previousError = "No arguments given"
+            pE = "No arguments given"
         else if (arg.length % 2 == 1)
-            previousError = "Length of byte string is odd number"
+            pE = "Length of byte string is odd number"
         else {
             for (let i = 0; i < arg.length; i += 2) {
                 let b = parseInt(arg.charAt(i)+arg.charAt(i+1), 16)
-                sys.poke(ptr++, b)
+                putNinc(b)
             }
-            previousError = undefined
+            pE = undefined
         }
     }
+    else if ("R" == cmd) {
+        // parse and run CUM image
+        // 0xA5 [payload size in 24 bit] [payload]
+
+        let hdr = sys.peek(P)
+
+        if (hdr != 0xA5) {
+            pE = "Image is not executable"
+        }
+        else {
+//            try {
+                let src = sys.toObjectCode(P)
+                pE = new Function(src)()
+//            }
+//            catch (e) {
+//                pE = e
+//                serial.printerr(e)
+//            }
+        }
+
+    }
     else if ('' == cmd) {
         // do nothing
     }
     else if ('?' == cmd) {
-        println(previousError)
+        println(pE)
     }
     else {
-        previousError = "Unknown command"
+        pE = "Unknown command"
     }
 
 }