7724 - baremetal: rendering array values

1 files changed, 105 insertions, 0 deletions

diff --git a/baremetal/shell/value.mu b/baremetal/shell/value.mu
index 64b1d772..4a93227e 100644
--- a/baremetal/shell/value.mu
+++ b/baremetal/shell/value.mu
@@ -6,6 +6,35 @@ type value {
   array-data: (handle array value)  # if type = 2
 }
 
+# top-level? is a hack just for numbers
+# we'll eventually need to return a y coordinate as well to render 2D values
+fn render-value screen: (addr screen), _val: (addr value), x: int, y: int, top-level?: boolean -> _/eax: int {
+  var val/esi: (addr value) <- copy _val
+  var val-type/ecx: (addr int) <- get val, type
+  compare *val-type, 1/string
+  {
+    break-if-!=
+    var val-ah/eax: (addr handle array byte) <- get val, text-data
+    var _val-string/eax: (addr array byte) <- lookup *val-ah
+    var val-string/ecx: (addr array byte) <- copy _val-string
+    var new-x/eax: int <- render-string screen, val-string, x, y
+    return new-x
+  }
+  compare *val-type, 2/array
+  {
+    break-if-!=
+    var val-ah/eax: (addr handle array value) <- get val, array-data
+    var _val-array/eax: (addr array value) <- lookup *val-ah
+    var val-array/edx: (addr array value) <- copy _val-array
+    var new-x/eax: int <- render-array screen, val-array, x, y
+    return new-x
+  }
+  # render ints by default for now
+  var val-num/eax: (addr float) <- get val, number-data
+  var new-x/eax: int <- render-number screen, *val-num, x, y, top-level?
+  return new-x
+}
+
 fn initialize-value-with-integer _self: (addr value), n: int {
   var self/esi: (addr value) <- copy _self
   var type/eax: (addr int) <- get self, type
@@ -127,3 +156,79 @@ fn test-render-string {
   check-screen-row screen, 0/y, "\"abc\"", "F - test-render-string"
   check-ints-equal new-x, 5, "F - test-render-string: result"
 }
+
+fn initialize-value-with-array-of-integers _self: (addr value), s: (addr array byte) {
+  # parse s into a temporary array of ints
+  var tmp-storage: (handle array int)
+  var tmp-ah/eax: (addr handle array int) <- address tmp-storage
+  parse-array-of-decimal-ints s, tmp-ah  # leak
+  var _tmp/eax: (addr array int ) <- lookup *tmp-ah
+  var tmp/esi: (addr array int ) <- copy _tmp
+  # load the array into values
+  var self/edi: (addr value) <- copy _self
+  var type/eax: (addr int) <- get self, type
+  copy-to *type, 2/string
+  var dest-array-ah/eax: (addr handle array value) <- get self, array-data
+  var len/ebx: int <- length tmp
+  populate dest-array-ah, len
+  var _dest-array/eax: (addr array value) <- lookup *dest-array-ah
+  var dest-array/edi: (addr array value) <- copy _dest-array
+  var i/eax: int <- copy 0
+  {
+    compare i, len
+    break-if->=
+    var src-addr/ecx: (addr int) <- index tmp, i
+    var src/ecx: int <- copy *src-addr
+    var src-f/xmm0: float <- convert src
+    var dest-offset/edx: (offset value) <- compute-offset dest-array, i
+    var dest-val/edx: (addr value) <- index dest-array, dest-offset
+    var dest/edx: (addr float) <- get dest-val, number-data
+    copy-to *dest, src-f
+    i <- increment
+    loop
+  }
+}
+
+fn render-array screen: (addr screen), _arr: (addr array value), x: int, y: int -> _/eax: int {
+  # don't surround in spaces
+  draw-code-point screen, 0x5b/open-bracket, x, y, 7/fg, 0/bg
+  increment x
+  var arr/esi: (addr array value) <- copy _arr
+  var max/ecx: int <- length arr
+  var i/edx: int <- copy 0
+  var new-x/eax: int <- copy x
+  {
+    compare i, max
+    break-if->=
+    {
+      compare i, 0
+      break-if-=
+      draw-code-point screen, 0x20/space, new-x, y, 7/fg, 0/bg
+      new-x <- increment
+    }
+    var off/ecx: (offset value) <- compute-offset arr, i
+    var x/ecx: (addr value) <- index arr, off
+    new-x <- render-value screen, x, new-x, y, 0/nested
+    i <- increment
+    loop
+  }
+  draw-code-point screen, 0x5d/close-bracket, new-x, y, 7/fg, 0/bg
+  new-x <- increment
+  return new-x
+}
+
+fn test-render-array {
+  # setup: screen
+  var screen-on-stack: screen
+  var screen/edi: (addr screen) <- address screen-on-stack
+  initialize-screen screen, 0x20, 4
+  #
+  var val-storage: value
+  var val/eax: (addr value) <- address val-storage
+  initialize-value-with-array-of-integers val, "0 1 2"
+  var val-array-ah/eax: (addr handle array value) <- get val, array-data
+  var val-array/eax: (addr array value) <- lookup *val-array-ah
+  var new-x/eax: int <- render-array screen, val-array, 0/x, 0/y
+  check-screen-row screen, 0/y, "[0 1 2]", "F - test-render-array"
+  check-ints-equal new-x, 7, "F - test-render-array: result"
+}