path: root/081print.mu

# Wrappers around print primitives that take a 'screen' object and are thus
# easier to test.
#
# Screen objects are intended to exactly mimic the behavior of traditional
# terminals. Moving a cursor too far right wraps it to the next line,
# scrolling if necessary. The details are subtle:
#
# a) Rows can take unbounded values. When printing, large values for the row
# saturate to the bottom row (because scrolling).
#
# b) If you print to a square (row, right) on the right margin, the cursor
# position depends on whether 'row' is in range. If it is, the new cursor
# position is (row+1, 0). If it isn't, the new cursor position is (row, 0).
# Because scrolling.

container screen [
  num-rows:num
  num-columns:num
  cursor-row:num
  cursor-column:num
  data:&:@:screen-cell  # capacity num-rows*num-columns
  pending-scroll?:bool
  top-idx:num  # index inside data that corresponds to top-left of screen
               # modified on scroll, wrapping around to the top of data
]

container screen-cell [
  contents:char
  color:num
]

def new-fake-screen w:num, h:num -> result:&:screen [
  local-scope
  load-inputs
  result <- new screen:type
  non-zero-width?:bool <- greater-than w, 0
  assert non-zero-width?, [screen can't have zero width]
  non-zero-height?:bool <- greater-than h, 0
  assert non-zero-height?, [screen can't have zero height]
  bufsize:num <- multiply w, h
  data:&:@:screen-cell <- new screen-cell:type, bufsize
  *result <- merge h/num-rows, w/num-columns, 0/cursor-row, 0/cursor-column, data, false/pending-scroll?, 0/top-idx
  result <- clear-screen result
]

def clear-screen screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [clear-screen]
  {
    break-if screen
    # real screen
    clear-display
    return
  }
  # fake screen
  buf:&:@:screen-cell <- get *screen, data:offset
  max:num <- length *buf
  i:num <- copy 0
  {
    done?:bool <- greater-or-equal i, max
    break-if done?
    curr:screen-cell <- merge 0/empty, 7/white
    *buf <- put-index *buf, i, curr
    i <- add i, 1
    loop
  }
  # reset cursor
  *screen <- put *screen, cursor-row:offset, 0
  *screen <- put *screen, cursor-column:offset, 0
  *screen <- put *screen, top-idx:offset, 0
]

def fake-screen-is-empty? screen:&:screen -> result:bool [
  local-scope
  load-inputs
#?   stash [fake-screen-is-empty?]
  return-unless screen, true  # do nothing for real screens
  buf:&:@:screen-cell <- get *screen, data:offset
  i:num <- copy 0
  len:num <- length *buf
  {
    done?:bool <- greater-or-equal i, len
    break-if done?
    curr:screen-cell <- index *buf, i
    curr-contents:char <- get curr, contents:offset
    i <- add i, 1
    loop-unless curr-contents
    # not 0
    return false
  }
  return true
]

def print screen:&:screen, c:char -> screen:&:screen [
  local-scope
  load-inputs
  color:num, color-found?:bool <- next-input
  {
    # default color to white
    break-if color-found?
    color <- copy 7/white
  }
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  c2:num <- character-to-code c
  trace 90, [print-character], c2
  {
    # real screen
    break-if screen
    print-character-to-display c, color, bg-color
    return
  }
  # fake screen
  # (handle special cases exactly like in the real screen)
  width:num <- get *screen, num-columns:offset
  height:num <- get *screen, num-rows:offset
  capacity:num <- multiply width, height
  row:num <- get *screen, cursor-row:offset
  column:num <- get *screen, cursor-column:offset
  buf:&:@:screen-cell <- get *screen, data:offset
  # some potentially slow sanity checks for preconditions {
  # eliminate fractions from column and row
  row <- round row
  column <- round column
  # if cursor is past left margin (error), reset to left margin
  {
    too-far-left?:bool <- lesser-than column, 0
    break-unless too-far-left?
    column <- copy 0
    *screen <- put *screen, cursor-column:offset, column
  }
  # if cursor is at or past right margin, wrap
  {
    at-right?:bool <- greater-or-equal column, width
    break-unless at-right?
    column <- copy 0
    *screen <- put *screen, cursor-column:offset, column
    row <- add row, 1
    *screen <- put *screen, cursor-row:offset, row
  }
  # }
  # if there's a pending scroll, perform it
  {
    pending-scroll?:bool <- get *screen, pending-scroll?:offset
    break-unless pending-scroll?
#?     stash [scroll]
    scroll-fake-screen screen
    *screen <- put *screen, pending-scroll?:offset, false
  }
#?     $print [print-character (], row, [, ], column, [): ], c, 10/newline
  # special-case: newline
  {
    newline?:bool <- equal c, 10/newline
    break-unless newline?
    cursor-down-on-fake-screen screen  # doesn't modify column
    return
  }
  # special-case: linefeed
  {
    linefeed?:bool <- equal c, 13/linefeed
    break-unless linefeed?
    *screen <- put *screen, cursor-column:offset, 0
    return
  }
  # special-case: backspace
  # moves cursor left but does not erase
  {
    backspace?:bool <- equal c, 8/backspace
    break-unless backspace?
    {
      break-unless column
      column <- subtract column, 1
      *screen <- put *screen, cursor-column:offset, column
    }
    return
  }
  # save character in fake screen
  top-idx:num <- get *screen, top-idx:offset
  index:num <- data-index row, column, width, height, top-idx
  cursor:screen-cell <- merge c, color
  *buf <- put-index *buf, index, cursor
  # move cursor to next character, wrapping as necessary
  # however, don't scroll just yet
  column <- add column, 1
  {
    past-right?:bool <- greater-or-equal column, width
    break-unless past-right?
    column <- copy 0
    row <- add row, 1
    past-bottom?:bool <- greater-or-equal row, height
    break-unless past-bottom?
    # queue up a scroll
#?     stash [pending scroll]
    *screen <- put *screen, pending-scroll?:offset, true
    row <- subtract row, 1  # update cursor as if scroll already happened
  }
  *screen <- put *screen, cursor-row:offset, row
  *screen <- put *screen, cursor-column:offset, column
]

def cursor-down-on-fake-screen screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-down]
  row:num <- get *screen, cursor-row:offset
  height:num <- get *screen, num-rows:offset
  bottom:num <- subtract height, 1
  at-bottom?:bool <- greater-or-equal row, bottom
  {
    break-if at-bottom?
    row <- add row, 1
    *screen <- put *screen, cursor-row:offset, row
  }
  {
    break-unless at-bottom?
    scroll-fake-screen screen  # does not modify row
  }
]

def scroll-fake-screen screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [scroll-fake-screen]
  width:num <- get *screen, num-columns:offset
  height:num <- get *screen, num-rows:offset
  buf:&:@:screen-cell <- get *screen, data:offset
  # clear top line and 'rotate' it to the bottom
  top-idx:num <- get *screen, top-idx:offset  # 0 <= top-idx < len(buf)
  next-top-idx:num <- add top-idx, width  # 0 <= next-top-idx <= len(buf)
  empty-cell:screen-cell <- merge 0/empty, 7/white
  {
    done?:bool <- greater-or-equal top-idx, next-top-idx
    break-if done?
    put-index *buf, top-idx, empty-cell
    top-idx <- add top-idx, 1
    # no modulo; top-idx is always a multiple of width,
    # so it can never wrap around inside this loop
    loop
  }
  # top-idx now same as next-top-idx; wrap around if necessary
  capacity:num <- multiply width, height
  _, top-idx <- divide-with-remainder, top-idx, capacity
  *screen <- put *screen, top-idx:offset, top-idx
]

# translate from screen (row, column) coordinates to an index into data
# while accounting for scrolling (sliding top-idx)
def data-index row:num, column:num, width:num, height:num, top-idx:num -> result:num [
  local-scope
  load-inputs
  {
    overflow?:bool <- greater-or-equal row, height
    break-unless overflow?
    row <- subtract height, 1
  }
  result <- multiply width, row
  result <- add result, column, top-idx
  capacity:num <- multiply width, height
  _, result <- divide-with-remainder result, capacity
]

scenario print-character-at-top-left [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  run [
    a:char <- copy 97/a
    fake-screen <- print fake-screen, a:char
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    1:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    1 <- 6  # width*height
    2 <- 97  # 'a'
    3 <- 7  # white
    # rest of screen is empty
    4 <- 0
  ]
]

scenario print-character-at-fractional-coordinate [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  a:char <- copy 97/a
  run [
    move-cursor fake-screen, 0.5, 0
    fake-screen <- print fake-screen, a:char
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    1:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    1 <- 6  # width*height
    2 <- 97  # 'a'
    3 <- 7  # white
    # rest of screen is empty
    4 <- 0
  ]
]

scenario print-character-in-color [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  run [
    a:char <- copy 97/a
    fake-screen <- print fake-screen, a:char, 1/red
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    1:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    1 <- 6  # width*height
    2 <- 97  # 'a'
    3 <- 1  # red
    # rest of screen is empty
    4 <- 0
  ]
]

scenario print-backspace-character [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  run [
    backspace:char <- copy 8/backspace
    fake-screen <- print fake-screen, backspace
    10:num/raw <- get *fake-screen, cursor-column:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    11:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    10 <- 0  # cursor column
    11 <- 6  # width*height
    12 <- 97  # still 'a'
    13 <- 7  # white
    # rest of screen is empty
    14 <- 0
  ]
]

scenario print-extra-backspace-character [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  run [
    backspace:char <- copy 8/backspace
    fake-screen <- print fake-screen, backspace
    fake-screen <- print fake-screen, backspace  # cursor already at left margin
    1:num/raw <- get *fake-screen, cursor-column:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    3:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    1 <- 0  # cursor column
    3 <- 6  # width*height
    4 <- 97  # still 'a'
    5 <- 7  # white
    # rest of screen is empty
    6 <- 0
  ]
]

scenario print-character-at-right-margin [
  # fill top row of screen with text
  local-scope
  fake-screen:&:screen <- new-fake-screen 2/width, 2/height
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  b:char <- copy 98/b
  fake-screen <- print fake-screen, b
  run [
    # cursor now at next row
    c:char <- copy 99/c
    fake-screen <- print fake-screen, c
    10:num/raw <- get *fake-screen, cursor-row:offset
    11:num/raw <- get *fake-screen, cursor-column:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    12:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    10 <- 1  # cursor row
    11 <- 1  # cursor column
    12 <- 4  # width*height
    13 <- 97  # 'a'
    14 <- 7  # white
    15 <- 98  # 'b'
    16 <- 7  # white
    17 <- 99  # 'c'
    18 <- 7  # white
    19 <- 0  # ' '
    20 <- 7  # white
  ]
]

scenario print-newline-character [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  run [
    newline:char <- copy 10/newline
    fake-screen <- print fake-screen, newline
    10:num/raw <- get *fake-screen, cursor-row:offset
    11:num/raw <- get *fake-screen, cursor-column:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    12:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    10 <- 1  # cursor row
    11 <- 1  # cursor column
    12 <- 6  # width*height
    13 <- 97  # 'a'
    14 <- 7  # white
    # rest of screen is empty
    15 <- 0
  ]
]

scenario print-newline-at-bottom-line [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  newline:char <- copy 10/newline
  fake-screen <- print fake-screen, newline
  fake-screen <- print fake-screen, newline
  run [
    # cursor now at bottom of screen
    fake-screen <- print fake-screen, newline
    10:num/raw <- get *fake-screen, cursor-row:offset
    11:num/raw <- get *fake-screen, cursor-column:offset
  ]
  # doesn't move further down
  memory-should-contain [
    10 <- 1  # cursor row
    11 <- 0  # cursor column
  ]
]

scenario print-character-at-bottom-right [
  local-scope
  fake-screen:&:screen <- new-fake-screen 2/width, 2/height
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  b:char <- copy 98/b
  fake-screen <- print fake-screen, b
  c:char <- copy 99/c
  fake-screen <- print fake-screen, c
  run [
    # cursor now at bottom right
    d:char <- copy 100/d
    fake-screen <- print fake-screen, d
    10:num/raw <- get *fake-screen, cursor-row:offset
    11:num/raw <- get *fake-screen, cursor-column:offset
    12:num/raw <- get *fake-screen, top-idx:offset
    13:bool/raw <- get *fake-screen, pending-scroll?:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    20:@:screen-cell/raw <- copy *cell
  ]
  # cursor column wraps but the screen doesn't scroll yet
  memory-should-contain [
    10 <- 1  # cursor row
    11 <- 0  # cursor column -- outside screen
    12 <- 0  # top-idx -- not yet scrolled
    13 <- 1  # pending-scroll?
    20 <- 4  # screen size (width*height)
    21 <- 97  # 'a'
    22 <- 7  # white
    23 <- 98  # 'b'
    24 <- 7  # white
    25 <- 99 # 'c'
    26 <- 7  # white
    27 <- 100  # 'd'
    28 <- 7  # white
  ]
  run [
    e:char <- copy 101/e
    print fake-screen, e
    10:num/raw <- get *fake-screen, cursor-row:offset
    11:num/raw <- get *fake-screen, cursor-column:offset
    12:num/raw <- get *fake-screen, top-idx:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    20:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    # text scrolls by 1, we lose the top line
    10 <- 1  # cursor row
    11 <- 1  # cursor column -- wrapped
    12 <- 2  # top-idx -- scrolled
    20 <- 4  # screen size (width*height)
    # screen now checked in rotated order
    25 <- 99 # 'c'
    26 <- 7  # white
    27 <- 100  # 'd'
    28 <- 7  # white
    # screen wraps; bottom line is cleared of old contents
    21 <- 101  # 'e'
    22 <- 7  # white
    23 <- 0  # unused
    24 <- 7  # white
  ]
]

# even though our screen supports scrolling, some apps may want to avoid
# scrolling
# these helpers help check for scrolling at development time
def save-top-idx screen:&:screen -> result:num [
  local-scope
  load-inputs
  return-unless screen, 0  # check is only for fake screens
  result <- get *screen, top-idx:offset
]
def assert-no-scroll screen:&:screen, old-top-idx:num [
  local-scope
  load-inputs
  return-unless screen
  new-top-idx:num <- get *screen, top-idx:offset
  no-scroll?:bool <- equal old-top-idx, new-top-idx
  assert no-scroll?, [render should never use screen's scrolling capabilities]
]

def clear-line screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [clear-line]
  space:char <- copy 0/nul
  {
    break-if screen
    # real screen
    clear-line-on-display
    return
  }
  # fake screen
  width:num <- get *screen, num-columns:offset
  column:num <- get *screen, cursor-column:offset
  original-column:num <- copy column
  # space over the entire line
  {
    right:num <- subtract width, 1
    done?:bool <- greater-or-equal column, right
    break-if done?
    print screen, space
    column <- add column, 1
    loop
  }
  # now back to where the cursor was
  *screen <- put *screen, cursor-column:offset, original-column
]

# only for non-scrolling apps
def clear-line-until screen:&:screen, right:num/inclusive -> screen:&:screen [
  local-scope
  load-inputs
  row:num, column:num <- cursor-position screen
#?   stash [clear-line-until] row column
  height:num <- screen-height screen
  past-bottom?:bool <- greater-or-equal row, height
  return-if past-bottom?
  space:char <- copy 32/space
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  {
    done?:bool <- greater-than column, right
    break-if done?
    screen <- print screen, space, 7/white, bg-color  # foreground color is mostly unused except if the cursor shows up at this cell
    column <- add column, 1
    loop
  }
]

def cursor-position screen:&:screen -> row:num, column:num [
  local-scope
  load-inputs
  {
    break-if screen
    # real screen
    row, column <- cursor-position-on-display
    return
  }
  # fake screen
  row:num <- get *screen, cursor-row:offset
  column:num <- get *screen, cursor-column:offset
]

def move-cursor screen:&:screen, new-row:num, new-column:num -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [move-cursor] new-row new-column
  {
    break-if screen
    # real screen
    move-cursor-on-display new-row, new-column
    return
  }
  # fake screen
  *screen <- put *screen, cursor-row:offset, new-row
  *screen <- put *screen, cursor-column:offset, new-column
  # if cursor column is within bounds, reset 'pending-scroll?'
  {
    width:num <- get *screen, num-columns:offset
    scroll?:bool <- greater-or-equal new-column, width
    break-if scroll?
#?     stash [resetting pending-scroll?]
    *screen <- put *screen, pending-scroll?:offset, false
  }
]

scenario clear-line-erases-printed-characters [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  # print a character
  a:char <- copy 97/a
  fake-screen <- print fake-screen, a
  # move cursor to start of line
  fake-screen <- move-cursor fake-screen, 0/row, 0/column
  run [
    fake-screen <- clear-line fake-screen
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    10:@:screen-cell/raw <- copy *cell
  ]
  # screen should be blank
  memory-should-contain [
    10 <- 6  # width*height
    11 <- 0
    12 <- 7
    13 <- 0
    14 <- 7
    15 <- 0
    16 <- 7
    17 <- 0
    18 <- 7
    19 <- 0
    20 <- 7
    21 <- 0
    22 <- 7
  ]
]

def cursor-down screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-down]
  {
    break-if screen
    # real screen
    move-cursor-down-on-display
    return
  }
  # fake screen
  cursor-down-on-fake-screen screen
]

scenario cursor-down-scrolls [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  # print something to screen and scroll
  run [
    print fake-screen, [abc]
    cursor-to-next-line fake-screen
    cursor-to-next-line fake-screen
    data:&:@:screen-cell <- get *fake-screen, data:offset
    10:@:screen-cell/raw <- copy *data
  ]
  # screen is now blank
  memory-should-contain [
    10 <- 6  # width*height
    11 <- 0
    12 <- 7  # white
    13 <- 0
    14 <- 7  # white
    15 <- 0
    16 <- 7  # white
    17 <- 0
    18 <- 7  # white
    19 <- 0
    20 <- 7  # white
    21 <- 0
    22 <- 7  # white
  ]
]

def cursor-up screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-up]
  {
    break-if screen
    # real screen
    move-cursor-up-on-display
    return
  }
  # fake screen
  row:num <- get *screen, cursor-row:offset
  at-top?:bool <- lesser-or-equal row, 0
  return-if at-top?
  row <- subtract row, 1
  *screen <- put *screen, cursor-row:offset, row
]

def cursor-right screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-right]
  {
    break-if screen
    # real screen
    move-cursor-right-on-display
    return
  }
  # fake screen
  width:num <- get *screen, num-columns:offset
  column:num <- get *screen, cursor-column:offset
  max:num <- subtract width, 1
  at-bottom?:bool <- greater-or-equal column, max
  return-if at-bottom?
  column <- add column, 1
  *screen <- put *screen, cursor-column:offset, column
]

def cursor-left screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-left]
  {
    break-if screen
    # real screen
    move-cursor-left-on-display
    return
  }
  # fake screen
  column:num <- get *screen, cursor-column:offset
  at-top?:bool <- lesser-or-equal column, 0
  return-if at-top?
  column <- subtract column, 1
  *screen <- put *screen, cursor-column:offset, column
]

def cursor-to-start-of-line screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-to-start-of-line]
  row:num <- cursor-position screen
  screen <- move-cursor screen, row, 0/column
]

def cursor-to-next-line screen:&:screen -> screen:&:screen [
  local-scope
  load-inputs
#?   stash [cursor-to-next-line]
  screen <- cursor-down screen
  screen <- cursor-to-start-of-line screen
]

def move-cursor-to-column screen:&:screen, column:num -> screen:&:screen [
  local-scope
  load-inputs
  row:num, _ <- cursor-position screen
#?   stash [move-cursor-to-column] row
  move-cursor screen, row, column
]

def screen-width screen:&:screen -> width:num [
  local-scope
  load-inputs
#?   stash [screen-width]
  {
    break-unless screen
    # fake screen
    width <- get *screen, num-columns:offset
    return
  }
  # real screen
  width <- display-width
]

def screen-height screen:&:screen -> height:num [
  local-scope
  load-inputs
#?   stash [screen-height]
  {
    break-unless screen
    # fake screen
    height <- get *screen, num-rows:offset
    return
  }
  # real screen
  height <- display-height
]

def print screen:&:screen, s:text -> screen:&:screen [
  local-scope
  load-inputs
  color:num, color-found?:bool <- next-input
  {
    # default color to white
    break-if color-found?
    color <- copy 7/white
  }
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  len:num <- length *s
  i:num <- copy 0
  {
    done?:bool <- greater-or-equal i, len
    break-if done?
    c:char <- index *s, i
    print screen, c, color, bg-color
    i <- add i, 1
    loop
  }
]

scenario print-text-wraps-past-right-margin [
  local-scope
  fake-screen:&:screen <- new-fake-screen 3/width, 2/height
  run [
    fake-screen <- print fake-screen, [abcd]
    5:num/raw <- get *fake-screen, cursor-row:offset
    6:num/raw <- get *fake-screen, cursor-column:offset
    7:num/raw <- get *fake-screen, top-idx:offset
    cell:&:@:screen-cell <- get *fake-screen, data:offset
    10:@:screen-cell/raw <- copy *cell
  ]
  memory-should-contain [
    5 <- 1  # cursor-row
    6 <- 1  # cursor-column
    7 <- 0  # top-idx
    10 <- 6  # width*height
    11 <- 97  # 'a'
    12 <- 7  # white
    13 <- 98  # 'b'
    14 <- 7  # white
    15 <- 99  # 'c'
    16 <- 7  # white
    17 <- 100  # 'd'
    18 <- 7  # white
    # rest of screen is empty
    19 <- 0
  ]
]

def print screen:&:screen, n:num -> screen:&:screen [
  local-scope
  load-inputs
  color:num, color-found?:bool <- next-input
  {
    # default color to white
    break-if color-found?
    color <- copy 7/white
  }
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  # todo: other bases besides decimal
  s:text <- to-text n
  screen <- print screen, s, color, bg-color
]

def print screen:&:screen, n:bool -> screen:&:screen [
  local-scope
  load-inputs
  color:num, color-found?:bool <- next-input
  {
    # default color to white
    break-if color-found?
    color <- copy 7/white
  }
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  {
    break-if n
    screen <- print screen, [false], color, bg-color
  }
  {
    break-unless n
    screen <- print screen, [true], color, bg-color
  }
]

def print screen:&:screen, n:&:_elem -> screen:&:screen [
  local-scope
  load-inputs
  color:num, color-found?:bool <- next-input
  {
    # default color to white
    break-if color-found?
    color <- copy 7/white
  }
  bg-color:num, bg-color-found?:bool <- next-input
  {
    # default bg-color to black
    break-if bg-color-found?
    bg-color <- copy 0/black
  }
  n2:num <- deaddress n
  screen <- print screen, n2, color, bg-color
]