path: root/linux/tile/environment.mu

# The architecture that seems to be crystallizing: the environment has two
# areas: functions and sandbox.
#
# Rendering the environment requires rendering all areas.
# Displaying the cursor requires displaying cursor for the area controlling the cursor.
# Processing events for the environment requires processing events for the area controlling the cursor.
#
# Areas can have dialogs.
# There can also be global dialogs (currently just one: goto function).
# Areas are responsible for rendering their dialogs.
# In practice this results in dialogs encapsulating the state they need to
# decide whether to render.
#
# This will be useful if we add more areas in the future.

type environment {
  screen: (handle screen)
  functions: (handle function)
  sandboxes: (handle sandbox)
  partial-function-name: (handle word)
  # at most one of these will be set
  cursor-function: (handle function)
  cursor-sandbox: (handle sandbox)
  #
  nrows: int
  ncols: int
  code-separator-col: int
}

fn initialize-environment _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  # initialize some predefined function definitions
  var functions/eax: (addr handle function) <- get env, functions
  create-primitive-functions functions
  # initialize first sandbox
  var sandbox-ah/ecx: (addr handle sandbox) <- get env, sandboxes
  allocate sandbox-ah
  var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah
  initialize-sandbox sandbox
  # initialize cursor sandbox
  var cursor-sandbox-ah/eax: (addr handle sandbox) <- get env, cursor-sandbox
  copy-object sandbox-ah, cursor-sandbox-ah
  # initialize screen
  var screen-ah/eax: (addr handle screen) <- get env, screen
  var _screen/eax: (addr screen) <- lookup *screen-ah
  var screen/edi: (addr screen) <- copy _screen
  var nrows/eax: int <- copy 0
  var ncols/ecx: int <- copy 0
  nrows, ncols <- screen-size screen
  var dest/edx: (addr int) <- get env, nrows
  copy-to *dest, nrows
  dest <- get env, ncols
  copy-to *dest, ncols
  var repl-col/ecx: int <- copy ncols
  repl-col <- shift-right 1
  dest <- get env, code-separator-col
  copy-to *dest, repl-col
}

fn initialize-environment-with-fake-screen _self: (addr environment), nrows: int, ncols: int {
  var self/esi: (addr environment) <- copy _self
  var screen-ah/eax: (addr handle screen) <- get self, screen
  allocate screen-ah
  var screen-addr/eax: (addr screen) <- lookup *screen-ah
  initialize-screen screen-addr, nrows, ncols
  initialize-environment self
}

#############
# Iterate
#############

fn process _self: (addr environment), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var fn-name-ah/eax: (addr handle word) <- get self, partial-function-name
  var fn-name/eax: (addr word) <- lookup *fn-name-ah
  compare fn-name, 0
  {
    break-if-=
#?     print-string 0, "processing goto fn\n"
    process-goto-dialog self, key
    return
  }
  var function-ah/eax: (addr handle function) <- get self, cursor-function
  var function/eax: (addr function) <- lookup *function-ah
  compare function, 0
  {
    break-if-=
#?     print-string 0, "processing function\n"
    process-function self, function, key
    return
  }
  var sandbox-ah/eax: (addr handle sandbox) <- get self, cursor-sandbox
  var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah
  compare sandbox, 0
  {
    break-if-=
#?     print-string 0, "processing sandbox\n"
    process-sandbox self, sandbox, key
    return
  }
}

# collect new name in partial-function-name, and move the cursor to function with that name
fn process-goto-dialog _self: (addr environment), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var fn-name-ah/edi: (addr handle word) <- get self, partial-function-name
  # if 'esc' pressed, cancel goto
  compare key, 0x1b/esc
  $process-goto-dialog:cancel: {
    break-if-!=
    clear-object fn-name-ah
    return
  }
  # if 'enter' pressed, location function and set cursor to it
  compare key, 0xa/enter
  $process-goto-dialog:commit: {
    break-if-!=
#?     print-string 0, "jump\n"
    var fn-name/eax: (addr word) <- lookup *fn-name-ah
    var functions/ecx: (addr handle function) <- get self, functions
    var dest/edx: (addr handle function) <- get self, cursor-function
    callee functions, fn-name, dest
    # we won't clear cursor-sandbox until we start supporting multiple sandboxes
    clear-object fn-name-ah
    # there shouldn't be any need to clear state for other dialogs in the sandbox
    return
  }
  #
  compare key, 0x7f/del  # backspace on Macs
  $process-goto-dialog:backspace: {
    break-if-!=
    # if not at start, delete grapheme before cursor
    var fn-name/eax: (addr word) <- lookup *fn-name-ah
    var at-start?/eax: boolean <- cursor-at-start? fn-name
    compare at-start?, 0/false
    {
      break-if-!=
      var fn-name/eax: (addr word) <- lookup *fn-name-ah
      delete-before-cursor fn-name
    }
    return
  }
  # otherwise insert key within current word
  var print?/eax: boolean <- real-grapheme? key
  $process-goto-dialog:real-grapheme: {
    compare print?, 0/false
    break-if-=
    var fn-name/eax: (addr word) <- lookup *fn-name-ah
    add-grapheme-to-word fn-name, key
    return
  }
  # silently ignore other hotkeys
}

fn process-function _self: (addr environment), _function: (addr function), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var function/edi: (addr function) <- copy _function
  process-function-edit self, function, key
}

fn process-function-edit _self: (addr environment), _function: (addr function), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var function/edi: (addr function) <- copy _function
  var cursor-word-ah/ebx: (addr handle word) <- get function, cursor-word
  var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
  var cursor-word/ecx: (addr word) <- copy _cursor-word
  compare key, 0x445b1b/left-arrow
  $process-function-edit:key-left-arrow: {
    break-if-!=
#?     print-string 0, "left-arrow\n"
    # if not at start, move left within current word
    var at-start?/eax: boolean <- cursor-at-start? cursor-word
    compare at-start?, 0/false
    {
      break-if-!=
#?       print-string 0, "cursor left within word\n"
      cursor-left cursor-word
      return
    }
    # otherwise move to end of previous word
    var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
#?       print-string 0, "move to previous word\n"
      cursor-to-end prev-word
      copy-object prev-word-ah, cursor-word-ah
    }
    return
  }
  compare key, 0x435b1b/right-arrow
  $process-function-edit:key-right-arrow: {
    break-if-!=
    # if not at end, move right within current word
    var at-end?/eax: boolean <- cursor-at-end? cursor-word
    compare at-end?, 0/false
    {
      break-if-!=
      cursor-right cursor-word
      return
    }
    # otherwise, move to the next word
    var next-word-ah/edx: (addr handle word) <- get cursor-word, next
    var next-word/eax: (addr word) <- lookup *next-word-ah
    {
      compare next-word, 0
      break-if-=
      cursor-to-start next-word
      copy-object next-word-ah, cursor-word-ah
    }
    return
  }
  # word-based motions
  compare key, 2/ctrl-b
  $process-function-edit:prev-word: {
    break-if-!=
    # jump to previous word if possible
    var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
      cursor-to-end prev-word
      copy-object prev-word-ah, cursor-word-ah
    }
    return
  }
  compare key, 6/ctrl-f
  $process-function-edit:next-word: {
    break-if-!=
    # jump to previous word if possible
    var next-word-ah/edx: (addr handle word) <- get cursor-word, next
    var next-word/eax: (addr word) <- lookup *next-word-ah
    {
      compare next-word, 0
      break-if-=
      cursor-to-end next-word
      copy-object next-word-ah, cursor-word-ah
    }
    return
  }
  # line-based motions
  compare key, 1/ctrl-a
  $process-function-edit:start-of-line: {
    break-if-!=
    # move cursor to start of first word
    var body-ah/eax: (addr handle line) <- get function, body
    var body/eax: (addr line) <- lookup *body-ah
    var body-contents-ah/ecx: (addr handle word) <- get body, data
    copy-object body-contents-ah, cursor-word-ah
    var body-contents/eax: (addr word) <- lookup *body-contents-ah
    cursor-to-start body-contents
    return
  }
  compare key, 5/ctrl-e
  $process-function-edit:end-of-line: {
    break-if-!=
    # move cursor to end of final word
    var body-ah/eax: (addr handle line) <- get function, body
    var body/eax: (addr line) <- lookup *body-ah
    var body-contents-ah/ecx: (addr handle word) <- get body, data
    copy-object body-contents-ah, cursor-word-ah
    final-word cursor-word-ah, cursor-word-ah
    var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
    cursor-to-end cursor-word
    return
  }
  # bounce to another function
  compare key, 7/ctrl-g
  $process-function-edit:goto-function: {
    break-if-!=
    # initialize dialog to name function to jump to
    var partial-function-name-ah/eax: (addr handle word) <- get self, partial-function-name
    allocate partial-function-name-ah
    var partial-function-name/eax: (addr word) <- lookup *partial-function-name-ah
    initialize-word partial-function-name
    return
  }
  # bounce to sandbox
  compare key, 9/tab
  $process-function-edit:goto-sandbox: {
    break-if-!=
    var function-ah/eax: (addr handle function) <- get self, cursor-function
    clear-object function-ah
    return
  }
  # editing the current function
  compare key, 0x7f/del  # backspace on Macs
  $process-function-edit:backspace: {
    break-if-!=
    # if not at start of some word, delete grapheme before cursor within current word
    var at-start?/eax: boolean <- cursor-at-start? cursor-word
    compare at-start?, 0/false
    {
      break-if-!=
      delete-before-cursor cursor-word
      return
    }
    # otherwise delete current word and move to end of prev word
    var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
      cursor-to-end prev-word
      delete-next prev-word
      copy-object prev-word-ah, cursor-word-ah
    }
    return
  }
  compare key, 0x20/space
  $process-function-edit:space: {
    break-if-!=
#?     print-string 0, "space\n"
    # if cursor is at start of word, insert word before
    {
      var at-start?/eax: boolean <- cursor-at-start? cursor-word
      compare at-start?, 0/false
      break-if-=
      var prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
      append-word prev-word-ah
      var new-prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
      copy-object new-prev-word-ah, cursor-word-ah
      return
    }
    # if start of word is quote and grapheme before cursor is not, just insert it as usual
    # TODO: support string escaping
    {
      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
      compare first-grapheme, 0x22/double-quote
      break-if-!=
      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
      compare final-grapheme, 0x22/double-quote
      break-if-=
      break $process-function-edit:space
    }
    # if start of word is '[' and grapheme before cursor is not ']', just insert it as usual
    # TODO: support nested arrays
    {
      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
      compare first-grapheme, 0x5b/[
      break-if-!=
      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
      compare final-grapheme, 0x5d/]
      break-if-=
      break $process-function-edit:space
    }
    # otherwise insert word after and move cursor to it for the next key
    # (but we'll continue to track the current cursor-word for the rest of this function)
    append-word cursor-word-ah
    var next-word-ah/eax: (addr handle word) <- get cursor-word, next
    copy-object next-word-ah, cursor-word-ah
    # if cursor is at end of word, that's all
    var at-end?/eax: boolean <- cursor-at-end? cursor-word
    compare at-end?, 0/false
    {
      break-if-=
      return
    }
    # otherwise we're in the middle of a word
    # move everything after cursor to the (just created) next word
    var next-word-ah/eax: (addr handle word) <- get cursor-word, next
    var _next-word/eax: (addr word) <- lookup *next-word-ah
    var next-word/ebx: (addr word) <- copy _next-word
    {
      var at-end?/eax: boolean <- cursor-at-end? cursor-word
      compare at-end?, 0/false
      break-if-!=
      var g/eax: grapheme <- pop-after-cursor cursor-word
      add-grapheme-to-word next-word, g
      loop
    }
    cursor-to-start next-word
    return
  }
  # otherwise insert key within current word
  var g/edx: grapheme <- copy key
  var print?/eax: boolean <- real-grapheme? key
  $process-function-edit:real-grapheme: {
    compare print?, 0/false
    break-if-=
    add-grapheme-to-word cursor-word, g
    return
  }
  # silently ignore other hotkeys
}

fn process-sandbox _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var sandbox/edi: (addr sandbox) <- copy _sandbox
  var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word
  var rename-word-mode?/eax: (addr word) <- lookup *rename-word-mode-ah?
  compare rename-word-mode?, 0
  {
    break-if-=
#?     print-string 0, "processing sandbox rename\n"
    process-sandbox-rename sandbox, key
    return
  }
  var define-function-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-function
  var define-function-mode?/eax: (addr word) <- lookup *define-function-mode-ah?
  compare define-function-mode?, 0
  {
    break-if-=
#?     print-string 0, "processing function definition\n"
    var functions/ecx: (addr handle function) <- get self, functions
    process-sandbox-define sandbox, functions, key
    return
  }
#?   print-string 0, "processing sandbox edit\n"
  process-sandbox-edit self, sandbox, key
}

fn process-sandbox-edit _self: (addr environment), _sandbox: (addr sandbox), key: grapheme {
  var self/esi: (addr environment) <- copy _self
  var sandbox/edi: (addr sandbox) <- copy _sandbox
  var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
  var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
  var cursor-word-ah/ebx: (addr handle word) <- get cursor-call-path, word
  var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
  var cursor-word/ecx: (addr word) <- copy _cursor-word
  compare key, 0x445b1b/left-arrow
  $process-sandbox-edit:key-left-arrow: {
    break-if-!=
#?     print-string 0, "left-arrow\n"
    # if not at start, move left within current word
    var at-start?/eax: boolean <- cursor-at-start? cursor-word
    compare at-start?, 0/false
    {
      break-if-!=
#?       print-string 0, "cursor left within word\n"
      cursor-left cursor-word
      return
    }
    # if current word is expanded, move to the rightmost word in its body
    {
      var cursor-call-path/esi: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var expanded-words/edx: (addr handle call-path) <- get sandbox, expanded-words
      var curr-word-is-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path
      compare curr-word-is-expanded?, 0/false
      break-if-=
      # update cursor-call-path
#?       print-string 0, "curr word is expanded\n"
      var self/ecx: (addr environment) <- copy _self
      var functions/ecx: (addr handle function) <- get self, functions
      var body: (handle line)
      var body-ah/eax: (addr handle line) <- address body
      function-body functions, cursor-word-ah, body-ah
      var body-addr/eax: (addr line) <- lookup *body-ah
      var first-word-ah/edx: (addr handle word) <- get body-addr, data
      var final-word-h: (handle word)
      var final-word-ah/eax: (addr handle word) <- address final-word-h
      final-word first-word-ah, final-word-ah
      push-to-call-path-element cursor-call-path, final-word-ah
      # move cursor to end of word
      var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
      var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
      var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
      cursor-to-end cursor-word
      return
    }
    # if at first word, look for a caller to jump to
    $process-sandbox-edit:key-left-arrow-first-word: {
      var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
      var prev-word/eax: (addr word) <- lookup *prev-word-ah
      compare prev-word, 0
      break-if-!=
      $process-sandbox-edit:key-left-arrow-first-word-and-caller: {
#?         print-string 0, "return\n"
        {
          var cursor-call-path-ah/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
          var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
          var next-cursor-element-ah/edx: (addr handle call-path-element) <- get cursor-call-path, next
          var next-cursor-element/eax: (addr call-path-element) <- lookup *next-cursor-element-ah
          compare next-cursor-element, 0
          break-if-= $process-sandbox-edit:key-left-arrow-first-word-and-caller
          copy-object next-cursor-element-ah, cursor-call-path-ah
        }
        var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
        var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
        var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
        var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
        cursor-word <- copy _cursor-word
      }
    }
    # then move to end of previous word
    var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
#?       print-string 0, "move to previous word\n"
      cursor-to-end prev-word
#?       {
#?         var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
#?         var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
#?         var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
#?         var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
#?         var cursor-word/ebx: (addr word) <- copy _cursor-word
#?         print-string 0, "word at cursor before: "
#?         print-word 0, cursor-word
#?         print-string 0, "\n"
#?       }
      var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      decrement-final-element cursor-call-path
#?       {
#?         var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
#?         var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
#?         var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
#?         var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
#?         var cursor-word/ebx: (addr word) <- copy _cursor-word
#?         print-string 0, "word at cursor after: "
#?         print-word 0, cursor-word
#?         print-string 0, "\n"
#?       }
    }
    return
  }
  compare key, 0x435b1b/right-arrow
  $process-sandbox-edit:key-right-arrow: {
    break-if-!=
    # if not at end, move right within current word
    var at-end?/eax: boolean <- cursor-at-end? cursor-word
    compare at-end?, 0/false
    {
      break-if-!=
#?       print-string 0, "a\n"
      cursor-right cursor-word
      return
    }
    # if at final word, look for a caller to jump to
    {
      var next-word-ah/edx: (addr handle word) <- get cursor-word, next
      var next-word/eax: (addr word) <- lookup *next-word-ah
      compare next-word, 0
      break-if-!=
      var cursor-call-path-ah/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
      var next-cursor-element-ah/ecx: (addr handle call-path-element) <- get cursor-call-path, next
      var next-cursor-element/eax: (addr call-path-element) <- lookup *next-cursor-element-ah
      compare next-cursor-element, 0
      break-if-=
      copy-object next-cursor-element-ah, cursor-call-path-ah
      return
    }
    # otherwise, move to the next word
    var next-word-ah/edx: (addr handle word) <- get cursor-word, next
    var next-word/eax: (addr word) <- lookup *next-word-ah
    {
      compare next-word, 0
      break-if-=
#?       print-string 0, "b\n"
      cursor-to-start next-word
      # . . cursor-word now out of date
      var cursor-call-path/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path
      increment-final-element cursor-call-path
      # Is the new cursor word expanded? If so, it's a function call. Add a
      # new level to the cursor-call-path for the call's body.
      $process-sandbox-edit:key-right-arrow-next-word-is-call-expanded: {
#?         print-string 0, "c\n"
        {
          var expanded-words/eax: (addr handle call-path) <- get sandbox, expanded-words
          var curr-word-is-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path
          compare curr-word-is-expanded?, 0/false
          break-if-= $process-sandbox-edit:key-right-arrow-next-word-is-call-expanded
        }
        var callee-h: (handle function)
        var callee-ah/edx: (addr handle function) <- address callee-h
        var functions/ebx: (addr handle function) <- get self, functions
        callee functions, next-word, callee-ah
        var callee/eax: (addr function) <- lookup *callee-ah
        var callee-body-ah/eax: (addr handle line) <- get callee, body
        var callee-body/eax: (addr line) <- lookup *callee-body-ah
        var callee-body-first-word/edx: (addr handle word) <- get callee-body, data
        push-to-call-path-element cursor-call-path, callee-body-first-word
        # position cursor at left
        var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
        var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
        var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
        var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
        cursor-to-start cursor-word
#?         print-string 0, "d\n"
        return
      }
    }
    return
  }
  compare key, 0xa/enter
  {
    break-if-!=
    # toggle display of subsidiary stack
    toggle-cursor-word sandbox
    return
  }
  compare key, 0xc/ctrl-l
  $process-sandbox-edit:new-line: {
    break-if-!=
    # new line in sandbox
    append-line sandbox
    return
  }
  # word-based motions
  compare key, 2/ctrl-b
  $process-sandbox-edit:prev-word: {
    break-if-!=
    # jump to previous word at same level
    var prev-word-ah/edx: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
      cursor-to-end prev-word
      var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      decrement-final-element cursor-call-path
      return
    }
    # if previous word doesn't exist, try to bump up one level
    {
      var cursor-call-path-ah/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
      var caller-cursor-element-ah/ecx: (addr handle call-path-element) <- get cursor-call-path, next
      var caller-cursor-element/eax: (addr call-path-element) <- lookup *caller-cursor-element-ah
      compare caller-cursor-element, 0
      break-if-=
      # check if previous word exists in caller
      var caller-word-ah/eax: (addr handle word) <- get caller-cursor-element, word
      var caller-word/eax: (addr word) <- lookup *caller-word-ah
      var word-before-caller-ah/eax: (addr handle word) <- get caller-word, prev
      var word-before-caller/eax: (addr word) <- lookup *word-before-caller-ah
      compare word-before-caller, 0
      break-if-=
      # if so jump to it
      drop-from-call-path-element cursor-call-path-ah
      decrement-final-element cursor-call-path-ah
      return
    }
  }
  compare key, 6/ctrl-f
  $process-sandbox-edit:next-word: {
    break-if-!=
#?     print-string 0, "AA\n"
    # jump to previous word at same level
    var next-word-ah/edx: (addr handle word) <- get cursor-word, next
    var next-word/eax: (addr word) <- lookup *next-word-ah
    {
      compare next-word, 0
      break-if-=
#?       print-string 0, "BB\n"
      cursor-to-end next-word
      var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      increment-final-element cursor-call-path
      return
    }
    # if next word doesn't exist, try to bump up one level
#?     print-string 0, "CC\n"
    var cursor-call-path-ah/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
    var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
    var caller-cursor-element-ah/ecx: (addr handle call-path-element) <- get cursor-call-path, next
    var caller-cursor-element/eax: (addr call-path-element) <- lookup *caller-cursor-element-ah
    compare caller-cursor-element, 0
    break-if-=
#?     print-string 0, "DD\n"
    copy-object caller-cursor-element-ah, cursor-call-path-ah
    return
  }
  compare key, 7/ctrl-g
  $process-sandbox-edit:goto-function: {
    break-if-!=
    # initialize dialog to name function to jump to
    var partial-function-name-ah/eax: (addr handle word) <- get self, partial-function-name
    allocate partial-function-name-ah
    var partial-function-name/eax: (addr word) <- lookup *partial-function-name-ah
    initialize-word partial-function-name
    return
  }
  # line-based motions
  compare key, 1/ctrl-a
  $process-sandbox-edit:start-of-line: {
    break-if-!=
    # move cursor up past all calls and to start of line
    var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
    drop-nested-calls cursor-call-path-ah
    move-final-element-to-start-of-line cursor-call-path-ah
    # move cursor to start of word
    var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
    var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
    var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
    cursor-to-start cursor-word
    # this works as long as the first word isn't expanded
    # but we don't expect to see zero-arg functions first-up
    return
  }
  compare key, 5/ctrl-e
  $process-sandbox-edit:end-of-line: {
    break-if-!=
    # move cursor up past all calls and to start of line
    var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
    drop-nested-calls cursor-call-path-ah
    move-final-element-to-end-of-line cursor-call-path-ah
    # move cursor to end of word
    var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
    var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
    var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
    cursor-to-end cursor-word
    # this works because expanded words lie to the right of their bodies
    # so the final word is always guaranteed to be at the top-level
    return
  }
  compare key, 0x15/ctrl-u
  $process-sandbox-edit:clear-line: {
    break-if-!=
    # clear line in sandbox
    initialize-sandbox sandbox
    return
  }
  # if cursor is within a call, disable editing hotkeys below
  var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
  var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
  var next-cursor-element-ah/eax: (addr handle call-path-element) <- get cursor-call-path, next
  var next-cursor-element/eax: (addr call-path-element) <- lookup *next-cursor-element-ah
  compare next-cursor-element, 0
  {
    break-if-=
    return
  }
  # - remaining keys only work at the top row outside any function calls
  compare key, 0x7f/del  # backspace on Macs
  $process-sandbox-edit:backspace: {
    break-if-!=
    # if not at start of some word, delete grapheme before cursor within current word
    var at-start?/eax: boolean <- cursor-at-start? cursor-word
    compare at-start?, 0/false
    {
      break-if-!=
      delete-before-cursor cursor-word
      return
    }
    # otherwise delete current word and move to end of prev word
    var prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
    var prev-word/eax: (addr word) <- lookup *prev-word-ah
    {
      compare prev-word, 0
      break-if-=
      cursor-to-end prev-word
      delete-next prev-word
      var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      decrement-final-element cursor-call-path
    }
    return
  }
  compare key, 0x20/space
  $process-sandbox-edit:space: {
    break-if-!=
#?     print-string 0, "space\n"
    # if cursor is at start of word, insert word before
    {
      var at-start?/eax: boolean <- cursor-at-start? cursor-word
      compare at-start?, 0/false
      break-if-=
      var prev-word-ah/eax: (addr handle word) <- get cursor-word, prev
      append-word prev-word-ah
      var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      decrement-final-element cursor-call-path
      return
    }
    # if start of word is quote and grapheme before cursor is not, just insert it as usual
    # TODO: support string escaping
    {
      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
      compare first-grapheme, 0x22/double-quote
      break-if-!=
      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
      compare final-grapheme, 0x22/double-quote
      break-if-=
      break $process-sandbox-edit:space
    }
    # if start of word is '[' and grapheme before cursor is not ']', just insert it as usual
    # TODO: support nested arrays
    {
      var first-grapheme/eax: grapheme <- first-grapheme cursor-word
      compare first-grapheme, 0x5b/[
      break-if-!=
      var final-grapheme/eax: grapheme <- grapheme-before-cursor cursor-word
      compare final-grapheme, 0x5d/]
      break-if-=
      break $process-sandbox-edit:space
    }
    # otherwise insert word after and move cursor to it for the next key
    # (but we'll continue to track the current cursor-word for the rest of this function)
    append-word cursor-word-ah
    var cursor-call-path/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
    increment-final-element cursor-call-path
    # if cursor is at end of word, that's all
    var at-end?/eax: boolean <- cursor-at-end? cursor-word
    compare at-end?, 0/false
    {
      break-if-=
      return
    }
    # otherwise we're in the middle of a word
    # move everything after cursor to the (just created) next word
    var next-word-ah/eax: (addr handle word) <- get cursor-word, next
    var _next-word/eax: (addr word) <- lookup *next-word-ah
    var next-word/ebx: (addr word) <- copy _next-word
    {
      var at-end?/eax: boolean <- cursor-at-end? cursor-word
      compare at-end?, 0/false
      break-if-!=
      var g/eax: grapheme <- pop-after-cursor cursor-word
      add-grapheme-to-word next-word, g
      loop
    }
    cursor-to-start next-word
    return
  }
  compare key, 0xe/ctrl-n
  $process:rename-word: {
    break-if-!=
    # TODO: ensure current word is not a function
    # rename word at cursor
    var new-name-ah/eax: (addr handle word) <- get sandbox, partial-name-for-cursor-word
    allocate new-name-ah
    var new-name/eax: (addr word) <- lookup *new-name-ah
    initialize-word new-name
    return
  }
  compare key, 4/ctrl-d
  $process:define-function: {
    break-if-!=
    # define function out of line at cursor
    var new-name-ah/eax: (addr handle word) <- get sandbox, partial-name-for-function
    allocate new-name-ah
    var new-name/eax: (addr word) <- lookup *new-name-ah
    initialize-word new-name
    return
  }
  # otherwise insert key within current word
  var g/edx: grapheme <- copy key
  var print?/eax: boolean <- real-grapheme? key
  $process-sandbox-edit:real-grapheme: {
    compare print?, 0/false
    break-if-=
    add-grapheme-to-word cursor-word, g
    return
  }
  # silently ignore other hotkeys
}

# collect new name in partial-name-for-cursor-word, and then rename the word
# at cursor to it
# Precondition: cursor-call-path is a singleton (not within a call)
fn process-sandbox-rename _sandbox: (addr sandbox), key: grapheme {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-cursor-word
  # if 'esc' pressed, cancel rename
  compare key, 0x1b/esc
  $process-sandbox-rename:cancel: {
    break-if-!=
    clear-object new-name-ah
    return
  }
  # if 'enter' pressed, perform rename
  compare key, 0xa/enter
  $process-sandbox-rename:commit: {
    break-if-!=
#?     print-string 0, "rename\n"
    # new line
    var new-line-h: (handle line)
    var new-line-ah/eax: (addr handle line) <- address new-line-h
    allocate new-line-ah
    var new-line/eax: (addr line) <- lookup *new-line-ah
    initialize-line new-line
    var new-line-word-ah/ecx: (addr handle word) <- get new-line, data
    {
      # move word at cursor to new line
      var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var cursor/eax: (addr call-path-element) <- lookup *cursor-ah
      var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word
#?       print-string 0, "cursor before at word "
#?       {
#?         var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah
#?         print-word 0, cursor-word
#?         print-string 0, "\n"
#?       }
      move-word-contents word-at-cursor-ah, new-line-word-ah
      # copy name to word at cursor
      copy-word-contents-before-cursor new-name-ah, word-at-cursor-ah
#?       print-string 0, "cursor after at word "
#?       {
#?         var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah
#?         print-word 0, cursor-word
#?         print-string 0, "\n"
#?         var foo/eax: int <- copy cursor-word
#?         print-int32-hex 0, foo
#?         print-string 0, "\n"
#?       }
#?       print-string 0, "new name word "
#?       {
#?         var new-name/eax: (addr word) <- lookup *new-name-ah
#?         print-word 0, new-name
#?         print-string 0, "\n"
#?         var foo/eax: int <- copy new-name
#?         print-int32-hex 0, foo
#?         print-string 0, "\n"
#?       }
    }
    # prepend '=' to name
    {
      var new-name/eax: (addr word) <- lookup *new-name-ah
      cursor-to-start new-name
      add-grapheme-to-word new-name, 0x3d/=
    }
    # append name to new line
    chain-words new-line-word-ah, new-name-ah
    # new-line->next = sandbox->data
    var new-line-next/ecx: (addr handle line) <- get new-line, next
    var sandbox-slot/edx: (addr handle line) <- get sandbox, data
    copy-object sandbox-slot, new-line-next
    # sandbox->data = new-line
    copy-handle new-line-h, sandbox-slot
    # clear partial-name-for-cursor-word
    clear-object new-name-ah
#?     var cursor-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
#?     var cursor/eax: (addr call-path-element) <- lookup *cursor-ah
#?     var word-at-cursor-ah/eax: (addr handle word) <- get cursor, word
#?     print-string 0, "cursor after rename: "
#?     {
#?       var cursor-word/eax: (addr word) <- lookup *word-at-cursor-ah
#?       print-word 0, cursor-word
#?       print-string 0, " -- "
#?       var foo/eax: int <- copy cursor-word
#?       print-int32-hex 0, foo
#?       print-string 0, "\n"
#?     }
    return
  }
  #
  compare key, 0x7f/del  # backspace on Macs
  $process-sandbox-rename:backspace: {
    break-if-!=
    # if not at start, delete grapheme before cursor
    var new-name/eax: (addr word) <- lookup *new-name-ah
    var at-start?/eax: boolean <- cursor-at-start? new-name
    compare at-start?, 0/false
    {
      break-if-!=
      var new-name/eax: (addr word) <- lookup *new-name-ah
      delete-before-cursor new-name
    }
    return
  }
  # otherwise insert key within current word
  var print?/eax: boolean <- real-grapheme? key
  $process-sandbox-rename:real-grapheme: {
    compare print?, 0/false
    break-if-=
    var new-name/eax: (addr word) <- lookup *new-name-ah
    add-grapheme-to-word new-name, key
    return
  }
  # silently ignore other hotkeys
}

# collect new name in partial-name-for-function, and then define the last line
# of the sandbox to be a new function with that name. Replace the last line
# with a call to the appropriate function.
# Precondition: cursor-call-path is a singleton (not within a call)
fn process-sandbox-define _sandbox: (addr sandbox), functions: (addr handle function), key: grapheme {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var new-name-ah/edi: (addr handle word) <- get sandbox, partial-name-for-function
  # if 'esc' pressed, cancel define
  compare key, 0x1b/esc
  $process-sandbox-define:cancel: {
    break-if-!=
    clear-object new-name-ah
    return
  }
  # if 'enter' pressed, perform define
  compare key, 0xa/enter
  $process-sandbox-define:commit: {
    break-if-!=
#?     print-string 0, "define\n"
    # create new function
    var new-function: (handle function)
    var new-function-ah/ecx: (addr handle function) <- address new-function
    allocate new-function-ah
    var _new-function/eax: (addr function) <- lookup *new-function-ah
    var new-function/ebx: (addr function) <- copy _new-function
    var dest/edx: (addr handle function) <- get new-function, next
    copy-object functions, dest
    copy-object new-function-ah, functions
    # set function name to new-name
    var new-name/eax: (addr word) <- lookup *new-name-ah
    var dest/edx: (addr handle array byte) <- get new-function, name
    word-to-string new-name, dest
    # move final line to body
    var body-ah/eax: (addr handle line) <- get new-function, body
    allocate body-ah
    var body/eax: (addr line) <- lookup *body-ah
    var body-contents/ecx: (addr handle word) <- get body, data
    var final-line-storage: (handle line)
    var final-line-ah/eax: (addr handle line) <- address final-line-storage
    final-line sandbox, final-line-ah
    var final-line/eax: (addr line) <- lookup *final-line-ah
    var final-line-contents/eax: (addr handle word) <- get final-line, data
    copy-object final-line-contents, body-contents
    var cursor-word-ah/ecx: (addr handle word) <- get new-function, cursor-word
    copy-object final-line-contents, cursor-word-ah
    {
      var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
      cursor-to-start cursor-word
    }
    #
    copy-unbound-words-to-args functions
    #
    var empty-word: (handle word)
    copy-handle empty-word, final-line-contents
    construct-call functions, final-line-contents
    # clear partial-name-for-function
    var empty-word: (handle word)
    copy-handle empty-word, new-name-ah
    # update cursor
    var final-line/eax: (addr line) <- lookup final-line-storage
    var cursor-call-path-ah/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path
    allocate cursor-call-path-ah  # leak
    initialize-path-from-line final-line, cursor-call-path-ah
    return
  }
  #
  compare key, 0x7f/del  # backspace on Macs
  $process-sandbox-define:backspace: {
    break-if-!=
    # if not at start, delete grapheme before cursor
    var new-name/eax: (addr word) <- lookup *new-name-ah
    var at-start?/eax: boolean <- cursor-at-start? new-name
    compare at-start?, 0/false
    {
      break-if-!=
      var new-name/eax: (addr word) <- lookup *new-name-ah
      delete-before-cursor new-name
    }
    return
  }
  # otherwise insert key within current word
  var print?/eax: boolean <- real-grapheme? key
  $process-sandbox-define:real-grapheme: {
    compare print?, 0/false
    break-if-=
    var new-name/eax: (addr word) <- lookup *new-name-ah
    add-grapheme-to-word new-name, key
    return
  }
  # silently ignore other hotkeys
}

# extract from the body of the first function in 'functions' all words that
# aren't defined in the rest of 'functions'. Prepend them in reverse order.
# Assumes function body is a single line for now.
fn copy-unbound-words-to-args _functions: (addr handle function) {
  # target
  var target-ah/eax: (addr handle function) <- copy _functions
  var _target/eax: (addr function) <- lookup *target-ah
  var target/esi: (addr function) <- copy _target
  var dest-ah/edi: (addr handle word) <- get target, args
  # next
  var functions-ah/edx: (addr handle function) <- get target, next
  # src
  var line-ah/eax: (addr handle line) <- get target, body
  var line/eax: (addr line) <- lookup *line-ah
  var curr-ah/eax: (addr handle word) <- get line, data
  var curr/eax: (addr word) <- lookup *curr-ah
  {
    compare curr, 0
    break-if-=
    $copy-unbound-words-to-args:loop-iter: {
      # is it a number?
      {
        var int?/eax: boolean <- word-is-decimal-integer? curr
        compare int?, 0/false
        break-if-!= $copy-unbound-words-to-args:loop-iter
      }
      # is it a pre-existing function?
      var bound?/ebx: boolean <- bound-function? curr, functions-ah
      compare bound?, 0/false
      break-if-!=
      # is it already bound as an arg?
      var dup?/ebx: boolean <- arg-exists? _functions, curr  # _functions = target-ah
      compare dup?, 0/false
      break-if-!= $copy-unbound-words-to-args:loop-iter
      # push copy of curr before dest-ah
      var rest-h: (handle word)
      var rest-ah/ecx: (addr handle word) <- address rest-h
      copy-object dest-ah, rest-ah
      copy-word curr, dest-ah
      chain-words dest-ah, rest-ah
    }
    var next-ah/ecx: (addr handle word) <- get curr, next
    curr <- lookup *next-ah
    loop
  }
}

fn bound-function? w: (addr word), functions-ah: (addr handle function) -> _/ebx: boolean {
  var result/ebx: boolean <- copy 1/true
  {
    ## numbers
    # if w == "+" return true
    var subresult/eax: boolean <- word-equal? w, "+"
    compare subresult, 0/false
    break-if-!=
    # if w == "-" return true
    subresult <- word-equal? w, "-"
    compare subresult, 0/false
    break-if-!=
    # if w == "*" return true
    subresult <- word-equal? w, "*"
    compare subresult, 0/false
    break-if-!=
    # if w == "/" return true
    subresult <- word-equal? w, "/"
    compare subresult, 0/false
    break-if-!=
    # if w == "sqrt" return true
    subresult <- word-equal? w, "sqrt"
    compare subresult, 0/false
    break-if-!=
    ## strings/arrays
    # if w == "len" return true
    subresult <- word-equal? w, "len"
    compare subresult, 0/false
    break-if-!=
    ## files
    # if w == "open" return true
    subresult <- word-equal? w, "open"
    compare subresult, 0/false
    break-if-!=
    # if w == "read" return true
    subresult <- word-equal? w, "read"
    compare subresult, 0/false
    break-if-!=
    # if w == "slurp" return true
    subresult <- word-equal? w, "slurp"
    compare subresult, 0/false
    break-if-!=
    # if w == "lines" return true
    subresult <- word-equal? w, "lines"
    compare subresult, 0/false
    break-if-!=
    ## screens
    # if w == "fake-screen" return true
    subresult <- word-equal? w, "fake-screen"
    compare subresult, 0/false
    break-if-!=
    # if w == "print" return true
    subresult <- word-equal? w, "print"
    compare subresult, 0/false
    break-if-!=
    # if w == "move" return true
    subresult <- word-equal? w, "move"
    compare subresult, 0/false
    break-if-!=
    # if w == "up" return true
    subresult <- word-equal? w, "up"
    compare subresult, 0/false
    break-if-!=
    # if w == "down" return true
    subresult <- word-equal? w, "down"
    compare subresult, 0/false
    break-if-!=
    # if w == "left" return true
    subresult <- word-equal? w, "left"
    compare subresult, 0/false
    break-if-!=
    # if w == "right" return true
    subresult <- word-equal? w, "right"
    compare subresult, 0/false
    break-if-!=
    ## hacks
    # if w == "dup" return true
    subresult <- word-equal? w, "dup"
    compare subresult, 0/false
    break-if-!=
    # if w == "swap" return true
    subresult <- word-equal? w, "swap"
    compare subresult, 0/false
    break-if-!=
    # return w in functions
    var out-h: (handle function)
    var out/eax: (addr handle function) <- address out-h
    callee functions-ah, w, out
    var found?/eax: (addr function) <- lookup *out
    result <- copy found?
  }
  return result
}

fn arg-exists? _f-ah: (addr handle function), arg: (addr word) -> _/ebx: boolean {
  var f-ah/eax: (addr handle function) <- copy _f-ah
  var f/eax: (addr function) <- lookup *f-ah
  var args-ah/eax: (addr handle word) <- get f, args
  var result/ebx: boolean <- word-exists? args-ah, arg
  return result
}

# construct a call to `f` with copies of exactly its args
fn construct-call _f-ah: (addr handle function), _dest-ah: (addr handle word) {
  var f-ah/eax: (addr handle function) <- copy _f-ah
  var _f/eax: (addr function) <- lookup *f-ah
  var f/esi: (addr function) <- copy _f
  # append args in reverse
  var args-ah/eax: (addr handle word) <- get f, args
  var dest-ah/edi: (addr handle word) <- copy _dest-ah
  copy-words-in-reverse args-ah, dest-ah
  # append name
  var name-ah/eax: (addr handle array byte) <- get f, name
  var name/eax: (addr array byte) <- lookup *name-ah
  append-word-at-end-with dest-ah, name
}

fn word-index _words: (addr handle word), _n: int, out: (addr handle word) {
  var n/ecx: int <- copy _n
  {
    compare n, 0
    break-if-!=
    copy-object _words, out
    return
  }
  var words-ah/eax: (addr handle word) <- copy _words
  var words/eax: (addr word) <- lookup *words-ah
  var next/eax: (addr handle word) <- get words, next
  n <- decrement
  word-index next, n, out
}

fn toggle-cursor-word _sandbox: (addr sandbox) {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words
  var cursor-call-path/ecx: (addr handle call-path-element) <- get sandbox, cursor-call-path
#?   print-string 0, "cursor call path: "
#?   dump-call-path-element 0, cursor-call-path
#?   print-string 0, "expanded words:\n"
#?   dump-call-paths 0, expanded-words
  var already-expanded?/eax: boolean <- find-in-call-paths expanded-words, cursor-call-path
  compare already-expanded?, 0/false
  {
    break-if-!=
#?     print-string 0, "expand\n"
    # if not already-expanded, insert
    insert-in-call-path expanded-words cursor-call-path
#?     print-string 0, "expanded words now:\n"
#?     dump-call-paths 0, expanded-words
    return
  }
  {
    break-if-=
    # otherwise delete
    delete-in-call-path expanded-words cursor-call-path
  }
}

fn append-line _sandbox: (addr sandbox) {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var line-ah/ecx: (addr handle line) <- get sandbox, data
  {
    var line/eax: (addr line) <- lookup *line-ah
    var next-line-ah/edx: (addr handle line) <- get line, next
    var next-line/eax: (addr line) <- lookup *next-line-ah
    compare next-line, 0
    break-if-=
    line-ah <- copy next-line-ah
    loop
  }
  var line/eax: (addr line) <- lookup *line-ah
  var final-line-ah/edx: (addr handle line) <- get line, next
  allocate final-line-ah
  var final-line/eax: (addr line) <- lookup *final-line-ah
  initialize-line final-line
  var final-prev/eax: (addr handle line) <- get final-line, prev
  copy-object line-ah, final-prev
  # clear cursor
  var final-line/eax: (addr line) <- lookup *final-line-ah
  var word-ah/ecx: (addr handle word) <- get final-line, data
  var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
  var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
  var dest/eax: (addr handle word) <- get cursor-call-path, word
  copy-object word-ah, dest
}

#############
# Visualize
#############

fn evaluate-environment _env: (addr environment), stack: (addr value-stack) {
  var env/esi: (addr environment) <- copy _env
  # functions
  var functions/edx: (addr handle function) <- get env, functions
  # line
  var sandbox-ah/esi: (addr handle sandbox) <- get env, sandboxes
  var sandbox/eax: (addr sandbox) <- lookup *sandbox-ah
  var line-ah/eax: (addr handle line) <- get sandbox, data
  var _line/eax: (addr line) <- lookup *line-ah
  var line/esi: (addr line) <- copy _line
  evaluate functions, 0, line, 0, stack
}

fn render _env: (addr environment) {
#?   print-string 0, "== render\n"
  var env/esi: (addr environment) <- copy _env
  clear-canvas env
  # menu
  render-menu env
  # screen
  var screen-ah/eax: (addr handle screen) <- get env, screen
  var _screen/eax: (addr screen) <- lookup *screen-ah
  var screen/edi: (addr screen) <- copy _screen
  # functions
  var sep-col/eax: (addr int) <- get env, code-separator-col
  var functions/edx: (addr handle function) <- get env, functions
  render-functions screen, *sep-col, env
  # sandbox
  var repl-col/ecx: int <- copy *sep-col
  repl-col <- add 2/repl-margin-left
  var cursor-sandbox-ah/eax: (addr handle sandbox) <- get env, cursor-sandbox
  var cursor-sandbox/eax: (addr sandbox) <- lookup *cursor-sandbox-ah
  # bindings
  var bindings-storage: table
  var bindings/ebx: (addr table) <- address bindings-storage
  initialize-table bindings, 0x10
#?   print-string 0, "render-sandbox {\n"
  render-sandbox screen, functions, bindings, cursor-sandbox, 3, repl-col
#?   print-string 0, "render-sandbox }\n"
  # dialogs
  render-goto-dialog screen, env
  #
  position-cursor screen, env
}

# draw a wordstar-style cheatsheet of shortcuts on the bottom line of the screen
fn render-menu _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var cursor-function-ah/eax: (addr handle function) <- get env, cursor-function
  var cursor-function/eax: (addr function) <- lookup *cursor-function-ah
  {
    compare cursor-function, 0
    break-if-=
    render-function-menu env
    return
  }
  var cursor-sandbox-ah/eax: (addr handle sandbox) <- get env, cursor-sandbox
  var cursor-sandbox/eax: (addr sandbox) <- lookup *cursor-sandbox-ah
  {
    compare cursor-sandbox, 0
    break-if-=
    render-sandbox-menu env
    return
  }
}

# HACK: areas currently responsible for positioning their dialogs' cursors. So
# we just do nothing here if a dialog is up.
fn position-cursor screen: (addr screen), _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var goto-function-ah/eax: (addr handle word) <- get env, partial-function-name
  var goto-function/eax: (addr word) <- lookup *goto-function-ah
  {
    compare goto-function, 0
    break-if-=
    return
  }
  var cursor-function-ah/eax: (addr handle function) <- get env, cursor-function
  var cursor-function/eax: (addr function) <- lookup *cursor-function-ah
  {
    compare cursor-function, 0
    break-if-=
    var cursor-row/ecx: (addr int) <- get cursor-function, cursor-row
    var cursor-col/eax: (addr int) <- get cursor-function, cursor-col
    move-cursor screen, *cursor-row, *cursor-col
    return
  }
  var cursor-sandbox-ah/eax: (addr handle sandbox) <- get env, cursor-sandbox
  var cursor-sandbox/eax: (addr sandbox) <- lookup *cursor-sandbox-ah
  {
    compare cursor-sandbox, 0
    break-if-=
    # if in a dialog, return
    {
      var partial-word-rename-ah/eax: (addr handle word) <- get cursor-sandbox, partial-name-for-cursor-word
      var partial-word-rename/eax: (addr word) <- lookup *partial-word-rename-ah
      compare partial-word-rename, 0
      break-if-=
      return
    }
    {
      var partial-function-name-ah/eax: (addr handle word) <- get cursor-sandbox, partial-name-for-function
      var partial-function-name/eax: (addr word) <- lookup *partial-function-name-ah
      compare partial-function-name, 0
      break-if-=
      return
    }
    var cursor-row/ecx: (addr int) <- get cursor-sandbox, cursor-row
    var cursor-col/eax: (addr int) <- get cursor-sandbox, cursor-col
    move-cursor screen, *cursor-row, *cursor-col
  }
}

fn render-goto-dialog screen: (addr screen), _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var goto-function-mode-ah?/eax: (addr handle word) <- get env, partial-function-name
  var goto-function-mode?/eax: (addr word) <- lookup *goto-function-mode-ah?
  compare goto-function-mode?, 0/false
  break-if-=
  # clear a space for the dialog
  var top-row/ebx: int <- copy 3
  var bottom-row/edx: int <- copy 9
  var sep-col/eax: (addr int) <- get env, code-separator-col
  var left-col/ecx: int <- copy *sep-col
  left-col <- subtract 0x10
  var right-col/eax: int <- copy *sep-col
  right-col <- add 0x10
  clear-rect screen, top-row, left-col, bottom-row, right-col
  draw-box screen, top-row, left-col, bottom-row, right-col
  # render a little menu for the dialog
  var menu-row/eax: int <- copy bottom-row
  menu-row <- decrement
  var menu-col/edx: int <- copy left-col
  menu-col <- add 2
  move-cursor screen, menu-row, menu-col
  start-reverse-video screen
  print-string screen, " esc "
  reset-formatting screen
  print-string screen, " cancel  "
  start-reverse-video screen
  print-string screen, " enter "
  reset-formatting screen
  print-string screen, " jump  "
  # draw the word, positioned appropriately around the cursor
  var start-col/ecx: int <- copy left-col
  start-col <- increment
  move-cursor screen, 6, start-col  # cursor-row
  var word-ah?/edx: (addr handle word) <- get env, partial-function-name
  var word/eax: (addr word) <- lookup *word-ah?
  print-word screen, word
}

fn render-sandbox screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  # line
  var curr-line-ah/eax: (addr handle line) <- get sandbox, data
  var _curr-line/eax: (addr line) <- lookup *curr-line-ah
  var curr-line/ecx: (addr line) <- copy _curr-line
  #
  var curr-row/edx: int <- copy top-row
  # cursor row, col
  var cursor-row-addr: (addr int)
  var tmp/eax: (addr int) <- get sandbox, cursor-row
  copy-to cursor-row-addr, tmp
  var cursor-col-addr: (addr int)
  tmp <- get sandbox, cursor-col
  copy-to cursor-col-addr, tmp
  # render all but final line without stack
#?   print-string 0, "render all but final line\n"
  {
    var next-line-ah/eax: (addr handle line) <- get curr-line, next
    var next-line/eax: (addr line) <- lookup *next-line-ah
    compare next-line, 0
    break-if-=
    {
      var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
      var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
      var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
      var cursor-word/eax: (addr word) <- lookup *cursor-word-ah
      # it's enough to pass in the first word of the path, because if the path isn't a singleton the word is guaranteed to be unique
      render-line-without-stack screen, curr-line, curr-row, left-col, cursor-word, cursor-row-addr, cursor-col-addr
    }
    curr-line <- copy next-line
    curr-row <- add 2
    loop
  }
  #
  render-final-line-with-stack screen, functions, bindings, sandbox, curr-row, left-col, cursor-row-addr, cursor-col-addr
  # at most one of the following dialogs will be rendered
  render-rename-dialog screen, sandbox
  render-define-dialog screen, sandbox
}

fn render-final-line-with-stack screen: (addr screen), functions: (addr handle function), bindings: (addr table), _sandbox: (addr sandbox), top-row: int, left-col: int, cursor-row-addr: (addr int), cursor-col-addr: (addr int) {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  # expanded-words
  var expanded-words/edi: (addr handle call-path) <- get sandbox, expanded-words
  # cursor-word
  var cursor-call-path-ah/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
  var cursor-call-path/eax: (addr call-path-element) <- lookup *cursor-call-path-ah
  var cursor-word-ah/eax: (addr handle word) <- get cursor-call-path, word
  var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
  var cursor-word/ebx: (addr word) <- copy _cursor-word
#?   print-string 0, "word at cursor: "
#?   print-word 0, cursor-word
#?   print-string 0, "\n"
  # cursor-call-path
  var cursor-call-path: (addr handle call-path-element)
  {
    var src/eax: (addr handle call-path-element) <- get sandbox, cursor-call-path
    copy-to cursor-call-path, src
  }
  # first line
  var first-line-ah/eax: (addr handle line) <- get sandbox, data
  var _first-line/eax: (addr line) <- lookup *first-line-ah
  var first-line/edx: (addr line) <- copy _first-line
  # final line
  var final-line-storage: (handle line)
  var final-line-ah/eax: (addr handle line) <- address final-line-storage
  final-line sandbox, final-line-ah
  var final-line/eax: (addr line) <- lookup *final-line-ah
  # curr-path
  var curr-path-storage: (handle call-path-element)
  var curr-path/ecx: (addr handle call-path-element) <- address curr-path-storage
  allocate curr-path  # leak
  initialize-path-from-line final-line, curr-path
  #
  var dummy/ecx: int <- render-line screen, functions, bindings, first-line, final-line, expanded-words, top-row, left-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr
}

fn final-line _sandbox: (addr sandbox), out: (addr handle line) {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var curr-line-ah/ecx: (addr handle line) <- get sandbox, data
  {
    var curr-line/eax: (addr line) <- lookup *curr-line-ah
    var next-line-ah/edx: (addr handle line) <- get curr-line, next
    var next-line/eax: (addr line) <- lookup *next-line-ah
    compare next-line, 0
    break-if-=
    curr-line-ah <- copy next-line-ah
    loop
  }
  copy-object curr-line-ah, out
}

fn render-rename-dialog screen: (addr screen), _sandbox: (addr sandbox) {
  var sandbox/edi: (addr sandbox) <- copy _sandbox
  var rename-word-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-cursor-word
  var rename-word-mode?/eax: (addr word) <- lookup *rename-word-mode-ah?
  compare rename-word-mode?, 0/false
  break-if-=
  # clear a space for the dialog
  var cursor-row/ebx: (addr int) <- get sandbox, cursor-row
  var top-row/eax: int <- copy *cursor-row
  top-row <- subtract 3
  var bottom-row/ecx: int <- copy *cursor-row
  bottom-row <- add 3
  var cursor-col/ebx: (addr int) <- get sandbox, cursor-col
  var left-col/edx: int <- copy *cursor-col
  left-col <- subtract 0x10
  var right-col/ebx: int <- copy *cursor-col
  right-col <- add 0x10
  clear-rect screen, top-row, left-col, bottom-row, right-col
  draw-box screen, top-row, left-col, bottom-row, right-col
  # render a little menu for the dialog
  var menu-row/ecx: int <- copy bottom-row
  menu-row <- decrement
  var menu-col/edx: int <- copy left-col
  menu-col <- add 2
  move-cursor screen, menu-row, menu-col
  start-reverse-video screen
  print-string screen, " esc "
  reset-formatting screen
  print-string screen, " cancel  "
  start-reverse-video screen
  print-string screen, " enter "
  reset-formatting screen
  print-string screen, " rename  "
  # draw the word, positioned appropriately around the cursor
  var cursor-col/ebx: (addr int) <- get sandbox, cursor-col
  var start-col/ecx: int <- copy *cursor-col
  var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-cursor-word
  var word/eax: (addr word) <- lookup *word-ah?
  var cursor-index/eax: int <- cursor-index word
  start-col <- subtract cursor-index
  var cursor-row/ebx: (addr int) <- get sandbox, cursor-row
  move-cursor screen, *cursor-row, start-col
  var word/eax: (addr word) <- lookup *word-ah?
  print-word screen, word
}

fn render-define-dialog screen: (addr screen), _sandbox: (addr sandbox) {
  var sandbox/edi: (addr sandbox) <- copy _sandbox
  var define-function-mode-ah?/ecx: (addr handle word) <- get sandbox, partial-name-for-function
  var define-function-mode?/eax: (addr word) <- lookup *define-function-mode-ah?
  compare define-function-mode?, 0/false
  break-if-=
  # clear a space for the dialog
  var cursor-row/ebx: (addr int) <- get sandbox, cursor-row
  var top-row/eax: int <- copy *cursor-row
  top-row <- subtract 3
  var bottom-row/ecx: int <- copy *cursor-row
  bottom-row <- add 3
  var cursor-col/ebx: (addr int) <- get sandbox, cursor-col
  var left-col/edx: int <- copy *cursor-col
  left-col <- subtract 0x10
  var right-col/ebx: int <- copy *cursor-col
  right-col <- add 0x10
  clear-rect screen, top-row, left-col, bottom-row, right-col
  draw-box screen, top-row, left-col, bottom-row, right-col
  # render a little menu for the dialog
  var menu-row/ecx: int <- copy bottom-row
  menu-row <- decrement
  var menu-col/edx: int <- copy left-col
  menu-col <- add 2
  move-cursor screen, menu-row, menu-col
  start-reverse-video screen
  print-string screen, " esc "
  reset-formatting screen
  print-string screen, " cancel  "
  start-reverse-video screen
  print-string screen, " enter "
  reset-formatting screen
  print-string screen, " define  "
  # draw the word, positioned appropriately around the cursor
  var cursor-col/ebx: (addr int) <- get sandbox, cursor-col
  var start-col/ecx: int <- copy *cursor-col
  var word-ah?/edx: (addr handle word) <- get sandbox, partial-name-for-function
  var word/eax: (addr word) <- lookup *word-ah?
  var cursor-index/eax: int <- cursor-index word
  start-col <- subtract cursor-index
  var cursor-row/ebx: (addr int) <- get sandbox, cursor-row
  move-cursor screen, *cursor-row, start-col
  var word/eax: (addr word) <- lookup *word-ah?
  print-word screen, word
}

# Render just the words in 'line'.
fn render-line-without-stack screen: (addr screen), _line: (addr line), curr-row: int, left-col: int, cursor-word: (addr word), cursor-row-addr: (addr int), cursor-col-addr: (addr int) {
  # curr-word
  var line/eax: (addr line) <- copy _line
  var first-word-ah/eax: (addr handle word) <- get line, data
  var _curr-word/eax: (addr word) <- lookup *first-word-ah
  var curr-word/esi: (addr word) <- copy _curr-word
  #
  # loop-carried dependency
  var curr-col/ecx: int <- copy left-col
  #
  {
    compare curr-word, 0
    break-if-=
#?     print-string 0, "-- word in penultimate lines: "
#?     {
#?       var foo/eax: int <- copy curr-word
#?       print-int32-hex 0, foo
#?     }
#?     print-string 0, "\n"
    var old-col/edx: int <- copy curr-col
    move-cursor screen, curr-row, curr-col
    print-word screen, curr-word
    {
      var max-width/eax: int <- word-length curr-word
      curr-col <- add max-width
      curr-col <- add 1/margin-right
    }
    # cache cursor column if necessary
    {
      compare curr-word, cursor-word
      break-if-!=
#?       print-string 0, "Cursor at "
#?       print-int32-decimal 0, curr-row
#?       print-string 0, ", "
#?       print-int32-decimal 0, old-col
#?       print-string 0, "\n"
#?       print-string 0, "contents: "
#?       print-word 0, cursor-word
#?       print-string 0, "\n"
#?       {
#?         var foo/eax: int <- copy cursor-word
#?         print-int32-hex 0, foo
#?         print-string 0, "\n"
#?       }
      var dest/ecx: (addr int) <- copy cursor-row-addr
      var src/eax: int <- copy curr-row
      copy-to *dest, src
      dest <- copy cursor-col-addr
      copy-to *dest, old-col
      var cursor-index-in-word/eax: int <- cursor-index curr-word
      add-to *dest, cursor-index-in-word
    }
    # loop update
    var next-word-ah/edx: (addr handle word) <- get curr-word, next
    var _curr-word/eax: (addr word) <- lookup *next-word-ah
    curr-word <- copy _curr-word
    loop
  }
}

fn call-depth-at-cursor _sandbox: (addr sandbox) -> _/eax: int {
  var sandbox/esi: (addr sandbox) <- copy _sandbox
  var cursor-call-path/edi: (addr handle call-path-element) <- get sandbox, cursor-call-path
  var result/eax: int <- call-path-element-length cursor-call-path
  result <- add 2  # input-row - 1
  return result
}

fn call-path-element-length _x: (addr handle call-path-element) -> _/eax: int {
  var curr-ah/ecx: (addr handle call-path-element) <- copy _x
  var result/edi: int <- copy 0
  {
    var curr/eax: (addr call-path-element) <- lookup *curr-ah
    compare curr, 0
    break-if-=
    curr-ah <- get curr, next
    result <- increment
    loop
  }
  return result
}

# Render the line of words in line, along with the state of the stack under each word.
# Also render any expanded function calls using recursive calls.
#
# Along the way, compute the column the cursor should be positioned at (cursor-col-addr).
fn render-line screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), _line: (addr line), expanded-words: (addr handle call-path), top-row: int, left-col: int, curr-path: (addr handle call-path-element), cursor-word: (addr word), cursor-call-path: (addr handle call-path-element), cursor-row-addr: (addr int), cursor-col-addr: (addr int) -> _/ecx: int {
#?   print-string 0, "render-line\n"
#?   dump-table bindings
  # curr-word
  var line/esi: (addr line) <- copy _line
  var first-word-ah/eax: (addr handle word) <- get line, data
  var curr-word/eax: (addr word) <- lookup *first-word-ah
  #
  # loop-carried dependency
  var curr-col/ecx: int <- copy left-col
  #
  {
    compare curr-word, 0
    break-if-=
#?     print-string 0, "-- word "
#?     print-word 0, curr-word
#?     print-string 0, "\n"
    # if necessary, first render columns for subsidiary stack
    $render-line:subsidiary: {
      {
#?         print-string 0, "check sub\n"
        var display-subsidiary-stack?/eax: boolean <- find-in-call-paths expanded-words, curr-path
        compare display-subsidiary-stack?, 0/false
        break-if-= $render-line:subsidiary
      }
#?       print-string 0, "render subsidiary stack\n"
      # does function exist?
      var callee/edi: (addr function) <- copy 0
      {
        var callee-h: (handle function)
        var callee-ah/ecx: (addr handle function) <- address callee-h
        callee functions, curr-word, callee-ah
        var _callee/eax: (addr function) <- lookup *callee-ah
        callee <- copy _callee
        compare callee, 0
        break-if-= $render-line:subsidiary
      }
      move-cursor screen, top-row, curr-col
      start-color screen, 8, 7
      print-word screen, curr-word
      {
        var word-len/eax: int <- word-length curr-word
        curr-col <- add word-len
        curr-col <- add 2
        increment top-row
      }
      # obtain stack at call site
      var stack-storage: value-stack
      var stack/edx: (addr value-stack) <- address stack-storage
      initialize-value-stack stack, 0x10
      {
        var prev-word-ah/eax: (addr handle word) <- get curr-word, prev
        var prev-word/eax: (addr word) <- lookup *prev-word-ah
        compare prev-word, 0
        break-if-=
        var bindings2-storage: table
        var bindings2/ebx: (addr table) <- address bindings2-storage
        deep-copy-table bindings, bindings2
        evaluate functions, bindings2, first-line, prev-word, stack
      }
      # construct new bindings
      var callee-bindings-storage: table
      var callee-bindings/esi: (addr table) <- address callee-bindings-storage
      initialize-table callee-bindings, 0x10
      bind-args callee, stack, callee-bindings
      # obtain body
      var callee-body-ah/eax: (addr handle line) <- get callee, body
      var callee-body/eax: (addr line) <- lookup *callee-body-ah
      var callee-body-first-word/edx: (addr handle word) <- get callee-body, data
      # - render subsidiary stack
      push-to-call-path-element curr-path, callee-body-first-word  # leak
#?       print-string 0, "subsidiary {\n"
#?       dump-table callee-bindings
#?       syscall_exit
      curr-col <- render-line screen, functions, callee-bindings, callee-body, callee-body, expanded-words, top-row, curr-col, curr-path, cursor-word, cursor-call-path, cursor-row-addr, cursor-col-addr
#?       print-string 0, "}\n"
      drop-from-call-path-element curr-path
      #
      move-cursor screen, top-row, curr-col
      print-code-point screen, 0x21d7/⇗
      #
      curr-col <- add 2
      decrement top-row
    }
    # render main column
    var old-col/edx: int <- copy curr-col
    var bindings2-storage: table
    var bindings2/ebx: (addr table) <- address bindings2-storage
#?     print-string 0, "deep-copy {\n"
    deep-copy-table bindings, bindings2
#?     print-string 0, "}\n"
#?     print-string 0, "render column {\n"
    curr-col <- render-column screen, functions, bindings2, first-line, line, curr-word, top-row, curr-col
#?     print-string 0, "}\n"
    # cache cursor column if necessary
    $render-line:cache-cursor-column: {
      {
        var found?/eax: boolean <- call-path-element-match? curr-path, cursor-call-path
        compare found?, 0/false
        break-if-= $render-line:cache-cursor-column
      }
      var dest/edi: (addr int) <- copy cursor-row-addr
      {
        var src/eax: int <- copy top-row
        copy-to *dest, src
      }
      dest <- copy cursor-col-addr
      copy-to *dest, old-col
      var cursor-index-in-word/eax: int <- cursor-index curr-word
      add-to *dest, cursor-index-in-word
    }
    # loop update
#?     print-string 0, "next word\n"
    var next-word-ah/edx: (addr handle word) <- get curr-word, next
    curr-word <- lookup *next-word-ah
#?     {
#?       var foo/eax: int <- copy curr-word
#?       print-int32-hex 0, foo
#?       print-string 0, "\n"
#?     }
    increment-final-element curr-path
    loop
  }
  return curr-col
}

fn callee functions: (addr handle function), word: (addr word), out: (addr handle function) {
  var stream-storage: (stream byte 0x10)
  var stream/esi: (addr stream byte) <- address stream-storage
  emit-word word, stream
  find-function functions, stream, out
}

# Render:
#   - starting at top-row, left-col: final-word
#   - starting somewhere below at left-col: the stack result from interpreting first-world to final-word (inclusive)
#
# Return the farthest column written.
fn render-column screen: (addr screen), functions: (addr handle function), bindings: (addr table), first-line: (addr line), line: (addr line), final-word: (addr word), top-row: int, left-col: int -> _/ecx: int {
#?   print-string 0, "render-column\n"
#?   dump-table bindings
  var max-width/esi: int <- copy 0
  {
    # compute stack
    var stack: value-stack
    var stack-addr/edi: (addr value-stack) <- address stack
    initialize-value-stack stack-addr, 0x10/max-words
    # copy bindings
    var bindings2-storage: table
    var bindings2/ebx: (addr table) <- address bindings2-storage
#?     print-string 0, "deep copy table {\n"
    deep-copy-table bindings, bindings2
#?     print-string 0, "}\n"
    evaluate functions, bindings2, first-line, final-word, stack-addr
    # indent stack
    var indented-col/ebx: int <- copy left-col
    indented-col <- add 1/margin-right
    # render stack
    var curr-row/edx: int <- copy top-row
    curr-row <- add 2/stack-margin-top
    {
      var top-addr/ecx: (addr int) <- get stack-addr, top
      compare *top-addr, 0
      break-if-<=
      decrement *top-addr
      var data-ah/eax: (addr handle array value) <- get stack-addr, data
      var data/eax: (addr array value) <- lookup *data-ah
      var top/ecx: int <- copy *top-addr
      var dest-offset/ecx: (offset value) <- compute-offset data, top
      var val/eax: (addr value) <- index data, dest-offset
      render-value-at screen, curr-row, indented-col, val, 1/top-level=true
      {
        var width/eax: int <- value-width val, 1
        compare width, max-width
        break-if-<=
        max-width <- copy width
      }
      var height/eax: int <- value-height val
      curr-row <- add height
      loop
    }
  }

  max-width <- add 2  # spaces on either side of items on the stack

  # render word, initialize result
  reset-formatting screen
  move-cursor screen, top-row, left-col
  print-word screen, final-word
  {
    var width/eax: int <- word-length final-word
    compare width, max-width
    break-if-<=
    max-width <- copy width
  }

  # post-process right-col
  var right-col/ecx: int <- copy left-col
  right-col <- add max-width
  right-col <- add 1/margin-right
#?   print-int32-decimal 0, left-col
#?   print-string 0, " => "
#?   print-int32-decimal 0, right-col
#?   print-string 0, "\n"
  return right-col
}

fn render-function-menu _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var screen-ah/edi: (addr handle screen) <- get env, screen
  var _screen/eax: (addr screen) <- lookup *screen-ah
  var screen/edi: (addr screen) <- copy _screen
  var nrows/eax: (addr int) <- get env, nrows
  move-cursor screen, *nrows, 0
  start-reverse-video screen
  print-string screen, " ctrl-q "
  reset-formatting screen
  print-string screen, " quit     "
  start-reverse-video screen
  print-string screen, " ctrl-a "
  reset-formatting screen
  print-string screen, " ⏮   "
  start-reverse-video screen
  print-string screen, " ctrl-b "
  reset-formatting screen
  print-string screen, " ◀ word  "
  start-reverse-video screen
  print-string screen, " ctrl-f "
  reset-formatting screen
  print-string screen, " word ▶  "
  start-reverse-video screen
  print-string screen, " ctrl-e "
  reset-formatting screen
  print-string screen, " ⏭       "
  start-reverse-video screen
  print-string screen, " ctrl-g "
  reset-formatting screen
  print-string screen, " go to function  "
  start-reverse-video screen
  print-string screen, " tab "
  reset-formatting screen
  print-string screen, " go to sandbox"
}

fn render-sandbox-menu _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var screen-ah/edi: (addr handle screen) <- get env, screen
  var _screen/eax: (addr screen) <- lookup *screen-ah
  var screen/edi: (addr screen) <- copy _screen
  var nrows/eax: (addr int) <- get env, nrows
  move-cursor screen, *nrows, 0
  start-reverse-video screen
  print-string screen, " ctrl-q "
  reset-formatting screen
  print-string screen, " quit     "
  start-reverse-video screen
  print-string screen, " ctrl-a "
  reset-formatting screen
  print-string screen, " ⏮   "
  start-reverse-video screen
  print-string screen, " ctrl-b "
  reset-formatting screen
  print-string screen, " ◀ word  "
  start-reverse-video screen
  print-string screen, " ctrl-f "
  reset-formatting screen
  print-string screen, " word ▶  "
  start-reverse-video screen
  print-string screen, " ctrl-e "
  reset-formatting screen
  print-string screen, " ⏭       "
  start-reverse-video screen
  print-string screen, " ctrl-g "
  reset-formatting screen
  print-string screen, " go to function     "
  start-reverse-video screen
  print-string screen, " ctrl-l "
  reset-formatting screen
  print-string screen, " new line "
  start-reverse-video screen
  print-string screen, " ctrl-u "
  reset-formatting screen
  print-string screen, " clear  "
  start-reverse-video screen
  print-string screen, " ctrl-n "
  reset-formatting screen
  print-string screen, " name word  "
  start-reverse-video screen
  print-string screen, " ctrl-d "
  reset-formatting screen
  print-string screen, " define function"
}

fn clear-canvas _env: (addr environment) {
  var env/esi: (addr environment) <- copy _env
  var screen-ah/edi: (addr handle screen) <- get env, screen
  var _screen/eax: (addr screen) <- lookup *screen-ah
  var screen/edi: (addr screen) <- copy _screen
  clear-screen screen
  var nrows/eax: (addr int) <- get env, nrows
  var sep-col/ecx: (addr int) <- get env, code-separator-col
  # divider
  draw-vertical-line screen, 1, *nrows, *sep-col
  # primitives
  var dummy/eax: int <- render-primitives screen, *nrows, *sep-col
}

# return value: top-most row written to
fn render-primitives screen: (addr screen), bottom-margin-row: int, right-col: int -> _/eax: int {
  # render primitives from the bottom of the screen upward
  var row/ecx: int <- copy bottom-margin-row
  row <- subtract 1
  var col/edx: int <- copy 1
  move-cursor screen, row, col
  row, col <- render-primitive-group screen, row, col, right-col, "numbers: ", "+ - * / sqrt  "
  row, col <- render-primitive-group screen, row, col, right-col, "arrays: ", "len  "
  row, col <- render-primitive-group screen, row, col, right-col, "files: ", "open read slurp lines  "
  row, col <- render-primitive-group screen, row, col, right-col, "misc: ", "dup swap  "  # hack: keep these at the right of the bottom row
  row, col <- render-primitive-group screen, row, col, right-col, "screens: ", "fake-screen print move up down left right  "
  # finally print heading up top
  row <- decrement
  move-cursor screen, row, 1
  start-bold screen
  print-string screen, "primitives:"
  reset-formatting screen
  return row
}

# start at row, col and print the given strings
# move up one row if there isn't enough room before right-col
# return row, col printed until
fn render-primitive-group screen: (addr screen), _row: int, _col: int, right-col: int, _heading: (addr array byte), _contents: (addr array byte) -> _/ecx: int, _/edx: int {
  var row/ecx: int <- copy _row
  var col/edx: int <- copy _col
  # decrement row if necessary
  var new-col/ebx: int <- copy col
  var heading/esi: (addr array byte) <- copy _heading
  var len1/eax: int <- length heading
  new-col <- add len1
  var contents/edi: (addr array byte) <- copy _contents
  var len2/eax: int <- length contents
  new-col <- add len2
  var bound/eax: int <- copy right-col
  bound <- decrement
  {
    compare new-col, bound
    break-if-<=
    row <- decrement
    col <- copy 1
  }
  move-cursor screen, row, col
  start-color screen, 0xf6, 7
  print-string screen, heading
  reset-formatting screen
  print-string screen, contents
  return row, new-col
}

fn render-functions screen: (addr screen), right-col: int, _env: (addr environment) {
  var row/ecx: int <- copy 1
  var dummy-col/edx: int <- copy right-col
  var env/esi: (addr environment) <- copy _env
  var functions/esi: (addr handle function) <- get env, functions
  {
    var curr/eax: (addr function) <- lookup *functions
    compare curr, 0
    break-if-=
    row, dummy-col <- render-function-right-aligned screen, row, right-col, curr
    functions <- get curr, next
    row <- add 1/inter-function-margin
    loop
  }
}

# print function starting at row, right-aligned before right-col
# return row, col printed until
fn render-function-right-aligned screen: (addr screen), row: int, right-col: int, f: (addr function) -> _/ecx: int, _/edx: int {
  var col/edx: int <- copy right-col
  col <- subtract 1/function-right-margin
  var col2/ebx: int <- copy col
  var width/eax: int <- function-width f
  col <- subtract width
  var new-row/ecx: int <- copy row
  var height/eax: int <- function-height f
  new-row <- add height
  new-row <- decrement
  col <- subtract 1/function-left-padding
  start-color screen, 0, 0xf7
  clear-rect screen, row, col, new-row, col2
  col <- add 1
#?   var dummy/eax: grapheme <- read-key-from-real-keyboard
  render-function screen, row, col, f
  new-row <- add 1/function-bottom-margin
  col <- subtract 1/function-left-padding
  col <- subtract 1/function-left-margin
  reset-formatting screen
  return new-row, col
}

# render function starting at row, col
# only single-line functions supported for now
fn render-function screen: (addr screen), row: int, col: int, _f: (addr function) {
  var f/esi: (addr function) <- copy _f
  var args/ecx: (addr handle word) <- get f, args
  move-cursor screen, row, col
  print-words-in-reverse screen, args
  var name-ah/eax: (addr handle array byte) <- get f, name
  var name/eax: (addr array byte) <- lookup *name-ah
  start-bold screen
  print-string screen, name
  reset-formatting screen
  start-color screen, 0, 0xf7
  increment row
  add-to col, 2
  move-cursor screen, row, col
  print-string screen, "≡ "
  add-to col, 2
  var cursor-row/ecx: (addr int) <- get f, cursor-row
  var cursor-col/edx: (addr int) <- get f, cursor-col
  var cursor-word-ah/eax: (addr handle word) <- get f, cursor-word
  var _cursor-word/eax: (addr word) <- lookup *cursor-word-ah
  var cursor-word/ebx: (addr word) <- copy _cursor-word
  var body-ah/eax: (addr handle line) <- get f, body
  var body/eax: (addr line) <- lookup *body-ah
  render-line-without-stack screen, body, row, col, cursor-word, cursor-row, cursor-col
}

fn real-grapheme? g: grapheme -> _/eax: boolean {
  # if g == newline return true
  compare g, 0xa
  {
    break-if-!=
    return 1/true
  }
  # if g == tab return true
  compare g, 9
  {
    break-if-!=
    return 1/true
  }
  # if g < 32 return false
  compare g, 0x20
  {
    break-if->=
    return 0/false
  }
  # if g <= 255 return true
  compare g, 0xff
  {
    break-if->
    return 1/true
  }
  # if (g&0xff == Esc) it's an escape sequence
  and-with g, 0xff
  compare g, 0x1b/esc
  {
    break-if-!=
    return 0/false
  }
  # otherwise return true
  return 1/true
}