type environment {
search-terms: (handle gap-buffer)
tabs: (handle array tab)
current-tab-index: int # index into tabs
dirty?: boolean
# search mode
cursor-in-search?: boolean
# channel mode
cursor-in-channels?: boolean
channel-cursor-index: int
}
type tab {
type: int
# type 0: all items
# type 1: items in a channel
# type 2: search for a term
# type 3: comments in a single thread
item-index: int # what item in the corresponding list we start rendering
# the current page at
# only for type 0, 1
hidden-items: (handle stream int)
# only for type 1
channel-index: int
# only for type 2
search-terms: (handle gap-buffer)
search-items: (handle array int)
search-items-first-free: int
# only for type 3
root-index: int
}
# static buffer sizes in this file:
# main-panel-hor # in characters
# item-padding-hor # in pixels
# item-padding-ver # in characters
# avatar-side # in pixels
# avatar-space-hor # in characters
# avatar-space-ver # in characters
# search-position-x # in characters
# search-space-ver # in characters
# author-name-padding-ver # in characters
# post-right-coord # in characters
# channel-offset-x # in characters
# menu-space-ver # in characters
# max-search-results
fn initialize-environment _self: (addr environment), _items: (addr item-list) {
var self/esi: (addr environment) <- copy _self
var search-terms-ah/eax: (addr handle gap-buffer) <- get self, search-terms
allocate search-terms-ah
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
initialize-gap-buffer search-terms, 0x30/search-capacity
var items/eax: (addr item-list) <- copy _items
var items-data-first-free-a/eax: (addr int) <- get items, data-first-free
var final-item/edx: int <- copy *items-data-first-free-a
final-item <- decrement
var tabs-ah/ecx: (addr handle array tab) <- get self, tabs
populate tabs-ah, 0x10/max-history
# current-tab-index implicitly set to 0
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var first-tab/eax: (addr tab) <- index tabs, 0/current-tab-index
var dest/edi: (addr int) <- get first-tab, item-index
copy-to *dest, final-item
}
### Render
fn render-environment screen: (addr screen), _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/esi: (addr environment) <- copy _env
{
var dirty?/eax: (addr boolean) <- get env, dirty?
compare *dirty?, 0/false
break-if-!=
# minimize repaints when typing into the search bar
{
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
compare *cursor-in-search?, 0/false
break-if-=
render-search-input screen, env
clear-rect screen, 0/x 0x2f/y, 0x80/x 0x30/y, 0/bg
render-search-menu screen, env
return
}
# minimize repaints when focus in channel nav
{
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
compare *cursor-in-channels?, 0/false
break-if-=
render-channels screen, env, channels
clear-rect screen, 0/x 0x2f/y, 0x80/x 0x30/y, 0/bg
render-channels-menu screen, env
return
}
}
# full repaint
clear-screen screen
render-search-input screen, env
render-channels screen, env, channels
render-item-list screen, env, users, channels, items
render-menu screen, env
var dirty?/eax: (addr boolean) <- get env, dirty?
copy-to *dirty?, 0/false
}
fn render-channels screen: (addr screen), _env: (addr environment), _channels: (addr array channel) {
var env/esi: (addr environment) <- copy _env
var cursor-index/edi: int <- copy -1
{
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
compare *cursor-in-search?, 0/false
break-if-!=
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
compare *cursor-in-channels?, 0/false
break-if-=
var cursor-index-addr/eax: (addr int) <- get env, channel-cursor-index
cursor-index <- copy *cursor-index-addr
}
var channels/esi: (addr array channel) <- copy _channels
var y/ebx: int <- copy 2/search-space-ver
y <- add 1/item-padding-ver
var i/ecx: int <- copy 0
var max/edx: int <- length channels
{
compare i, max
break-if->=
var offset/eax: (offset channel) <- compute-offset channels, i
var curr/eax: (addr channel) <- index channels, offset
var name-ah/eax: (addr handle array byte) <- get curr, name
var name/eax: (addr array byte) <- lookup *name-ah
compare name, 0
break-if-=
set-cursor-position screen, 2/x y
{
compare cursor-index, i
break-if-=
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 7/grey 0/black
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, name, 7/grey 0/black
}
{
compare cursor-index, i
break-if-!=
# cursor; reverse video
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 0/black 0xf/white
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, name, 0/black 0xf/white
}
y <- add 2/channel-padding
i <- increment
loop
}
}
fn render-item-list screen: (addr screen), _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/esi: (addr environment) <- copy _env
var tmp-width/eax: int <- copy 0
var tmp-height/ecx: int <- copy 0
tmp-width, tmp-height <- screen-size screen
var screen-width: int
copy-to screen-width, tmp-width
var screen-height: int
copy-to screen-height, tmp-height
#
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
var tabs/edx: (addr array tab) <- copy _tabs
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
var current-tab-index/eax: int <- copy *current-tab-index-a
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
var show-cursor?: boolean
{
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
compare *cursor-in-search?, 0/false
break-if-!=
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
compare *cursor-in-channels?, 0/false
break-if-!=
copy-to show-cursor?, 1/true
}
render-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
var top/eax: int <- copy screen-height
top <- subtract 2/menu-space-ver
clear-rect screen, 0 top, screen-width screen-height, 0/bg
}
fn render-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), items: (addr item-list), screen-height: int {
var current-tab/esi: (addr tab) <- copy _current-tab
var current-tab-type/eax: (addr int) <- get current-tab, type
compare *current-tab-type, 0/all-items
{
break-if-!=
render-all-items screen, current-tab, show-cursor?, items, users, screen-height
return
}
compare *current-tab-type, 1/channel
{
break-if-!=
render-channel-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
return
}
compare *current-tab-type, 2/search
{
break-if-!=
render-search-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
return
}
compare *current-tab-type, 3/thread
{
break-if-!=
render-thread-tab screen, current-tab, show-cursor?, users, channels, items, screen-height
return
}
}
fn render-all-items screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, _items: (addr item-list), users: (addr array user), screen-height: int {
var current-tab/esi: (addr tab) <- copy _current-tab
var items/edi: (addr item-list) <- copy _items
var newest-item/eax: (addr int) <- get current-tab, item-index
var i/ebx: int <- copy *newest-item
var items-data-first-free-addr/eax: (addr int) <- get items, data-first-free
render-progress screen, i, *items-data-first-free-addr
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/edi: (addr array item) <- copy _items-data
var y/ecx: int <- copy 2/search-space-ver
y <- add 1/item-padding-ver
$render-all-items:loop: {
compare i, 0
break-if-<
{
var hide?/eax: boolean <- should-hide? current-tab, i, _items
compare hide?, 0/false
break-if-=
i <- decrement
loop $render-all-items:loop
}
compare y, screen-height
break-if->=
var offset/eax: (offset item) <- compute-offset items-data, i
var curr-item/eax: (addr item) <- index items-data, offset
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
# cursor always at top item
copy-to show-cursor?, 0/false
i <- decrement
loop
}
}
fn render-channel-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), _channels: (addr array channel), _items: (addr item-list), screen-height: int {
var current-tab/esi: (addr tab) <- copy _current-tab
var items/edi: (addr item-list) <- copy _items
var channels/ebx: (addr array channel) <- copy _channels
var channel-index-addr/eax: (addr int) <- get current-tab, channel-index
var channel-index/eax: int <- copy *channel-index-addr
var channel-offset/eax: (offset channel) <- compute-offset channels, channel-index
var current-channel/ecx: (addr channel) <- index channels, channel-offset
var current-channel-posts-ah/eax: (addr handle array int) <- get current-channel, posts
var _current-channel-posts/eax: (addr array int) <- lookup *current-channel-posts-ah
var current-channel-posts/edx: (addr array int) <- copy _current-channel-posts
var current-channel-first-channel-item-addr/eax: (addr int) <- get current-tab, item-index
var i/ebx: int <- copy *current-channel-first-channel-item-addr
var current-channel-posts-first-free-addr/eax: (addr int) <- get current-channel, posts-first-free
set-cursor-position 0/screen, 0x68/x 0/y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "channel", 7/fg 0/bg
render-progress screen, i, *current-channel-posts-first-free-addr
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/edi: (addr array item) <- copy _items-data
var y/ecx: int <- copy 2/search-space-ver
y <- add 1/item-padding-ver
{
compare i, 0
break-if-<
compare y, screen-height
break-if->=
var item-index-addr/eax: (addr int) <- index current-channel-posts, i
var item-index/eax: int <- copy *item-index-addr
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
var curr-item/eax: (addr item) <- index items-data, item-offset
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
# cursor always at top item
copy-to show-cursor?, 0/false
i <- decrement
loop
}
}
fn render-search-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), _items: (addr item-list), screen-height: int {
var current-tab/esi: (addr tab) <- copy _current-tab
var items/edi: (addr item-list) <- copy _items
var current-tab-search-items-ah/eax: (addr handle array int) <- get current-tab, search-items
var _current-tab-search-items/eax: (addr array int) <- lookup *current-tab-search-items-ah
var current-tab-search-items/ebx: (addr array int) <- copy _current-tab-search-items
var current-tab-top-item-addr/eax: (addr int) <- get current-tab, item-index
var i/edx: int <- copy *current-tab-top-item-addr
var current-tab-search-items-first-free-addr/eax: (addr int) <- get current-tab, search-items-first-free
set-cursor-position 0/screen, 0x68/x 0/y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "search", 7/fg 0/bg
render-progress screen, i, *current-tab-search-items-first-free-addr
{
compare *current-tab-search-items-first-free-addr, 0x100/max-search-results
break-if-<
set-cursor-position 0/screen, 0x68/x 1/y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "too many results", 4/fg 0/bg
}
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/edi: (addr array item) <- copy _items-data
var y/ecx: int <- copy 2/search-space-ver
y <- add 1/item-padding-ver
{
compare i, 0
break-if-<
compare y, screen-height
break-if->=
var item-index-addr/eax: (addr int) <- index current-tab-search-items, i
var item-index/eax: int <- copy *item-index-addr
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
var curr-item/eax: (addr item) <- index items-data, item-offset
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
# cursor always at top item
copy-to show-cursor?, 0/false
i <- decrement
loop
}
}
fn render-thread-tab screen: (addr screen), _current-tab: (addr tab), show-cursor?: boolean, users: (addr array user), channels: (addr array channel), _items: (addr item-list), screen-height: int {
var current-tab/esi: (addr tab) <- copy _current-tab
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/edi: (addr array item) <- copy _items-data
var post-index-addr/eax: (addr int) <- get current-tab, root-index
var post-index/eax: int <- copy *post-index-addr
var post-offset/eax: (offset item) <- compute-offset items-data, post-index
var post/ebx: (addr item) <- index items-data, post-offset
var current-tab-top-item-addr/eax: (addr int) <- get current-tab, item-index
var i/edx: int <- copy *current-tab-top-item-addr
var post-comments-first-free-addr/eax: (addr int) <- get post, comments-first-free
set-cursor-position 0/screen, 0x68/x 0/y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "thread", 7/fg 0/bg
render-progress screen, i, *post-comments-first-free-addr
var post-comments-ah/eax: (addr handle array int) <- get post, comments
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
var y/ecx: int <- copy 2/search-space-ver
y <- add 1/item-padding-ver
{
compare i, 0
break-if-<
compare y, screen-height
break-if->=
var item-index-addr/eax: (addr int) <- index post-comments, i
var item-index/eax: int <- copy *item-index-addr
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
var curr-item/eax: (addr item) <- index items-data, item-offset
y <- render-item screen, curr-item, users, show-cursor?, y, screen-height
# cursor always at top item
copy-to show-cursor?, 0/false
i <- decrement
loop
}
# finally render the parent -- though we'll never focus on it
y <- render-item screen, post, users, 0/no-cursor, y, screen-height
}
# side-effect: mutates cursor position
fn render-progress screen: (addr screen), curr: int, max: int {
set-cursor-position 0/screen, 0x70/x 0/y
var top-index/eax: int <- copy max
top-index <- subtract curr # happy accident: 1-based
draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen, top-index, 7/fg 0/bg
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "/", 7/fg 0/bg
draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen, max, 7/fg 0/bg
}
fn render-search-input screen: (addr screen), _env: (addr environment) {
var env/esi: (addr environment) <- copy _env
var cursor-in-search?/ecx: (addr boolean) <- get env, cursor-in-search?
set-cursor-position 0/screen, 0x22/x=search-position-x 1/y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "search ", 7/fg 0/bg
var search-terms-ah/eax: (addr handle gap-buffer) <- get env, search-terms
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
rewind-gap-buffer search-terms
var x/eax: int <- render-gap-buffer screen, search-terms, 0x2a/x 1/y, *cursor-in-search?, 0xf/fg 0/bg
{
compare x, 0x4a/end-search
break-if->
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x5f/underscore, 0/xmin 1/ymin, 0x80/xmax, 1/ymax, x, 1/y, 0xf/fg 0/bg
loop
}
}
# not used in search mode
fn render-menu screen: (addr screen), _env: (addr environment) {
var env/edi: (addr environment) <- copy _env
{
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
compare *cursor-in-search?, 0/false
break-if-=
render-search-menu screen, env
return
}
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
compare *cursor-in-channels?, 0/false
{
break-if-=
render-channels-menu screen, env
return
}
render-main-menu screen, env
}
fn render-main-menu screen: (addr screen), _env: (addr environment) {
var width/eax: int <- copy 0
var y/ecx: int <- copy 0
width, y <- screen-size screen
y <- decrement
set-cursor-position screen, 2/x, y
{
var env/edi: (addr environment) <- copy _env
var num-tabs/edi: (addr int) <- get env, current-tab-index
compare *num-tabs, 0
break-if-<=
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " go back ", width, 0xf/fg, 0/bg
}
draw-text-rightward-from-cursor screen, " / ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " search ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " Tab ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " go to channels ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " go to thread ", width, 0xf/fg, 0/bg
{
{
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? _env
compare is-all-items-or-channel?, 0/false
}
break-if-=
draw-text-rightward-from-cursor screen, " ^h ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " hide thread ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^u ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " unhide all ", width, 0xf/fg, 0/bg
}
draw-text-rightward-from-cursor screen, " ^b ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " << page ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^f ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " page >> ", width, 0xf/fg, 0/bg
}
fn render-channels-menu screen: (addr screen), _env: (addr environment) {
var width/eax: int <- copy 0
var y/ecx: int <- copy 0
width, y <- screen-size screen
y <- decrement
set-cursor-position screen, 2/x, y
{
var env/edi: (addr environment) <- copy _env
var num-tabs/edi: (addr int) <- get env, current-tab-index
compare *num-tabs, 0
break-if-<=
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " go back ", width, 0xf/fg, 0/bg
}
draw-text-rightward-from-cursor screen, " / ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " search ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " Tab ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " go to items ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " select ", width, 0xf/fg, 0/bg
}
fn render-search-menu screen: (addr screen), _env: (addr environment) {
var width/eax: int <- copy 0
var y/ecx: int <- copy 0
width, y <- screen-size screen
y <- decrement
set-cursor-position screen, 2/x, y
draw-text-rightward-from-cursor screen, " Esc ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " cancel ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " Enter ", width, 0/fg 0xf/bg
draw-text-rightward-from-cursor screen, " select ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^a ", width, 0/fg, 0xf/bg
draw-text-rightward-from-cursor screen, " << ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^b ", width, 0/fg, 0xf/bg
draw-text-rightward-from-cursor screen, " <word ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^f ", width, 0/fg, 0xf/bg
draw-text-rightward-from-cursor screen, " word> ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^e ", width, 0/fg, 0xf/bg
draw-text-rightward-from-cursor screen, " >> ", width, 0xf/fg, 0/bg
draw-text-rightward-from-cursor screen, " ^u ", width, 0/fg, 0xf/bg
draw-text-rightward-from-cursor screen, " clear ", width, 0xf/fg, 0/bg
}
fn render-item screen: (addr screen), _item: (addr item), _users: (addr array user), show-cursor?: boolean, y: int, screen-height: int -> _/ecx: int {
var item/esi: (addr item) <- copy _item
var users/edi: (addr array user) <- copy _users
var author-index-addr/ecx: (addr int) <- get item, by
var author-index/ecx: int <- copy *author-index-addr
var author-offset/ecx: (offset user) <- compute-offset users, author-index
var author/ecx: (addr user) <- index users, author-offset
# author avatar
var author-avatar-ah/eax: (addr handle image) <- get author, avatar
var _author-avatar/eax: (addr image) <- lookup *author-avatar-ah
var author-avatar/ebx: (addr image) <- copy _author-avatar
{
compare author-avatar, 0
break-if-=
var y/edx: int <- copy y
y <- shift-left 4/log2font-height
var x/eax: int <- copy 0x20/main-panel-hor
x <- shift-left 3/log2font-width
x <- add 0x18/item-padding-hor
render-image screen, author-avatar, x, y, 0x50/avatar-side, 0x50/avatar-side
}
# channel
var channel-name-ah/eax: (addr handle array byte) <- get item, channel
var channel-name/eax: (addr array byte) <- lookup *channel-name-ah
{
var x/eax: int <- copy 0x20/main-panel-hor
x <- add 0x40/channel-offset-x
set-cursor-position screen, x y
}
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "#", 7/grey 0/black
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, channel-name, 7/grey 0/black
# author name
{
var author-real-name-ah/eax: (addr handle array byte) <- get author, real-name
var author-real-name/eax: (addr array byte) <- lookup *author-real-name-ah
var x/ecx: int <- copy 0x20/main-panel-hor
x <- add 0x10/avatar-space-hor
set-cursor-position screen, x y
draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, author-real-name, 0xf/white 0/black
}
increment y
# text
var text-ah/eax: (addr handle array byte) <- get item, text
var _text/eax: (addr array byte) <- lookup *text-ah
var text/edx: (addr array byte) <- copy _text
var text-y/eax: int <- render-slack-message screen, text, show-cursor?, y, screen-height
# flush
add-to y, 6/avatar-space-ver
compare y, text-y
{
break-if-<
return y
}
return text-y
}
fn render-slack-message screen: (addr screen), text: (addr array byte), highlight?: boolean, ymin: int, ymax: int -> _/eax: int {
var x/eax: int <- copy 0x20/main-panel-hor
x <- add 0x10/avatar-space-hor
var y/ecx: int <- copy ymin
y <- add 1/author-name-padding-ver
$render-slack-message:draw: {
compare highlight?, 0/false
{
break-if-=
x, y <- draw-json-text-wrapping-right-then-down screen, text, x y, 0x70/xmax=post-right-coord ymax, x y, 0/fg 7/bg
break $render-slack-message:draw
}
x, y <- draw-json-text-wrapping-right-then-down screen, text, x y, 0x70/xmax=post-right-coord ymax, x y, 7/fg 0/bg
}
y <- add 2/item-padding-ver
return y
}
# draw text in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
# return the next (x, y) coordinate in raster order where drawing stopped
# that way the caller can draw more if given the same min and max bounding-box.
# if there isn't enough space, truncate
fn draw-json-text-wrapping-right-then-down screen: (addr screen), _text: (addr array byte), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
var stream-storage: (stream byte 0x4000/print-buffer-size)
var stream/edi: (addr stream byte) <- address stream-storage
var text/esi: (addr array byte) <- copy _text
var len/eax: int <- length text
compare len, 0x4000/print-buffer-size
{
break-if-<
write stream, "ERROR: stream too small in draw-text-wrapping-right-then-down"
}
compare len, 0x4000/print-buffer-size
{
break-if->=
write stream, text
}
var x/eax: int <- copy _x
var y/ecx: int <- copy _y
x, y <- draw-json-stream-wrapping-right-then-down screen, stream, xmin, ymin, xmax, ymax, x, y, color, background-color
return x, y
}
# draw a stream in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
# return the next (x, y) coordinate in raster order where drawing stopped
# that way the caller can draw more if given the same min and max bounding-box.
# if there isn't enough space, truncate
fn draw-json-stream-wrapping-right-then-down screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
var xcurr/ecx: int <- copy x
var ycurr/edx: int <- copy y
var c/ebx: code-point <- copy 0
var next-c/esi: code-point <- copy 0
{
# read c from either next-c or stream
$draw-json-stream-wrapping-right-then-down:read-base: {
compare next-c, 0
{
break-if-=
c <- copy next-c
next-c <- copy 0
break $draw-json-stream-wrapping-right-then-down:read-base
}
c <- read-json-code-point stream
}
compare c, 0xffffffff/end-of-file
break-if-=
$draw-json-stream-wrapping-right-then-down:render-code-point-utf8: {
compare c, 0x5c/backslash
{
break-if-!=
xcurr, ycurr <- render-json-escaped-code-point screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
}
compare c, 0xa/newline
{
break-if-!=
# minimum effort to clear cursor
var dummy/eax: int <- draw-code-point screen, 0x20/space, xcurr, ycurr, color, background-color
xcurr <- copy xmin
ycurr <- increment
break $draw-json-stream-wrapping-right-then-down:render-code-point-utf8
}
var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
# overlay a combining character if necessary
$draw-json-stream-wrapping-right-then-down:read-combiner: {
var done?/eax: boolean <- stream-empty? stream
compare done?, 0/false
break-if-!=
# read a character
# no combining character allowed here
var g/eax: code-point-utf8 <- read-code-point-utf8 stream
var c/eax: code-point <- to-code-point g
# if not a combining character, save for next iteration and loop
{
var combining-code-point?/eax: boolean <- combining-code-point? c
compare combining-code-point?, 0/false
}
{
break-if-!=
next-c <- copy c
break $draw-json-stream-wrapping-right-then-down:read-combiner
}
# otherwise overlay it without saving its width
# This means strange results if a base and its combiner have different
# widths. We'll always follow the base width.
var dummy/eax: int <- overlay-code-point screen, c, xcurr, ycurr, color, background-color
}
xcurr <- add offset
compare xcurr, xmax
{
break-if-<
xcurr <- copy xmin
ycurr <- increment
}
}
loop
}
set-cursor-position screen, xcurr, ycurr
return xcurr, ycurr
}
# just return a different register
fn read-json-code-point stream: (addr stream byte) -> _/ebx: code-point {
var g/eax: code-point-utf8 <- read-code-point-utf8 stream
var result/eax: code-point <- to-code-point g
return result
}
# '\' encountered
# https://www.json.org/json-en.html
fn render-json-escaped-code-point screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, xcurr: int, ycurr: int, color: int, background-color: int -> _/ecx: int, _/edx: int {
var g/ebx: code-point <- read-json-code-point stream
compare g, 0xffffffff/end-of-file
{
break-if-!=
return xcurr, ycurr
}
# \n = newline
compare g, 0x6e/n
var x/eax: int <- copy xcurr
{
break-if-!=
increment ycurr
return xmin, ycurr
}
# ignore \t \r \f \b
{
compare g, 0x74/t
break-if-!=
return xcurr, ycurr
}
{
compare g, 0x72/r
break-if-!=
return xcurr, ycurr
}
{
compare g, 0x66/f
break-if-!=
return xcurr, ycurr
}
{
compare g, 0x62/b
break-if-!=
return xcurr, ycurr
}
var y/ecx: int <- copy 0
# \u = Unicode
{
compare g, 0x75/u
break-if-!=
x, y <- render-json-escaped-unicode-code-point screen, stream, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
var y/edx: int <- copy y
return x, y
}
# most characters escape to themselves
# combining characters not supported after backslash
x, y <- render-code-point screen, g, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
var y/edx: int <- copy y
return x, y
}
# '\u' encountered
fn render-json-escaped-unicode-code-point screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, xcurr: int, ycurr: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
var hex-digits-storage: (array byte 4)
var hex-digits/esi: (addr array byte) <- address hex-digits-storage
# slurp 4 bytes exactly
var src/eax: byte <- read-byte stream
var dest/ecx: (addr byte) <- index hex-digits, 0
copy-byte-to *dest, src
src <- read-byte stream
dest <- index hex-digits, 1
copy-byte-to *dest, src
src <- read-byte stream
dest <- index hex-digits, 2
copy-byte-to *dest, src
src <- read-byte stream
dest <- index hex-digits, 3
copy-byte-to *dest, src
# \u2013 = -
{
var endash?/eax: boolean <- string-equal? hex-digits, "2013"
compare endash?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u2014 = -
{
var emdash?/eax: boolean <- string-equal? hex-digits, "2014"
compare emdash?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x2d/dash, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u2018 = '
{
var left-quote?/eax: boolean <- string-equal? hex-digits, "2018"
compare left-quote?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u2019 = '
{
var right-quote?/eax: boolean <- string-equal? hex-digits, "2019"
compare right-quote?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x27/quote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u201c = "
{
var left-dquote?/eax: boolean <- string-equal? hex-digits, "201c"
compare left-dquote?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u201d = "
{
var right-dquote?/eax: boolean <- string-equal? hex-digits, "201d"
compare right-dquote?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x22/dquote, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u2022 = *
{
var bullet?/eax: boolean <- string-equal? hex-digits, "2022"
compare bullet?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, 0x2a/asterisk, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
# \u2026 = ...
{
var ellipses?/eax: boolean <- string-equal? hex-digits, "2026"
compare ellipses?, 0/false
break-if-=
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- draw-text-wrapping-right-then-down screen, "...", xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
var n/eax: int <- parse-hex-int hex-digits
var c/edx: code-point <- copy n
var x/eax: int <- copy 0
var y/ecx: int <- copy 0
x, y <- render-code-point screen, c, xmin, ymin, xmax, ymax, xcurr, ycurr, color, background-color
return x, y
}
### Edit
fn update-environment _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
# first dispatch to search mode if necessary
{
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
compare *cursor-in-search?, 0/false
break-if-=
update-search env, key, users, channels, items
return
}
{
compare key, 0x2f/slash
break-if-!=
# enter search mode
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
copy-to *cursor-in-search?, 1/true
# do one more repaint
var dirty?/eax: (addr boolean) <- get env, dirty?
copy-to *dirty?, 1/true
return
}
{
compare key, 0x1b/esc
break-if-!=
# back in history
previous-tab env
return
}
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
{
compare key, 9/tab
break-if-!=
# toggle cursor between main panel and channels nav
not *cursor-in-channels? # bitwise NOT; only works if you never assign 1/true to this variable
# do one more repaint
var dirty?/eax: (addr boolean) <- get env, dirty?
copy-to *dirty?, 1/true
return
}
{
compare *cursor-in-channels?, 0/false
break-if-!=
update-main-panel env, key, users, channels, items
return
}
{
compare *cursor-in-channels?, 0/false
break-if-=
update-channels-nav env, key, users, channels, items
return
}
}
fn update-main-panel env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
{
compare key, 0xa/newline
break-if-!=
new-thread-tab-from-cursor env, users, channels, items
return
}
{
compare key, 8/ctrl-h
break-if-!=
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? env
compare is-all-items-or-channel?, 0/false
break-if-=
hide-thread env, users, channels, items
return
}
{
compare key, 0x15/ctrl-u
break-if-!=
var is-all-items-or-channel?/eax: boolean <- current-tab-is-all-items-or-channel? env
compare is-all-items-or-channel?, 0/false
break-if-=
new-all-items-tab env, users, channels, items
return
}
{
compare key, 0x81/down-arrow
break-if-!=
next-item env, users, channels, items
return
}
{
compare key, 0x82/up-arrow
break-if-!=
previous-item env, users, channels, items
return
}
{
compare key, 6/ctrl-f
break-if-!=
page-down env, users, channels, items
return
}
{
compare key, 2/ctrl-b
break-if-!=
page-up env, users, channels, items
return
}
}
fn current-tab-is-all-items-or-channel? _env: (addr environment) -> _/eax: boolean {
var env/esi: (addr environment) <- copy _env
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
var tabs/edx: (addr array tab) <- copy _tabs
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
var current-tab-index/eax: int <- copy *current-tab-index-a
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
var current-tab-type/eax: (addr int) <- get current-tab, type
{
compare *current-tab-type, 0/all-items
break-if-!=
return 1/true
}
{
compare *current-tab-type, 1/channel
break-if-!=
return 1/true
}
return 0/false
}
# TODO: clamp cursor within bounds
fn update-channels-nav _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var channel-cursor-index/eax: (addr int) <- get env, channel-cursor-index
{
compare key, 0x81/down-arrow
break-if-!=
increment *channel-cursor-index
return
}
{
compare key, 0x82/up-arrow
break-if-!=
decrement *channel-cursor-index
return
}
{
compare key, 0xa/newline
break-if-!=
new-channel-tab env, *channel-cursor-index, channels
var cursor-in-channels?/eax: (addr boolean) <- get env, cursor-in-channels?
copy-to *cursor-in-channels?, 0/false
return
}
}
fn update-search _env: (addr environment), key: byte, users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var cursor-in-search?/eax: (addr boolean) <- get env, cursor-in-search?
{
compare key 0x1b/esc
break-if-!=
# get out of search mode
copy-to *cursor-in-search?, 0/false
return
}
{
compare key, 0xa/newline
break-if-!=
# perform a search, then get out of search mode
new-search-tab env, items
copy-to *cursor-in-search?, 0/false
return
}
# otherwise delegate
var search-terms-ah/eax: (addr handle gap-buffer) <- get env, search-terms
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
var g/ecx: code-point-utf8 <- copy key
edit-gap-buffer search-terms, g
}
fn new-all-items-tab _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
increment *current-tab-index-addr
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var max-tabs/ebx: int <- length tabs
{
compare *current-tab-index-addr, max-tabs
break-if-<
abort "history overflow; grow max-history (we should probably improve this)"
}
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
clear-object current-tab
var items/eax: (addr item-list) <- copy _items
var items-data-first-free-a/eax: (addr int) <- get items, data-first-free
var final-item/edx: int <- copy *items-data-first-free-a
final-item <- decrement
var dest/edi: (addr int) <- get current-tab, item-index
copy-to *dest, final-item
}
fn new-thread-tab-from-cursor _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var item-index/esi: int <- item-index env, _items, channels
var post-index/ecx: int <- post-index _items, item-index
new-thread-tab env, users, channels, _items, post-index, item-index
}
fn new-thread-tab _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list), _post-index: int, _item-index: int {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
increment *current-tab-index-addr
var current-tab-index/edx: int <- copy *current-tab-index-addr
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var max-tabs/ebx: int <- length tabs
compare current-tab-index, max-tabs
{
compare current-tab-index, max-tabs
break-if-<
abort "history overflow; grow max-history (we should probably improve this)"
}
var current-tab-offset/edi: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/edi: (addr tab) <- index tabs, current-tab-offset
clear-object current-tab
var current-tab-type/eax: (addr int) <- get current-tab, type
copy-to *current-tab, 3/thread
var current-tab-root-index/eax: (addr int) <- get current-tab, root-index
var post-index/ecx: int <- copy _post-index
copy-to *current-tab-root-index, post-index
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var items-data/eax: (addr array item) <- lookup *items-data-ah
var offset/ecx: (offset item) <- compute-offset items-data, post-index
var post/eax: (addr item) <- index items-data, offset
var post-comments-first-free-addr/ecx: (addr int) <- get post, comments-first-free
# terminology:
# post-comment-index = index of a comment in a post's comment array
# comment-index = index of a comment in the global item list
var final-post-comment-index/ecx: int <- copy *post-comments-first-free-addr
final-post-comment-index <- decrement
var post-comments-ah/eax: (addr handle array int) <- get post, comments
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
# look for item-index in post-comments[0..final-post-comment-index]
var curr-post-comment-index/edx: int <- copy final-post-comment-index
{
compare curr-post-comment-index, 0
{
break-if->=
# if we didn't find the current item in a post's comments, it must be
# the parent post itself which isn't in the comment list but hackily
# rendered at the bottom. Just render the whole comment list.
var item-index/eax: int <- copy _item-index
var tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
copy-to *tab-item-index-addr, curr-post-comment-index
return
}
var curr-comment-index/ecx: (addr int) <- index post-comments, curr-post-comment-index
var item-index/eax: int <- copy _item-index
compare *curr-comment-index, item-index
{
break-if-!=
# item-index found
var item-index/eax: int <- copy _item-index
var tab-item-index-addr/edi: (addr int) <- get current-tab, item-index
copy-to *tab-item-index-addr, curr-post-comment-index
return
}
curr-post-comment-index <- decrement
loop
}
abort "new-thread-tab: should never leave previous loop without returning"
}
fn new-thread-tab-from-url _env: (addr environment), _url: (addr array byte), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
var id-storage: (array byte 0x11)
var id/ecx: (addr array byte) <- address id-storage
var url/edx: (addr array byte) <- copy _url
var len/ebx: int <- length url
var idx/eax: int <- copy len
idx <- subtract 0x11/id-length
{
var x/eax: (addr byte) <- index url, idx
var x2/ecx: byte <- copy-byte *x
compare x2, 0x70/p
break-if-=
abort "not p"
}
idx <- increment # skip 'p'
var dest-idx/edi: int <- copy 0
# insert first 10 digits of id
{
compare dest-idx, 0xa/ten
break-if->=
{
var c/eax: (addr byte) <- index url, idx
var c2/eax: byte <- copy-byte *c
var dest/ecx: (addr byte) <- index id, dest-idx
copy-byte-to *dest, c2
}
idx <- increment
dest-idx <- increment
loop
}
# insert a decimal point
{
var dest/ecx: (addr byte) <- index id, dest-idx
var decimal-point/eax: byte <- copy 0x2e
copy-byte-to *dest, decimal-point
dest-idx <- increment
}
# insert remaining digits of id
{
compare dest-idx, 0x11/id-length
break-if->=
{
var c/eax: (addr byte) <- index url, idx
var c2/eax: byte <- copy-byte *c
var dest/ecx: (addr byte) <- index id, dest-idx
copy-byte-to *dest, c2
}
idx <- increment
dest-idx <- increment
loop
}
var post-index/eax: int <- find-item-by-id _items, id
new-thread-tab _env, users, channels, _items, post-index, post-index
}
fn find-item-by-id _items: (addr item-list), id: (addr array byte) -> _/eax: int {
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var items-data/eax: (addr array item) <- lookup *items-data-ah
var i/ecx: int <- copy 0
var len/edx: int <- length items-data
{
compare i, len
break-if->=
var offset/edx: (offset item) <- compute-offset items-data, i
var curr-item/eax: (addr item) <- index items-data, offset
var curr-item-id-ah/eax: (addr handle array byte) <- get curr-item, id
var curr-item-id/eax: (addr array byte) <- lookup *curr-item-id-ah
{
var found?/eax: boolean <- string-equal? curr-item-id, id
compare found?, 0/false
break-if-=
return i
}
i <- increment
loop
}
abort "find-item-by-id: not found"
return -1
}
# hide a thread in a (channel or all-items) tab
fn hide-thread _env: (addr environment), users: (addr array user), channels: (addr array channel), items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/ebx: (addr tab) <- index tabs, current-tab-offset
var current-tab-hidden-items-ah/edx: (addr handle stream int) <- get current-tab, hidden-items
var current-tab-hidden-items/eax: (addr stream int) <- lookup *current-tab-hidden-items-ah
{
compare current-tab-hidden-items, 0
break-if-!=
populate-stream current-tab-hidden-items-ah, 0x10/max-hidden-threads
current-tab-hidden-items <- lookup *current-tab-hidden-items-ah
}
{
var too-many-hidden-items?/eax: boolean <- stream-full? current-tab-hidden-items
compare too-many-hidden-items?, 0/false
break-if-=
abort "too many hidden threads in this tab" # TODO: create a space for flash error messages on screen
return
}
var current-item-index/esi: int <- item-index env, items, channels
var current-post-index-value/ecx: int <- post-index items, current-item-index
# . turn current-post-index into an addr
var current-post-index-storage: int
copy-to current-post-index-storage, current-post-index-value
var current-post-index-addr/ecx: (addr int) <- address current-post-index-storage
#
write-to-stream current-tab-hidden-items, current-post-index-addr
# current-tab's item-index is now on a hidden item
# try to position it on a visible item
var item-index-addr/esi: (addr int) <- get current-tab, item-index
var old-item-index/eax: int <- copy *item-index-addr
next-item env, users, channels, items
compare *item-index-addr, old-item-index
break-if-!=
previous-item env, users, channels, items
}
fn should-hide? _tab: (addr tab), item-index: int, items: (addr item-list) -> _/eax: boolean {
var post-index/ecx: int <- post-index items, item-index
var tab/esi: (addr tab) <- copy _tab
var tab-hidden-items-ah/edx: (addr handle stream int) <- get tab, hidden-items
var tab-hidden-items/eax: (addr stream int) <- lookup *tab-hidden-items-ah
compare tab-hidden-items, 0
{
break-if-!=
# either we haven't hidden anything, or we're in a tab type that doesn't
# support hiding
return 0/false
}
rewind-stream tab-hidden-items
{
{
var done?/eax: boolean <- stream-empty? tab-hidden-items
compare done?, 0/false
}
break-if-!=
var curr-item: int
var curr-item-addr/edx: (addr int) <- address curr-item
read-from-stream tab-hidden-items, curr-item-addr
# if curr-item == post-index, return true
compare curr-item, post-index
{
break-if-!=
return 1/true
}
loop
}
return 0/false
}
# what index in the global items list is the cursor at in the current tab?
fn item-index _env: (addr environment), _items: (addr item-list), _channels: (addr array channel) -> _/esi: int {
var env/eax: (addr environment) <- copy _env
var current-tab-index-addr/esi: (addr int) <- get env, current-tab-index
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var tab-index/esi: int <- copy *current-tab-index-addr
var tab-offset/esi: (offset tab) <- compute-offset tabs, tab-index
var tab/esi: (addr tab) <- index tabs, tab-offset
var tab-type/eax: (addr int) <- get tab, type
{
compare *tab-type, 0/all-items
break-if-!=
var tab-item-index/eax: (addr int) <- get tab, item-index
return *tab-item-index
}
{
compare *tab-type, 1/channel
break-if-!=
var channel-index-addr/eax: (addr int) <- get tab, channel-index
var channel-index/eax: int <- copy *channel-index-addr
var channels/ecx: (addr array channel) <- copy _channels
var channel-offset/eax: (offset channel) <- compute-offset channels, channel-index
var current-channel/eax: (addr channel) <- index channels, channel-offset
var current-channel-posts-ah/eax: (addr handle array int) <- get current-channel, posts
var current-channel-posts/eax: (addr array int) <- lookup *current-channel-posts-ah
var channel-item-index-addr/ecx: (addr int) <- get tab, item-index
var channel-item-index/ecx: int <- copy *channel-item-index-addr
var channel-item-index/eax: (addr int) <- index current-channel-posts, channel-item-index
return *channel-item-index
}
{
compare *tab-type, 2/search
break-if-!=
var tab-search-items-ah/eax: (addr handle array int) <- get tab, search-items
var tab-search-items/eax: (addr array int) <- lookup *tab-search-items-ah
var tab-search-items-index-addr/ecx: (addr int) <- get tab, item-index
var tab-search-items-index/ecx: int <- copy *tab-search-items-index-addr
var src/eax: (addr int) <- index tab-search-items, tab-search-items-index
return *src
}
{
compare *tab-type, 3/thread
break-if-!=
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/edi: (addr array item) <- copy _items-data
var tab-root-index-addr/eax: (addr int) <- get tab, root-index
var tab-root-index/eax: int <- copy *tab-root-index-addr
var tab-root-offset/eax: (offset item) <- compute-offset items-data, tab-root-index
var post/eax: (addr item) <- index items-data, tab-root-offset
var post-comments-ah/eax: (addr handle array int) <- get post, comments
var post-comments/eax: (addr array int) <- lookup *post-comments-ah
var tab-item-index-addr/ecx: (addr int) <- get tab, item-index
var tab-item-index/ecx: int <- copy *tab-item-index-addr
var src/eax: (addr int) <- index post-comments, tab-item-index
return *src
}
abort "item-index: unknown tab type"
return -1
}
# go from a comment item to its parent post
fn post-index _items: (addr item-list), item-index: int -> _/ecx: int {
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var items-data/eax: (addr array item) <- lookup *items-data-ah
var index/ecx: int <- copy item-index
var offset/ecx: (offset item) <- compute-offset items-data, index
var item/eax: (addr item) <- index items-data, offset
var parent/eax: (addr int) <- get item, parent
compare *parent, 0
{
break-if-=
return *parent
}
return item-index
}
fn new-channel-tab _env: (addr environment), channel-index: int, _channels: (addr array channel) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
increment *current-tab-index-addr
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var max-tabs/edx: int <- length tabs
compare current-tab-index, max-tabs
{
compare current-tab-index, max-tabs
break-if-<
abort "history overflow; grow max-history (we should probably improve this)"
}
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
clear-object current-tab
var current-tab-type/eax: (addr int) <- get current-tab, type
copy-to *current-tab, 1/channel
var current-tab-channel-index/eax: (addr int) <- get current-tab, channel-index
var curr-channel-index/edx: int <- copy channel-index
copy-to *current-tab-channel-index, curr-channel-index
var channels/esi: (addr array channel) <- copy _channels
var curr-channel-offset/eax: (offset channel) <- compute-offset channels, curr-channel-index
var curr-channel/eax: (addr channel) <- index channels, curr-channel-offset
var curr-channel-posts-first-free-addr/eax: (addr int) <- get curr-channel, posts-first-free
var curr-channel-final-post-index/eax: int <- copy *curr-channel-posts-first-free-addr
curr-channel-final-post-index <- decrement
var dest/edi: (addr int) <- get current-tab, item-index
copy-to *dest, curr-channel-final-post-index
}
fn new-search-tab _env: (addr environment), items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/eax: (addr int) <- get env, current-tab-index
increment *current-tab-index-addr
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var max-tabs/edx: int <- length tabs
compare current-tab-index, max-tabs
{
compare current-tab-index, max-tabs
break-if-<
abort "history overflow; grow max-history (we should probably improve this)"
}
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
clear-object current-tab
var current-tab-type/eax: (addr int) <- get current-tab, type
copy-to *current-tab, 2/search
var current-tab-search-terms-ah/edx: (addr handle gap-buffer) <- get current-tab, search-terms
allocate current-tab-search-terms-ah
var current-tab-search-terms/eax: (addr gap-buffer) <- lookup *current-tab-search-terms-ah
initialize-gap-buffer current-tab-search-terms, 0x30/search-capacity
var search-terms-ah/ebx: (addr handle gap-buffer) <- get env, search-terms
copy-gap-buffer search-terms-ah, current-tab-search-terms-ah
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
search-items current-tab, items, search-terms
}
fn search-items _tab: (addr tab), _items: (addr item-list), search-terms: (addr gap-buffer) {
var tab/edi: (addr tab) <- copy _tab
var tab-items-first-free-addr/esi: (addr int) <- get tab, search-items-first-free
var tab-items-ah/eax: (addr handle array int) <- get tab, search-items
populate tab-items-ah, 0x100/max-search-results
var _tab-items/eax: (addr array int) <- lookup *tab-items-ah
var tab-items/edi: (addr array int) <- copy _tab-items
# preprocess search-terms
var search-terms-stream-storage: (stream byte 0x100)
var search-terms-stream-addr/ecx: (addr stream byte) <- address search-terms-stream-storage
emit-gap-buffer search-terms, search-terms-stream-addr
var search-terms-text-h: (handle array byte)
var search-terms-text-ah/eax: (addr handle array byte) <- address search-terms-text-h
stream-to-array search-terms-stream-addr, search-terms-text-ah
var tmp/eax: (addr array byte) <- lookup *search-terms-text-ah
var search-terms-text: (addr array byte)
copy-to search-terms-text, tmp
#
var items/ecx: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/ebx: (addr array item) <- copy _items-data
var items-data-first-free-a/edx: (addr int) <- get items, data-first-free
var i/ecx: int <- copy 0
{
compare i, *items-data-first-free-a
break-if->=
var curr-offset/eax: (offset item) <- compute-offset items-data, i
var curr-item/eax: (addr item) <- index items-data, curr-offset
var found?/eax: boolean <- search-terms-match? curr-item, search-terms-text
compare found?, 0/false
{
break-if-=
var tab-items-first-free/eax: int <- copy *tab-items-first-free-addr
compare tab-items-first-free, 0x100/max-search-results
break-if->=
var dest/eax: (addr int) <- index tab-items, tab-items-first-free
copy-to *dest, i
increment *tab-items-first-free-addr
}
i <- increment
loop
}
var tab/edi: (addr tab) <- copy _tab
var tab-item-index-addr/edi: (addr int) <- get tab, item-index
var tab-items-first-free/eax: int <- copy *tab-items-first-free-addr
tab-items-first-free <- decrement
copy-to *tab-item-index-addr, tab-items-first-free
}
fn search-terms-match? _item: (addr item), search-terms: (addr array byte) -> _/eax: boolean {
var item/esi: (addr item) <- copy _item
var item-text-ah/eax: (addr handle array byte) <- get item, text
var item-text/eax: (addr array byte) <- lookup *item-text-ah
var i/ecx: int <- copy 0
var max/edx: int <- length item-text
var search-terms2/ebx: (addr array byte) <- copy search-terms
var slen/ebx: int <- length search-terms2
max <- subtract slen
{
compare i, max
break-if->
var found?/eax: boolean <- substring-match? item-text, search-terms, i
compare found?, 0/false
{
break-if-=
return 1/true
}
i <- increment
loop
}
return 0/false
}
fn substring-match? _s: (addr array byte), _pat: (addr array byte), start: int -> _/eax: boolean {
var s/esi: (addr array byte) <- copy _s
var pat/edi: (addr array byte) <- copy _pat
var s-idx/edx: int <- copy start
var pat-idx/ebx: int <- copy 0
var pat-len: int
var tmp/eax: int <- length pat
copy-to pat-len, tmp
{
compare pat-idx, pat-len
break-if->=
var s-ab/eax: (addr byte) <- index s, s-idx
var s-b/eax: byte <- copy-byte *s-ab
var pat-ab/ecx: (addr byte) <- index pat, pat-idx
var pat-b/ecx: byte <- copy-byte *pat-ab
compare s-b, pat-b
{
break-if-=
return 0/false
}
s-idx <- increment
pat-idx <- increment
loop
}
return 1/true
}
fn previous-tab _env: (addr environment) {
var env/edi: (addr environment) <- copy _env
var current-tab-index-addr/ecx: (addr int) <- get env, current-tab-index
compare *current-tab-index-addr, 0
{
break-if-<=
decrement *current-tab-index-addr
# if necessary restore search state
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var tabs/eax: (addr array tab) <- lookup *tabs-ah
var current-tab-index/ecx: int <- copy *current-tab-index-addr
var current-tab-offset/ecx: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/ecx: (addr tab) <- index tabs, current-tab-offset
var current-tab-type/eax: (addr int) <- get current-tab, type
compare *current-tab-type, 2/search
break-if-!=
var current-tab-search-terms-ah/ecx: (addr handle gap-buffer) <- get current-tab, search-terms
var search-terms-ah/edx: (addr handle gap-buffer) <- get env, search-terms
var search-terms/eax: (addr gap-buffer) <- lookup *search-terms-ah
clear-gap-buffer search-terms
copy-gap-buffer current-tab-search-terms-ah, search-terms-ah
}
}
fn next-item _env: (addr environment), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
var tabs/edx: (addr array tab) <- copy _tabs
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
var current-tab-index/eax: int <- copy *current-tab-index-a
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
var dest/ebx: (addr int) <- get current-tab, item-index
# if current-tab isn't all-items or channel, no need to worry about hidden items
var current-tab-type/eax: (addr int) <- get current-tab, type
{
compare *current-tab-type, 0/all-items
break-if-=
compare *current-tab-type, 1/channel
break-if-=
{
compare *dest, 0
break-if-<=
decrement *dest
}
return
}
var old-value/ecx: int <- copy *dest
# do { --*dest } while *dest > 0 and should-hide?(current-tab, *dest)
{
compare *dest, 0
break-if-<=
decrement *dest
# if current item is not hidden, return
var current-item-index/esi: int <- item-index env, _items, _channels
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
compare should-hide?, 0/false
loop-if-!=
return
}
# couldn't find a visible item. Restore.
copy-to *dest, old-value
}
fn previous-item _env: (addr environment), users: (addr array user), _channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var tabs-ah/eax: (addr handle array tab) <- get env, tabs
var _tabs/eax: (addr array tab) <- lookup *tabs-ah
var tabs/edx: (addr array tab) <- copy _tabs
var current-tab-index-a/eax: (addr int) <- get env, current-tab-index
var current-tab-index/eax: int <- copy *current-tab-index-a
var current-tab-offset/eax: (offset tab) <- compute-offset tabs, current-tab-index
var current-tab/edx: (addr tab) <- index tabs, current-tab-offset
var current-tab-type/eax: (addr int) <- get current-tab, type
compare *current-tab-type, 0/all-items
{
break-if-!=
var items/esi: (addr item-list) <- copy _items
var items-data-first-free-a/ecx: (addr int) <- get items, data-first-free
var final-item-index/ecx: int <- copy *items-data-first-free-a
final-item-index <- decrement
var dest/ebx: (addr int) <- get current-tab, item-index
var old-value/eax: int <- copy *dest
# do { ++*dest } while *dest < final-index and should-hide?(current-tab, *dest)
{
compare *dest, final-item-index
break-if->=
increment *dest
# if current item is not hidden, return
var current-item-index/esi: int <- item-index env, _items, _channels
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
compare should-hide?, 0/false
loop-if-!=
return
}
# couldn't find a visible item. Restore.
copy-to *dest, old-value
return
}
compare *current-tab-type, 1/channel
{
break-if-!=
var current-channel-index-addr/eax: (addr int) <- get current-tab, channel-index
var current-channel-index/eax: int <- copy *current-channel-index-addr
var channels/esi: (addr array channel) <- copy _channels
var current-channel-offset/eax: (offset channel) <- compute-offset channels, current-channel-index
var current-channel/eax: (addr channel) <- index channels, current-channel-offset
var current-channel-posts-first-free-addr/eax: (addr int) <- get current-channel, posts-first-free
var final-item-index/ecx: int <- copy *current-channel-posts-first-free-addr
final-item-index <- decrement
var dest/ebx: (addr int) <- get current-tab, item-index
var old-value/eax: int <- copy *dest
# do { ++*dest } while *dest < final-index and should-hide?(current-tab, *dest)
{
compare *dest, final-item-index
break-if->=
increment *dest
# if current item is not hidden, return
var current-item-index/esi: int <- item-index env, _items, _channels
var should-hide?/eax: boolean <- should-hide? current-tab, current-item-index, _items
compare should-hide?, 0/false
loop-if-!=
return
}
# couldn't find a visible item. Restore.
copy-to *dest, old-value
return
}
compare *current-tab-type, 2/search
{
break-if-!=
var current-tab-search-items-first-free-addr/eax: (addr int) <- get current-tab, search-items-first-free
var final-item-index/ecx: int <- copy *current-tab-search-items-first-free-addr
final-item-index <- decrement
var dest/eax: (addr int) <- get current-tab, item-index
compare *dest, final-item-index
break-if->=
increment *dest
return
}
compare *current-tab-type, 3/thread
{
break-if-!=
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/esi: (addr array item) <- copy _items-data
var current-tab-root-index-addr/eax: (addr int) <- get current-tab, root-index
var current-tab-root-index/eax: int <- copy *current-tab-root-index-addr
var current-tab-root-offset/eax: (offset item) <- compute-offset items-data, current-tab-root-index
var post/eax: (addr item) <- index items-data, current-tab-root-offset
var post-comments-first-free-addr/ecx: (addr int) <- get post, comments-first-free
var final-item-index/ecx: int <- copy *post-comments-first-free-addr
final-item-index <- decrement
var dest/eax: (addr int) <- get current-tab, item-index
compare *dest, final-item-index
break-if->=
increment *dest
return
}
}
fn page-down _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/ebx: (addr array item) <- copy _items-data
var _old-item-index/esi: int <- item-index env, _items, channels
var old-item-index/ecx: int <- copy _old-item-index
var y/edx: int <- copy 2
{
compare y, 0x28/screen-height-minus-menu
break-if->=
var item-index/esi: int <- item-index env, _items, channels
{
compare y, 2
break-if-= # skip this condition on first iteration
compare item-index, old-item-index
break-if-!=
# no forward progress; we're at the bottom of the current tab
return
}
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
var item/eax: (addr item) <- index items-data, item-offset
var item-text-ah/eax: (addr handle array byte) <- get item, text
var item-text/eax: (addr array byte) <- lookup *item-text-ah
var h/eax: int <- estimate-height item-text
y <- add h
next-item env, users, channels, _items
loop
}
# we're past the end of the screen now, so bounce back for some continuity
previous-item env, users, channels, _items
{
# HACK: make sure we make forward progress even if a single post takes up
# the whole screen.
# We can't see the rest of that single post at the moment. But at least we
# can go past it.
var old-item-index/eax: int <- copy old-item-index
var item-index/esi: int <- item-index env, _items, channels
compare item-index, old-item-index
break-if-!=
next-item env, users, channels, _items
}
}
fn page-up _env: (addr environment), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
var env/edi: (addr environment) <- copy _env
var items/eax: (addr item-list) <- copy _items
var items-data-ah/eax: (addr handle array item) <- get items, data
var _items-data/eax: (addr array item) <- lookup *items-data-ah
var items-data/ebx: (addr array item) <- copy _items-data
var _old-item-index/esi: int <- item-index env, _items, channels
var old-item-index/ecx: int <- copy _old-item-index
var y/edx: int <- copy 2
{
compare y, 0x28/screen-height-minus-menu
break-if->=
var item-index/esi: int <- item-index env, _items, channels
{
compare y, 2
break-if-= # skip this condition on first iteration
compare item-index, old-item-index
break-if-!=
# no forward progress; we're at the bottom of the current tab
return
}
var item-offset/eax: (offset item) <- compute-offset items-data, item-index
var item/eax: (addr item) <- index items-data, item-offset
var item-text-ah/eax: (addr handle array byte) <- get item, text
var item-text/eax: (addr array byte) <- lookup *item-text-ah
var h/eax: int <- estimate-height item-text
y <- add h
previous-item env, users, channels, _items
loop
}
}
# keep sync'd with render-item
fn estimate-height _message-text: (addr array byte) -> _/eax: int {
var message-text/esi: (addr array byte) <- copy _message-text
var result/eax: int <- length message-text
var remainder/edx: int <- copy 0
result, remainder <- integer-divide result, 0x40/post-width
compare remainder, 0
{
break-if-=
result <- increment
}
result <- add 2/item-padding-ver
compare result, 6/avatar-space-ver
{
break-if->
return 6/avatar-space-ver
}
return result
}