Indent with tabs.

1 files changed, 97 insertions, 11 deletions

diff --git a/main.myr b/main.myr
index 0684871..feac70c 100644
--- a/main.myr
+++ b/main.myr
@@ -24,7 +24,7 @@ const loadprg = {b, fname
     match std.open(fname, std.Oread)
     | `std.Ok(n): fd = n
     | `std.Err(errno):
-        std.die(std.fmt("could not open {}\n", fname))
+        std.fatal("could not open {}\n", fname)
     ;;
 
     buf = std.slalloc(0xfff - 0x200)
@@ -34,7 +34,7 @@ const loadprg = {b, fname
             b#[i + 0x200] = (buf[i] : uint8)
         ;;
     | `std.Err(n):
-        std.die(std.fmt("could not read {}\n", fname))
+        std.fatal("could not read {}\n", fname)
     ;;
 }
 
@@ -61,13 +61,35 @@ const main = {
     var sound : uint8 = 0
 
     clrscr(&gfx, scrsz)
-    loadprg(&mem, "/home/jakob/Airplane.ch8")
+    loadprg(&mem, "/tmp/UFO")
 
     var opcode, arg
 
     while true
+        sdl.delay(1000)
         opcode = mem[pc]
         arg = mem[pc + 1]
+        std.put("\x1b[H\x1b[2J")
+        std.put("v0: {}\n", reg[0])
+        std.put("v1: {}\n", reg[1])
+        std.put("v2: {}\n", reg[2])
+        std.put("v3: {}\n", reg[3])
+        std.put("v4: {}\n", reg[4])
+        std.put("v5: {}\n", reg[5])
+        std.put("v6: {}\n", reg[6])
+        std.put("v7: {}\n", reg[7])
+        std.put("v8: {}\n", reg[8])
+        std.put("v9: {}\n", reg[9])
+        std.put("va: {}\n", reg[10])
+        std.put("vb: {}\n", reg[11])
+        std.put("vc: {}\n", reg[12])
+        std.put("vd: {}\n", reg[13])
+        std.put("ve: {}\n", reg[14])
+        std.put("vf: {}\n", reg[15])
+        std.put("\n")
+        std.put("I: {}, d: {}, s: {}\n", I, delay, sound)
+        std.put("sp: {}, stk: {}\n", sp, stk)
+        std.put("{p=0,x}: {p=0,x} {p=0,x}\n", pc, opcode, arg)
         match (opcode & 0xf0) >> 4
         | 0x0:
             // CLS
@@ -82,23 +104,25 @@ const main = {
                 sp--
             // SYS
             else
-                std.die("RCA 1802 SYS unimplemted\n")
+                std.die("RCA 1802 SYS unimplemted")
             ;;
         // JP
         | 0x1:
             pc = (opcode & 0x0f : uint16)
             pc <<= 8
             pc |= (arg : uint16)
+            pc -= 2
         // CALL
         | 0x2:
             sp++
             if sp >= stksz
-                std.die("stack overflow\n")
+                std.die("stack overflow")
             ;;
             stk[sp] = pc
             pc = (opcode & 0x0f : uint16)
             pc <<= 8
             pc |= (arg : uint16)
+            pc -= 2
         // SE
         | 0x3:
             if reg[opcode & 0x0f] == arg
@@ -166,7 +190,7 @@ const main = {
             | 0xe:
                 reg[0xf] = reg[opcode & 0x0f] & (1 << 7)
                 reg[opcode & 0x0f] <<= 1
-            | _: std.die("unimplemented opcode\n")
+            | _: std.die("unimplemented opcode")
             ;;
         // SNE
         | 0x9:
@@ -184,17 +208,79 @@ const main = {
             pc <<= 8
             pc |= (arg : uint16)
             pc += (reg[0] : uint16)
+            pc -= 2
         // RND
         | 0xc:
-            reg[opcode & 0x0f] = std.rand(0, 256) & arg
-        | _ : std.die("unimplemented opcode\n")
+            // HACK: SIGFPE when calling std.rand(0, 256)
+            reg[opcode & 0x0f] = (std.rand(0, 255) + std.rand(0, 2)) & arg
+        // DRW
+        | 0xd:
+            var x = (reg[opcode & 0x0f] : uint16)
+            var y = (reg[(arg & 0xf0) >> 8] : uint16)
+            var n = (arg & 0x0f : uint16)
+            var i, j
+            for i = 0; i < n; i++;
+                for j = 0; j < 8; j++
+                    if (y + i) * scrwidth + x + j < scrsz
+                        if mem[I + i * 8 + j] != 0
+                            gfx[(y + i) * scrwidth + x + j] = 0xff
+                        else
+                            gfx[(y + i) * scrwidth + x + j] = 0x00
+                        ;;
+                    ;;
+                ;;
+            ;;
+            sdl.update(tex, (gfx[:] : void#), 64)
+            sdl.copy(r, tex)
+            sdl.present(r)
+        | 0xe:
+            // SKP
+            if arg == 0x9e
+            // SKNP
+            elif arg == 0xa1
+                pc += 2
+            else
+                std.die("unimplemented opcode")
+            ;;
+        | 0xf:
+            match arg
+            | 0x07:
+                reg[opcode & 0x0f] = delay
+            | 0x0a:
+                std.die("unimplemented opcode")
+            | 0x15:
+                delay = reg[opcode & 0x0f]
+            | 0x18:
+                sound = reg[opcode & 0x0f]
+            | 0x1e:
+                // TODO: Deal with overflow
+                I += (reg[opcode & 0x0f] : uint16)
+            | 0x29:
+                // TODO
+                I = 0
+            | 0x33:
+                // TODO
+            | 0x55:
+                // TODO
+            | 0x65:
+                // TODO
+            | _:
+                std.die("unimplemented opcode")
+            ;;
+        | _ : std.die("unimplemented opcode")
         ;;
         pc += 2
+        if delay > 0
+            delay--
+        ;;
+        if sound > 0
+            sound--
+        ;;
     ;;
 
-    sdl.update(tex, (gfx[:] : void#), 64)
-    sdl.copy(r, tex)
-    sdl.present(r)
+    /* sdl.update(tex, (gfx[:] : void#), 64) */
+    /* sdl.copy(r, tex) */
+    /* sdl.present(r) */
 
     sdl.freerenderer(r)
     sdl.freewin(win)