7836

1 files changed, 0 insertions, 263 deletions

diff --git a/baremetal/shell/value.mu b/baremetal/shell/value.mu
deleted file mode 100644
index 5b5ec142..00000000
--- a/baremetal/shell/value.mu
+++ /dev/null
@@ -1,263 +0,0 @@
-# todo: turn this into a sum type
-type value {
-  type: int
-  number-data: float  # if type = 0
-  text-data: (handle array byte)  # if type = 1
-  array-data: (handle array value)  # if type = 2
-  boolean-data: boolean  # if type = 3
-}
-
-# 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
-  }
-  compare *val-type, 3/boolean
-  {
-    break-if-!=
-    var val/eax: (addr boolean) <- get val, boolean-data
-    var new-x/eax: int <- render-boolean screen, *val, 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
-  copy-to *type, 0/number
-  var val/xmm0: float <- convert n
-  var dest/eax: (addr float) <- get self, number-data
-  copy-to *dest, val
-}
-
-fn initialize-value-with-float _self: (addr value), n: float {
-  var self/esi: (addr value) <- copy _self
-  var type/eax: (addr int) <- get self, type
-  copy-to *type, 0/number
-  var val/xmm0: float <- copy n
-  var dest/eax: (addr float) <- get self, number-data
-  copy-to *dest, val
-}
-
-# synaesthesia
-# TODO: right-justify
-fn render-number screen: (addr screen), val: float, x: int, y: int, top-level?: boolean -> _/eax: int {
-  # if we're inside an array, don't color
-  compare top-level?, 0
-  {
-    break-if-!=
-    var new-x/eax: int <- render-float-decimal screen, val, 3/precision, x, y, 3/fg, 0/bg
-    return new-x
-  }
-  var val-int/eax: int <- convert val
-  var _bg/eax: int <- hash-color val-int
-  var bg/ecx: int <- copy _bg
-  var fg/edx: int <- copy 7
-  {
-    compare bg, 2
-    break-if-!=
-    fg <- copy 0
-  }
-  {
-    compare bg, 3
-    break-if-!=
-    fg <- copy 0
-  }
-  {
-    compare bg, 6
-    break-if-!=
-    fg <- copy 0
-  }
-  draw-code-point screen, 0x20/space, x, y, fg, bg
-  increment x
-  var new-x/eax: int <- render-float-decimal screen, val, 3/precision, x, y, fg, bg
-  draw-code-point screen, 0x20/space, new-x, y, fg, bg
-  new-x <- increment
-  return new-x
-}
-
-fn hash-color val: int -> _/eax: int {
-  var quotient/eax: int <- copy 0
-  var remainder/edx: int <- copy 0
-  quotient, remainder <- integer-divide val, 7  # assumes that 7 is always the background color
-  return remainder
-}
-
-fn test-render-number {
-  # setup: screen
-  var screen-on-stack: screen
-  var screen/edi: (addr screen) <- address screen-on-stack
-  initialize-screen screen, 0x20, 4
-  # integers render with some padding spaces
-  var new-x/eax: int <- render-number screen, 0/n, 0/x, 0/y, 1/at-top-level
-  check-screen-row screen, 0/y, " 0 ", "F - test-render-number"
-  check-ints-equal new-x, 3, "F - test-render-number: result"
-  # we won't bother testing the background colors; lots of flexibility there
-}
-
-fn initialize-value-with-string _self: (addr value), s: (addr array byte) {
-  var self/esi: (addr value) <- copy _self
-  var type/eax: (addr int) <- get self, type
-  copy-to *type, 1/string
-  var dest/eax: (addr handle array byte) <- get self, text-data
-  copy-array-object s, dest
-}
-
-fn render-string screen: (addr screen), _val: (addr array byte), x: int, y: int -> _/eax: int {
-  var val/esi: (addr array byte) <- copy _val
-  compare val, 0
-  {
-    break-if-!=
-    return x
-  }
-  var orig-len/ecx: int <- length val
-  # truncate to 12 graphemes
-  # TODO: more sophisticated interactive rendering
-  var truncated: (handle array byte)
-  var truncated-ah/eax: (addr handle array byte) <- address truncated
-  substring val, 0, 0xc, truncated-ah
-  var _truncated-string/eax: (addr array byte) <- lookup *truncated-ah
-  var truncated-string/edx: (addr array byte) <- copy _truncated-string
-  var len/ebx: int <- length truncated-string
-  draw-code-point screen, 0x22/double-quote, x, y, 7/fg, 0/bg
-  increment x
-  var new-x/eax: int <- draw-text-rightward-over-full-screen screen, truncated-string, x, y, 7/fg, 0/bg
-  compare len, orig-len
-  {
-    break-if-=
-    new-x <- draw-text-rightward-over-full-screen screen, "...", new-x, y, 7/fg, 0/bg
-  }
-  draw-code-point screen, 0x22/double-quote, new-x, y, 7/fg, 0/bg
-  new-x <- increment
-  return new-x
-}
-
-fn test-render-string {
-  # setup: screen
-  var screen-on-stack: screen
-  var screen/edi: (addr screen) <- address screen-on-stack
-  initialize-screen screen, 0x20, 4
-  # strings render with quotes
-  var new-x/eax: int <- render-string screen, "abc", 0/x, 0/y
-  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"
-}
-
-fn initialize-value-with-boolean _self: (addr value), _b: boolean {
-  var self/esi: (addr value) <- copy _self
-  var type/eax: (addr int) <- get self, type
-  copy-to *type, 3/boolean
-  var dest/edi: (addr boolean) <- get self, boolean-data
-  var b/esi: boolean <- copy _b
-  copy-to *dest, b
-}
-
-fn render-boolean screen: (addr screen), val: boolean, x: int, y: int -> _/eax: int {
-  var new-x/eax: int <- copy 0
-  compare val, 0/false
-  {
-    break-if-=
-    new-x <- draw-text-rightward-over-full-screen screen, "true", new-x, y, 7/fg, 0/bg
-    return new-x
-  }
-  new-x <- draw-text-rightward-over-full-screen screen, "false", new-x, y, 7/fg, 0/bg
-  return new-x
-}