7698 - starting to test-drive baremetal shell

4 files changed, 259 insertions, 5 deletions

diff --git a/baremetal/500text-screen.mu b/baremetal/500text-screen.mu
index 88ebc104..050cf4db 100644
--- a/baremetal/500text-screen.mu
+++ b/baremetal/500text-screen.mu
@@ -90,8 +90,17 @@ fn draw-grapheme screen: (addr screen), g: grapheme, x: int, y: int, color: int,
   copy-to *dest-color, src-color
 }
 
+# not really needed for a real screen, though it shouldn't do any harm
 fn screen-cell-index screen-on-stack: (addr screen), x: int, y: int -> _/ecx: int {
   var screen/esi: (addr screen) <- copy screen-on-stack
+  # only one bounds check isn't automatically handled
+  {
+    var xmax/eax: (addr int) <- get screen, width
+    var xcurr/ecx: int <- copy x
+    compare xcurr, *xmax
+    break-if-<
+    abort "tried to print out of screen bounds"
+  }
   var height-addr/eax: (addr int) <- get screen, height
   var result/ecx: int <- copy y
   result <- multiply *height-addr
diff --git a/baremetal/501draw-text.mu b/baremetal/501draw-text.mu
index 395aff0b..b9fc274f 100644
--- a/baremetal/501draw-text.mu
+++ b/baremetal/501draw-text.mu
@@ -499,3 +499,14 @@ fn draw-text-wrapping-down-then-right-from-cursor-over-full-screen screen: (addr
   width, height <- screen-size screen
   draw-text-wrapping-down-then-right-from-cursor screen, text, 0/xmin, 0/ymin, width, height, color, background-color
 }
+
+# hacky error-handling
+# just go into an infinite loop
+fn abort e: (addr array byte) {
+  var dummy1/eax: int <- copy 0
+  var dummy2/ecx: int <- copy 0
+  dummy1, dummy2 <- draw-text-wrapping-right-then-down-over-full-screen 0/screen, e, 0/x, 0x2f/y, 0xf/fg=white, 0xc/bg=red
+  {
+    loop
+  }
+}
diff --git a/baremetal/504test-screen.mu b/baremetal/504test-screen.mu
index 72691a64..0b8514c1 100644
--- a/baremetal/504test-screen.mu
+++ b/baremetal/504test-screen.mu
@@ -5,12 +5,12 @@
 # Tab characters (that translate into multiple screen cells) not supported.
 
 fn check-screen-row screen: (addr screen), y: int, expected: (addr array byte), msg: (addr array byte) {
-  check-screen-row-from screen, y, 0/y, expected, msg
+  check-screen-row-from screen, 0/x, y, expected, msg
 }
 
 fn check-screen-row-from screen-on-stack: (addr screen), x: int, y: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
-  var idx/ecx: int <- screen-cell-index screen, y, x
+  var idx/ecx: int <- screen-cell-index screen, x, y
   # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
@@ -67,7 +67,7 @@ fn check-screen-row-in-color screen: (addr screen), fg: int, y: int, expected: (
 
 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
-  var idx/ecx: int <- screen-cell-index screen, y, x
+  var idx/ecx: int <- screen-cell-index screen, x, y
   # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
@@ -156,7 +156,7 @@ fn check-screen-row-in-background-color screen: (addr screen), bg: int, y: int,
 
 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, y: int, x: int, expected: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
-  var idx/ecx: int <- screen-cell-index screen, y, x
+  var idx/ecx: int <- screen-cell-index screen, x, y
   # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
@@ -248,7 +248,7 @@ fn check-background-color-in-screen-row screen: (addr screen), bg: int, y: int,
 
 fn check-background-color-in-screen-row-from screen-on-stack: (addr screen), bg: int, y: int, x: int, expected-bitmap: (addr array byte), msg: (addr array byte) {
   var screen/esi: (addr screen) <- copy screen-on-stack
-  var idx/ecx: int <- screen-cell-index screen, y, x
+  var idx/ecx: int <- screen-cell-index screen, x, y
   # compare background color where 'expected-bitmap' is a non-space
   var e: (stream byte 0x100)
   var e-addr/edx: (addr stream byte) <- address e
diff --git a/baremetal/shell/grapheme-stack.mu b/baremetal/shell/grapheme-stack.mu
new file mode 100644
index 00000000..1ceb96c0
--- /dev/null
+++ b/baremetal/shell/grapheme-stack.mu
@@ -0,0 +1,234 @@
+type grapheme-stack {
+  data: (handle array grapheme)
+  top: int
+}
+
+fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var d/edi: (addr handle array grapheme) <- get self, data
+  populate d, n
+  var top/eax: (addr int) <- get self, top
+  copy-to *top, 0
+}
+
+fn clear-grapheme-stack _self: (addr grapheme-stack) {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var top/eax: (addr int) <- get self, top
+  copy-to *top, 0
+}
+
+fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var top/eax: (addr int) <- get self, top
+  compare *top, 0
+  {
+    break-if-!=
+    return 1/true
+  }
+  return 0/false
+}
+
+fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var top-addr/ecx: (addr int) <- get self, top
+  var data-ah/edx: (addr handle array grapheme) <- get self, data
+  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var top/edx: int <- copy *top-addr
+  var dest-addr/edx: (addr grapheme) <- index data, top
+  var val/eax: grapheme <- copy _val
+  copy-to *dest-addr, val
+  add-to *top-addr, 1
+}
+
+fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var top-addr/ecx: (addr int) <- get self, top
+  {
+    compare *top-addr, 0
+    break-if->
+    return -1
+  }
+  subtract-from *top-addr, 1
+  var data-ah/edx: (addr handle array grapheme) <- get self, data
+  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var top/edx: int <- copy *top-addr
+  var result-addr/eax: (addr grapheme) <- index data, top
+  return *result-addr
+}
+
+fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
+  var src/esi: (addr grapheme-stack) <- copy _src
+  var data-ah/edi: (addr handle array grapheme) <- get src, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edi: (addr array grapheme) <- copy _data
+  var top-addr/ecx: (addr int) <- get src, top
+  var i/eax: int <- copy 0
+  {
+    compare i, *top-addr
+    break-if->=
+    var g/edx: (addr grapheme) <- index data, i
+    push-grapheme-stack dest, *g
+    i <- increment
+    loop
+  }
+}
+
+# dump stack to screen from bottom to top
+# colors hardcoded
+fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen), x: int, y: int {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var data-ah/edi: (addr handle array grapheme) <- get self, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edi: (addr array grapheme) <- copy _data
+  var top-addr/ecx: (addr int) <- get self, top
+  var i/eax: int <- copy 0
+  {
+    compare i, *top-addr
+    break-if->=
+    var g/edx: (addr grapheme) <- index data, i
+    draw-grapheme screen, *g, x, y, 3/fg=cyan, 0/bg
+    i <- increment
+    increment x  # assume left to right
+    loop
+  }
+}
+
+# dump stack to screen from top to bottom
+# optionally render a 'cursor' with the top grapheme
+fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen), x: int, y: int, render-cursor?: boolean {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var data-ah/edi: (addr handle array grapheme) <- get self, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edi: (addr array grapheme) <- copy _data
+  var top-addr/ecx: (addr int) <- get self, top
+  var i/eax: int <- copy *top-addr
+  i <- decrement
+  # if render-cursor?, peel off first iteration
+  {
+    compare render-cursor?, 0/false
+    break-if-=
+    compare i, 0
+    break-if-<
+    var g/edx: (addr grapheme) <- index data, i
+    draw-grapheme screen, *g, x, y, 3/fg=cyan, 7/bg=cursor
+    i <- decrement
+    increment x  # assume left to right
+  }
+  # remaining iterations
+  {
+    compare i, 0
+    break-if-<
+    var g/edx: (addr grapheme) <- index data, i
+    draw-grapheme screen, *g, x, y, 3/fg=cyan, 0/bg
+    i <- decrement
+    increment x  # assume left to right
+    loop
+  }
+}
+
+fn test-render-grapheme-stack {
+  # setup: gs = "abc"
+  var gs-storage: grapheme-stack
+  var gs/edi: (addr grapheme-stack) <- address gs-storage
+  initialize-grapheme-stack gs, 5
+  var g/eax: grapheme <- copy 0x61/a
+  push-grapheme-stack gs, g
+  g <- copy 0x62/b
+  push-grapheme-stack gs, g
+  g <- copy 0x63/c
+  push-grapheme-stack gs, g
+  # setup: screen
+  var screen-on-stack: screen
+  var screen/esi: (addr screen) <- address screen-on-stack
+  initialize-screen screen, 5, 4
+  #
+  render-stack-from-bottom gs, screen, 0/x, 0/y
+  check-screen-row  screen, 0/y, "abc ", "F - test-render-grapheme-stack from bottom"
+  check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, "   ", "F - test-render-grapheme-stack bg from bottom"
+  #
+  render-stack-from-top gs, screen, 0/x, 1/y, 0/cursor=false
+  check-screen-row  screen, 1/y, "cba ", "F - test-render-grapheme-stack from top without cursor"
+  check-background-color-in-screen-row screen, 7/bg=cursor, 1/y, "   ", "F - test-render-grapheme-stack bg from top without cursor"
+  #
+  render-stack-from-top gs, screen, 0/x, 2/y, 1/cursor=true
+  check-screen-row  screen, 2/y, "cba ", "F - test-render-grapheme-stack from top with cursor"
+  check-background-color-in-screen-row screen, 7/bg=cursor, 2/y, "|   ", "F - test-render-grapheme-stack bg from top with cursor"
+}
+
+# compare from bottom
+# beware: modifies 'stream', which must be disposed of after a false result
+fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var data-ah/edi: (addr handle array grapheme) <- get self, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edi: (addr array grapheme) <- copy _data
+  var top-addr/ecx: (addr int) <- get self, top
+  var i/ebx: int <- copy 0
+  {
+    compare i, *top-addr
+    break-if->=
+    # if curr != expected, return false
+    {
+      var curr-a/edx: (addr grapheme) <- index data, i
+      var expected/eax: grapheme <- read-grapheme s
+      {
+        compare expected, *curr-a
+        break-if-=
+        return 0/false
+      }
+    }
+    i <- increment
+    loop
+  }
+  return 1   # true
+}
+
+# compare from bottom
+# beware: modifies 'stream', which must be disposed of after a false result
+fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var data-ah/edi: (addr handle array grapheme) <- get self, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edi: (addr array grapheme) <- copy _data
+  var top-addr/eax: (addr int) <- get self, top
+  var i/ebx: int <- copy *top-addr
+  i <- decrement
+  {
+    compare i, 0
+    break-if-<
+    {
+      var curr-a/edx: (addr grapheme) <- index data, i
+      var expected/eax: grapheme <- read-grapheme s
+      # if curr != expected, return false
+      {
+        compare expected, *curr-a
+        break-if-=
+        return 0/false
+      }
+    }
+    i <- decrement
+    loop
+  }
+  return 1   # true
+}
+
+fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
+  var self/esi: (addr grapheme-stack) <- copy _self
+  var data-ah/eax: (addr handle array grapheme) <- get self, data
+  var _data/eax: (addr array grapheme) <- lookup *data-ah
+  var data/edx: (addr array grapheme) <- copy _data
+  var top-addr/ecx: (addr int) <- get self, top
+  var i/ebx: int <- copy 0
+  var result/eax: boolean <- copy 1/true
+  $grapheme-stack-is-integer?:loop: {
+    compare i, *top-addr
+    break-if->=
+    var g/edx: (addr grapheme) <- index data, i
+    result <- is-decimal-digit? *g
+    compare result, 0/false
+    break-if-=
+    i <- increment
+    loop
+  }
+  return result
+}