browse-slack/main.mu

   1 type channel {
   2   name: (handle array byte)
   3   posts: (handle array int)  # item indices
   4   posts-first-free: int
   5 }
   6
   7 type user {
   8   id: (handle array byte)
   9   name: (handle array byte)
  10   real-name: (handle array byte)
  11   avatar: (handle image)
  12 }
  13
  14 type item {
  15   id: (handle array byte)
  16   channel: (handle array byte)
  17   by: int  # user index
  18   text: (handle array byte)
  19   parent: int  # item index
  20   comments: (handle array int)
  21   comments-first-free: int
  22 }
  23
  24 type item-list {
  25   data: (handle array item)
  26   data-first-free: int
  27 }
  28
  29 # globals:
  30 #   users: (handle array user)
  31 #   channels: (handle array channel)
  32 #   items: (handle array item)
  33 #
  34 # flows:
  35 #   channel -> posts
  36 #   user -> posts|comments
  37 #   post -> comments
  38 #   comment -> post|comments
  39 #   keywords -> posts|comments
  40
  41 # static buffer sizes in this program:
  42 #   data-size
  43 #   data-size-in-sectors
  44 #   num-channels
  45 #   num-users
  46 #   num-items
  47 #   num-comments
  48 #   message-text-limit
  49 #   channel-capacity
  50
  51 fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk) {
  52   # load entire disk contents to a single enormous stream
  53   var s-h: (handle stream byte)  # the stream is too large to put on the stack
  54   var s-ah/eax: (addr handle stream byte) <- address s-h
  55   populate-stream s-ah, 0x4000000/data-size
  56   var _s/eax: (addr stream byte) <- lookup *s-ah
  57   var s/ebx: (addr stream byte) <- copy _s
  58   var sector-count/eax: int <- copy 0x400  # test_data
  59 #?   var sector-count/eax: int <- copy 0x20000  # largest size tested; slow
  60   set-cursor-position 0/screen, 0x20/x 0/y  # aborts clobber the screen starting x=0
  61   draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "loading ", 3/fg 0/bg
  62   draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen, sector-count, 3/fg 0/bg
  63   draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, " sectors from data disk..", 3/fg 0/bg
  64   load-sectors data-disk, 0/lba, sector-count, s
  65   draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen, "done", 3/fg 0/bg
  66   # parse global data structures out of the stream
  67   var users-h: (handle array user)
  68   var users-ah/eax: (addr handle array user) <- address users-h
  69   populate users-ah, 0x800/num-users
  70   var _users/eax: (addr array user) <- lookup *users-ah
  71   var users/edi: (addr array user) <- copy _users
  72   var channels-h: (handle array channel)
  73   var channels-ah/eax: (addr handle array channel) <- address channels-h
  74   populate channels-ah, 0x20/num-channels
  75   var _channels/eax: (addr array channel) <- lookup *channels-ah
  76   var channels/esi: (addr array channel) <- copy _channels
  77   var items-storage: item-list
  78   var items/edx: (addr item-list) <- address items-storage
  79   var items-data-ah/eax: (addr handle array item) <- get items, data
  80   populate items-data-ah, 0x10000/num-items
  81   parse s, users, channels, items
  82   # render
  83   var env-storage: environment
  84   var env/ebx: (addr environment) <- address env-storage
  85   initialize-environment env, items
  86   {
  87     render-environment screen, env, users, channels, items
  88     {
  89       var key/eax: byte <- read-key keyboard
  90       compare key, 0
  91       loop-if-=
  92       update-environment env, key, users, channels, items
  93     }
  94     loop
  95   }
  96 }
  97
  98 fn parse in: (addr stream byte), users: (addr array user), channels: (addr array channel), _items: (addr item-list) {
  99   var items/esi: (addr item-list) <- copy _items
 100   var items-data-ah/eax: (addr handle array item) <- get items, data
 101   var _items-data/eax: (addr array item) <- lookup *items-data-ah
 102   var items-data/edi: (addr array item) <- copy _items-data
 103   # 'in' consists of a long, flat sequence of records surrounded by parens
 104   var record-storage: (stream byte 0x18000)
 105   var record/ecx: (addr stream byte) <- address record-storage
 106   var user-idx/edx: int <- copy 0
 107   var item-idx/ebx: int <- copy 0
 108   {
 109     var done?/eax: boolean <- stream-empty? in
 110     compare done?, 0/false
 111     break-if-!=
 112     var c/eax: byte <- peek-byte in
 113     compare c, 0
 114     break-if-=
 115     set-cursor-position 0/screen, 0x20/x 1/y
 116     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, "parsed " 3/fg 0/bg
 117     draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, user-idx, 3/fg 0/bg
 118     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, " users, " 3/fg 0/bg
 119     draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, item-idx, 3/fg 0/bg
 120     draw-text-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, " posts/comments" 3/fg 0/bg
 121     clear-stream record
 122     parse-record in, record
 123     var user?/eax: boolean <- user-record? record
 124     {
 125       compare user?, 0/false
 126       break-if-=
 127       parse-user record, users, user-idx
 128       user-idx <- increment
 129     }
 130     {
 131       compare user?, 0/false
 132       break-if-!=
 133       parse-item record, channels, items-data, item-idx
 134       item-idx <- increment
 135     }
 136     loop
 137   }
 138   var dest/eax: (addr int) <- get items, data-first-free
 139   copy-to *dest, item-idx
 140 }
 141
 142 fn parse-record in: (addr stream byte), out: (addr stream byte) {
 143   var paren/eax: byte <- read-byte in
 144   compare paren, 0x28/open-paren
 145   {
 146     break-if-=
 147     set-cursor-position 0/screen, 0x20 0x10
 148     var c/eax: int <- copy paren
 149     draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen c, 5/fg 0/bg
 150     abort "parse-record: ("
 151   }
 152   var paren-int/eax: int <- copy paren
 153   append-byte out, paren-int
 154   {
 155     {
 156       var eof?/eax: boolean <- stream-empty? in
 157       compare eof?, 0/false
 158       break-if-=
 159       abort "parse-record: truncated; increase the sector-count to load from disk"
 160     }
 161     var c/eax: byte <- read-byte in
 162     {
 163       var c-int/eax: int <- copy c
 164       append-byte out, c-int
 165     }
 166     compare c, 0x29/close-paren
 167     break-if-=
 168     compare c, 0x22/double-quote
 169     {
 170       break-if-!=
 171       slurp-json-string in, out
 172     }
 173     loop
 174   }
 175   skip-chars-matching-whitespace in
 176 }
 177
 178 fn user-record? record: (addr stream byte) -> _/eax: boolean {
 179   rewind-stream record
 180   var c/eax: byte <- read-byte record  # skip paren
 181   var c/eax: byte <- read-byte record  # skip double quote
 182   var c/eax: byte <- read-byte record
 183   compare c, 0x55/U
 184   {
 185     break-if-!=
 186     return 1/true
 187   }
 188   rewind-stream record
 189   return 0/false
 190 }
 191
 192 fn parse-user record: (addr stream byte), _users: (addr array user), user-idx: int {
 193   var users/esi: (addr array user) <- copy _users
 194   var offset/eax: (offset user) <- compute-offset users, user-idx
 195   var user/esi: (addr user) <- index users, offset
 196   #
 197   var s-storage: (stream byte 0x100)
 198   var s/ecx: (addr stream byte) <- address s-storage
 199   #
 200   rewind-stream record
 201   var paren/eax: byte <- read-byte record
 202   compare paren, 0x28/open-paren
 203   {
 204     break-if-=
 205     abort "parse-user: ("
 206   }
 207   # user id
 208   skip-chars-matching-whitespace record
 209   var double-quote/eax: byte <- read-byte record
 210   compare double-quote, 0x22/double-quote
 211   {
 212     break-if-=
 213     abort "parse-user: id"
 214   }
 215   next-json-string record, s
 216   var dest/eax: (addr handle array byte) <- get user, id
 217   stream-to-array s, dest
 218   # user name
 219   skip-chars-matching-whitespace record
 220   var double-quote/eax: byte <- read-byte record
 221   compare double-quote, 0x22/double-quote
 222   {
 223     break-if-=
 224     abort "parse-user: name"
 225   }
 226   clear-stream s
 227   next-json-string record, s
 228   var dest/eax: (addr handle array byte) <- get user, name
 229   stream-to-array s, dest
 230   # real name
 231   skip-chars-matching-whitespace record
 232   var double-quote/eax: byte <- read-byte record
 233   compare double-quote, 0x22/double-quote
 234   {
 235     break-if-=
 236     abort "parse-user: real-name"
 237   }
 238   clear-stream s
 239   next-json-string record, s
 240   var dest/eax: (addr handle array byte) <- get user, real-name
 241   stream-to-array s, dest
 242   # avatar
 243   skip-chars-matching-whitespace record
 244   var open-bracket/eax: byte <- read-byte record
 245   compare open-bracket, 0x5b/open-bracket
 246   {
 247     break-if-=
 248     abort "parse-user: avatar"
 249   }
 250   skip-chars-matching-whitespace record
 251   var c/eax: byte <- peek-byte record
 252   {
 253     compare c, 0x5d/close-bracket
 254     break-if-=
 255     var dest-ah/eax: (addr handle image) <- get user, avatar
 256     allocate dest-ah
 257     var dest/eax: (addr image) <- lookup *dest-ah
 258     initialize-image dest, record
 259   }
 260 }
 261
 262 fn parse-item record: (addr stream byte), _channels: (addr array channel), _items: (addr array item), item-idx: int {
 263   var items/esi: (addr array item) <- copy _items
 264   var offset/eax: (offset item) <- compute-offset items, item-idx
 265   var item/edi: (addr item) <- index items, offset
 266   #
 267   var s-storage: (stream byte 0x40)
 268   var s/ecx: (addr stream byte) <- address s-storage
 269   #
 270   rewind-stream record
 271   var paren/eax: byte <- read-byte record
 272   compare paren, 0x28/open-paren
 273   {
 274     break-if-=
 275     abort "parse-item: ("
 276   }
 277   # item id
 278   skip-chars-matching-whitespace record
 279   var double-quote/eax: byte <- read-byte record
 280   compare double-quote, 0x22/double-quote
 281   {
 282     break-if-=
 283     abort "parse-item: id"
 284   }
 285   next-json-string record, s
 286   var dest/eax: (addr handle array byte) <- get item, id
 287   stream-to-array s, dest
 288   # parent index
 289   {
 290     var word-slice-storage: slice
 291     var word-slice/ecx: (addr slice) <- address word-slice-storage
 292     next-word record, word-slice
 293     var src/eax: int <- parse-decimal-int-from-slice word-slice
 294     compare src, -1
 295     break-if-=
 296     var dest/edx: (addr int) <- get item, parent
 297     copy-to *dest, src
 298     # cross-link to parent
 299     var parent-offset/eax: (offset item) <- compute-offset items, src
 300     var parent-item/esi: (addr item) <- index items, parent-offset
 301     var parent-comments-ah/ebx: (addr handle array int) <- get parent-item, comments
 302     var parent-comments/eax: (addr array int) <- lookup *parent-comments-ah
 303     compare parent-comments, 0
 304     {
 305       break-if-!=
 306       populate parent-comments-ah, 0x200/num-comments
 307       parent-comments <- lookup *parent-comments-ah
 308     }
 309     var parent-comments-first-free-addr/edi: (addr int) <- get parent-item, comments-first-free
 310     var parent-comments-first-free/edx: int <- copy *parent-comments-first-free-addr
 311     var dest/eax: (addr int) <- index parent-comments, parent-comments-first-free
 312     var src/ecx: int <- copy item-idx
 313     copy-to *dest, src
 314     increment *parent-comments-first-free-addr
 315   }
 316   # channel name
 317   skip-chars-matching-whitespace record
 318   var double-quote/eax: byte <- read-byte record
 319   compare double-quote, 0x22/double-quote
 320   {
 321     break-if-=
 322     abort "parse-item: channel"
 323   }
 324   clear-stream s
 325   next-json-string record, s
 326   var dest/eax: (addr handle array byte) <- get item, channel
 327   stream-to-array s, dest
 328 #?   set-cursor-position 0/screen, 0x70 item-idx
 329   # cross-link to channels
 330   {
 331     var channels/esi: (addr array channel) <- copy _channels
 332     var channel-index/eax: int <- find-or-insert channels, s
 333 #?     draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, channel-index, 5/fg 0/bg
 334     var channel-offset/eax: (offset channel) <- compute-offset channels, channel-index
 335     var channel/eax: (addr channel) <- index channels, channel-offset
 336 #?     {
 337 #?       var foo/eax: int <- copy channel
 338 #?       draw-int32-hex-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, foo, 4/fg 0/bg
 339 #?     }
 340     var channel-posts-ah/ecx: (addr handle array int) <- get channel, posts
 341     var channel-posts-first-free-addr/edx: (addr int) <- get channel, posts-first-free
 342 #?     {
 343 #?       var foo/eax: int <- copy channel-posts-first-free-addr
 344 #?       draw-int32-hex-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, foo, 4/fg 0/bg
 345 #?     }
 346     var channel-posts-first-free/ebx: int <- copy *channel-posts-first-free-addr
 347 #?     draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen 0/screen, channel-posts-first-free, 3/fg 0/bg
 348     var channel-posts/eax: (addr array int) <- lookup *channel-posts-ah
 349     var dest/eax: (addr int) <- index channel-posts, channel-posts-first-free
 350     var src/ecx: int <- copy item-idx
 351     copy-to *dest, src
 352     increment *channel-posts-first-free-addr
 353   }
 354   # user index
 355   {
 356     var word-slice-storage: slice
 357     var word-slice/ecx: (addr slice) <- address word-slice-storage
 358     next-word record, word-slice
 359     var src/eax: int <- parse-decimal-int-from-slice word-slice
 360     var dest/edx: (addr int) <- get item, by
 361     copy-to *dest, src
 362   }
 363   # text
 364   var s-storage: (stream byte 0x4000)  # message-text-limit
 365   var s/ecx: (addr stream byte) <- address s-storage
 366   skip-chars-matching-whitespace record
 367   var double-quote/eax: byte <- read-byte record
 368   compare double-quote, 0x22/double-quote
 369   {
 370     break-if-=
 371     abort "parse-item: text"
 372   }
 373   next-json-string record, s
 374   var dest/eax: (addr handle array byte) <- get item, text
 375   stream-to-array s, dest
 376 }
 377
 378 fn find-or-insert _channels: (addr array channel), name: (addr stream byte) -> _/eax: int {
 379   var channels/esi: (addr array channel) <- copy _channels
 380   var i/ecx: int <- copy 0
 381   var max/edx: int <- length channels
 382   {
 383     compare i, max
 384     break-if->=
 385     var offset/eax: (offset channel) <- compute-offset channels, i
 386     var curr/ebx: (addr channel) <- index channels, offset
 387     var curr-name-ah/edi: (addr handle array byte) <- get curr, name
 388     var curr-name/eax: (addr array byte) <- lookup *curr-name-ah
 389     {
 390       compare curr-name, 0
 391       break-if-!=
 392       rewind-stream name
 393       stream-to-array name, curr-name-ah
 394       var posts-ah/eax: (addr handle array int) <- get curr, posts
 395       populate posts-ah, 0x8000/channel-capacity
 396       return i
 397     }
 398     var found?/eax: boolean <- stream-data-equal? name, curr-name
 399     {
 400       compare found?, 0/false
 401       break-if-=
 402       return i
 403     }
 404     i <- increment
 405     loop
 406   }
 407   abort "out of channels"
 408   return -1
 409 }
 410
 411 # includes trailing double quote
 412 fn slurp-json-string in: (addr stream byte), out: (addr stream byte) {
 413   # open quote is already slurped
 414   {
 415     {
 416       var eof?/eax: boolean <- stream-empty? in
 417       compare eof?, 0/false
 418       break-if-=
 419       abort "slurp-json-string: truncated"
 420     }
 421     var c/eax: byte <- read-byte in
 422     {
 423       var c-int/eax: int <- copy c
 424       append-byte out, c-int
 425     }
 426     compare c, 0x22/double-quote
 427     break-if-=
 428     compare c, 0x5c/backslash
 429     {
 430       break-if-!=
 431       # read next byte raw
 432       c <- read-byte in
 433       var c-int/eax: int <- copy c
 434       append-byte out, c-int
 435     }
 436     loop
 437   }
 438 }
 439
 440 # drops trailing double quote
 441 fn next-json-string in: (addr stream byte), out: (addr stream byte) {
 442   # open quote is already read
 443   {
 444     {
 445       var eof?/eax: boolean <- stream-empty? in
 446       compare eof?, 0/false
 447       break-if-=
 448       abort "next-json-string: truncated"
 449     }
 450     var c/eax: byte <- read-byte in
 451     compare c, 0x22/double-quote
 452     break-if-=
 453     {
 454       var c-int/eax: int <- copy c
 455       append-byte out, c-int
 456     }
 457     compare c, 0x5c/backslash
 458     {
 459       break-if-!=
 460       # read next byte raw
 461       c <- read-byte in
 462       var c-int/eax: int <- copy c
 463       append-byte out, c-int
 464     }
 465     loop
 466   }
 467 }