501draw-text.mu

   1 # some primitives for moving the cursor without making assumptions about
   2 # raster order
   3 fn move-cursor-left screen: (addr screen) {
   4   var cursor-x/eax: int <- copy 0
   5   var cursor-y/ecx: int <- copy 0
   6   cursor-x, cursor-y <- cursor-position screen
   7   compare cursor-x, 0
   8   {
   9     break-if->
  10     return
  11   }
  12   cursor-x <- decrement
  13   set-cursor-position screen, cursor-x, cursor-y
  14 }
  15
  16 fn move-cursor-right screen: (addr screen) {
  17   var _width/eax: int <- copy 0
  18   var dummy/ecx: int <- copy 0
  19   _width, dummy <- screen-size screen
  20   var limit/edx: int <- copy _width
  21   limit <- decrement
  22   var cursor-x/eax: int <- copy 0
  23   var cursor-y/ecx: int <- copy 0
  24   cursor-x, cursor-y <- cursor-position screen
  25   compare cursor-x, limit
  26   {
  27     break-if-<
  28     return
  29   }
  30   cursor-x <- increment
  31   set-cursor-position screen, cursor-x, cursor-y
  32 }
  33
  34 fn move-cursor-up screen: (addr screen) {
  35   var cursor-x/eax: int <- copy 0
  36   var cursor-y/ecx: int <- copy 0
  37   cursor-x, cursor-y <- cursor-position screen
  38   compare cursor-y, 0
  39   {
  40     break-if->
  41     return
  42   }
  43   cursor-y <- decrement
  44   set-cursor-position screen, cursor-x, cursor-y
  45 }
  46
  47 fn move-cursor-down screen: (addr screen) {
  48   var dummy/eax: int <- copy 0
  49   var _height/ecx: int <- copy 0
  50   dummy, _height <- screen-size screen
  51   var limit/edx: int <- copy _height
  52   limit <- decrement
  53   var cursor-x/eax: int <- copy 0
  54   var cursor-y/ecx: int <- copy 0
  55   cursor-x, cursor-y <- cursor-position screen
  56   compare cursor-y, limit
  57   {
  58     break-if-<
  59     return
  60   }
  61   cursor-y <- increment
  62   set-cursor-position screen, cursor-x, cursor-y
  63 }
  64
  65 fn move-cursor-to-left-margin-of-next-line screen: (addr screen) {
  66   var dummy/eax: int <- copy 0
  67   var _height/ecx: int <- copy 0
  68   dummy, _height <- screen-size screen
  69   var limit/edx: int <- copy _height
  70   limit <- decrement
  71   var cursor-x/eax: int <- copy 0
  72   var cursor-y/ecx: int <- copy 0
  73   cursor-x, cursor-y <- cursor-position screen
  74   compare cursor-y, limit
  75   {
  76     break-if-<
  77     return
  78   }
  79   cursor-y <- increment
  80   cursor-x <- copy 0
  81   set-cursor-position screen, cursor-x, cursor-y
  82 }
  83
  84 fn draw-code-point-at-cursor-over-full-screen screen: (addr screen), c: code-point, color: int, background-color: int {
  85   var cursor-x/eax: int <- copy 0
  86   var cursor-y/ecx: int <- copy 0
  87   cursor-x, cursor-y <- cursor-position screen
  88   var _offset/eax: int <- draw-code-point screen, c, cursor-x, cursor-y, color, background-color
  89   var offset/edx: int <- copy _offset
  90   var width/eax: int <- copy 0
  91   var dummy/ecx: int <- copy 0
  92   width, dummy <- screen-size screen
  93   move-cursor-rightward-and-downward screen, 0 width
  94   offset <- decrement
  95   compare offset, 0
  96   {
  97     break-if-=
  98     # should never move downward here
  99     move-cursor-rightward-and-downward screen, 0 width
 100   }
 101 }
 102
 103 # draw a single line of text from x, y to xmax
 104 # return the next 'x' coordinate
 105 # if there isn't enough space, truncate
 106 fn draw-text-rightward screen: (addr screen), text: (addr array byte), x: int, xmax: int, y: int, color: int, background-color: int -> _/eax: int {
 107   var stream-storage: (stream byte 0x400/print-buffer-size)
 108   var stream/esi: (addr stream byte) <- address stream-storage
 109   write stream, text
 110   var xcurr/eax: int <- draw-stream-rightward screen, stream, x, xmax, y, color, background-color
 111   return xcurr
 112 }
 113
 114 # draw a single-line stream from x, y to xmax
 115 # return the next 'x' coordinate
 116 # if there isn't enough space, truncate
 117 fn draw-stream-rightward screen: (addr screen), stream: (addr stream byte), x: int, xmax: int, y: int, color: int, background-color: int -> _/eax: int {
 118   var xcurr/ecx: int <- copy x
 119   {
 120     var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 121     compare g, 0xffffffff/end-of-file
 122     break-if-=
 123     var c/eax: code-point <- to-code-point g
 124     var offset/eax: int <- draw-code-point screen, c, xcurr, y, color, background-color
 125     xcurr <- add offset
 126     loop
 127   }
 128   set-cursor-position screen, xcurr, y
 129   return xcurr
 130 }
 131
 132 fn draw-text-rightward-over-full-screen screen: (addr screen), text: (addr array byte), x: int, y: int, color: int, background-color: int -> _/eax: int {
 133   var width/eax: int <- copy 0
 134   var height/ecx: int <- copy 0
 135   width, height <- screen-size screen
 136   var result/eax: int <- draw-text-rightward screen, text, x, width, y, color, background-color
 137   return result
 138 }
 139
 140 fn draw-text-rightward-from-cursor screen: (addr screen), text: (addr array byte), xmax: int, color: int, background-color: int {
 141   var cursor-x/eax: int <- copy 0
 142   var cursor-y/ecx: int <- copy 0
 143   cursor-x, cursor-y <- cursor-position screen
 144   cursor-x <- draw-text-rightward screen, text, cursor-x, xmax, cursor-y, color, background-color
 145   set-cursor-position screen, cursor-x, cursor-y
 146 }
 147
 148 fn draw-text-rightward-from-cursor-over-full-screen screen: (addr screen), text: (addr array byte), color: int, background-color: int {
 149   var width/eax: int <- copy 0
 150   var height/ecx: int <- copy 0
 151   width, height <- screen-size screen
 152   draw-text-rightward-from-cursor screen, text, width, color, background-color
 153 }
 154
 155 fn render-code-point screen: (addr screen), c: code-point, xmin: int, ymin: int, xmax: int, ymax: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 156   var x/ecx: int <- copy x
 157   compare c, 0xa/newline
 158   {
 159     break-if-!=
 160     # minimum effort to clear cursor
 161     var dummy/eax: int <- draw-code-point screen, 0x20/space, x, y, color, background-color
 162     x <- copy xmin
 163     increment y
 164     return x, y
 165   }
 166   var offset/eax: int <- draw-code-point screen, c, x, y, color, background-color
 167   x <- add offset
 168   compare x, xmax
 169   {
 170     break-if-<
 171     x <- copy xmin
 172     increment y
 173   }
 174   return x, y
 175 }
 176
 177 # draw text in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
 178 # return the next (x, y) coordinate in raster order where drawing stopped
 179 # that way the caller can draw more if given the same min and max bounding-box.
 180 # if there isn't enough space, truncate
 181 fn draw-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 {
 182   var stream-storage: (stream byte 0x200/print-buffer-size)
 183   var stream/edi: (addr stream byte) <- address stream-storage
 184   var text/esi: (addr array byte) <- copy _text
 185   var len/eax: int <- length text
 186   compare len, 0x200/print-buffer-size
 187   {
 188     break-if-<
 189     write stream, "ERROR: stream too small in draw-text-wrapping-right-then-down"
 190   }
 191   compare len, 0x200/print-buffer-size
 192   {
 193     break-if->=
 194     write stream, text
 195   }
 196   var x/eax: int <- copy _x
 197   var y/ecx: int <- copy _y
 198   x, y <- draw-stream-wrapping-right-then-down screen, stream, xmin, ymin, xmax, ymax, x, y, color, background-color
 199   return x, y
 200 }
 201
 202 # draw a stream in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
 203 # return the next (x, y) coordinate in raster order where drawing stopped
 204 # that way the caller can draw more if given the same min and max bounding-box.
 205 # if there isn't enough space, truncate
 206 fn draw-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 {
 207   var xcurr/ecx: int <- copy x
 208   var ycurr/edx: int <- copy y
 209   var c/ebx: code-point <- copy 0
 210   var next-c/esi: code-point <- copy 0
 211   $draw-stream-wrapping-right-then-down:loop: {
 212     # read c from either next-c or stream
 213     $draw-stream-wrapping-right-then-down:read-base: {
 214       compare next-c, 0
 215       {
 216         break-if-=
 217         c <- copy next-c
 218         next-c <- copy 0
 219         break $draw-stream-wrapping-right-then-down:read-base
 220       }
 221       var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 222       var _c/eax: code-point <- to-code-point g
 223       c <- copy _c
 224     }
 225     compare c, 0xffffffff/end-of-file
 226     break-if-=
 227     compare c, 0xa/newline
 228     {
 229       break-if-!=
 230       # minimum effort to clear cursor
 231       var dummy/eax: int <- draw-code-point screen, 0x20/space, xcurr, ycurr, color, background-color
 232       xcurr <- copy xmin
 233       ycurr <- increment
 234       loop $draw-stream-wrapping-right-then-down:loop
 235     }
 236     var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
 237     # overlay a combining character if necessary
 238     $draw-stream-wrapping-right-then-down:read-combiner: {
 239       var done?/eax: boolean <- stream-empty? stream
 240       compare done?, 0/false
 241       break-if-!=
 242       # read a character
 243       var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 244       var c/eax: code-point <- to-code-point g
 245       # if not a combining character, save for next iteration and loop
 246       {
 247         var combining-code-point?/eax: boolean <- combining-code-point? c
 248         compare combining-code-point?, 0/false
 249       }
 250       {
 251         break-if-!=
 252         next-c <- copy c
 253         break $draw-stream-wrapping-right-then-down:read-combiner
 254       }
 255       # otherwise overlay it without saving its width
 256       # This means strange results if a base and its combiner have different
 257       # widths. We'll always follow the base width.
 258       var dummy/eax: int <- overlay-code-point screen, c, xcurr, ycurr, color, background-color
 259     }
 260     xcurr <- add offset
 261     compare xcurr, xmax
 262     {
 263       break-if-<
 264       xcurr <- copy xmin
 265       ycurr <- increment
 266     }
 267     loop
 268   }
 269   set-cursor-position screen, xcurr, ycurr
 270   return xcurr, ycurr
 271 }
 272
 273 fn draw-stream-wrapping-right-then-down-from-cursor screen: (addr screen), stream: (addr stream byte), xmin: int, ymin: int, xmax: int, ymax: int, color: int, background-color: int {
 274   var cursor-x/eax: int <- copy 0
 275   var cursor-y/ecx: int <- copy 0
 276   cursor-x, cursor-y <- cursor-position screen
 277   var end-x/edx: int <- copy cursor-x
 278   end-x <- increment
 279   compare end-x, xmax
 280   {
 281     break-if-<
 282     cursor-x <- copy xmin
 283     cursor-y <- increment
 284   }
 285   cursor-x, cursor-y <- draw-stream-wrapping-right-then-down screen, stream, xmin, ymin, xmax, ymax, cursor-x, cursor-y, color, background-color
 286 }
 287
 288 fn draw-stream-wrapping-right-then-down-from-cursor-over-full-screen screen: (addr screen), stream: (addr stream byte), color: int, background-color: int {
 289   var width/eax: int <- copy 0
 290   var height/ecx: int <- copy 0
 291   width, height <- screen-size screen
 292   draw-stream-wrapping-right-then-down-from-cursor screen, stream, 0/xmin, 0/ymin, width, height, color, background-color
 293 }
 294
 295 fn move-cursor-rightward-and-downward screen: (addr screen), xmin: int, xmax: int {
 296   var cursor-x/eax: int <- copy 0
 297   var cursor-y/ecx: int <- copy 0
 298   cursor-x, cursor-y <- cursor-position screen
 299   cursor-x <- increment
 300   compare cursor-x, xmax
 301   {
 302     break-if-<
 303     cursor-x <- copy xmin
 304     cursor-y <- increment
 305   }
 306   set-cursor-position screen, cursor-x, cursor-y
 307 }
 308
 309 fn draw-text-wrapping-right-then-down-over-full-screen screen: (addr screen), text: (addr array byte), x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 310   var x2/eax: int <- copy 0
 311   var y2/ecx: int <- copy 0
 312   x2, y2 <- screen-size screen  # width, height
 313   x2, y2 <- draw-text-wrapping-right-then-down screen, text, 0/xmin, 0/ymin, x2, y2, x, y, color, background-color
 314   return x2, y2  # cursor-x, cursor-y
 315 }
 316
 317 fn draw-text-wrapping-right-then-down-from-cursor screen: (addr screen), text: (addr array byte), xmin: int, ymin: int, xmax: int, ymax: int, color: int, background-color: int {
 318   var cursor-x/eax: int <- copy 0
 319   var cursor-y/ecx: int <- copy 0
 320   cursor-x, cursor-y <- cursor-position screen
 321   var end-x/edx: int <- copy cursor-x
 322   end-x <- increment
 323   compare end-x, xmax
 324   {
 325     break-if-<
 326     cursor-x <- copy xmin
 327     cursor-y <- increment
 328   }
 329   cursor-x, cursor-y <- draw-text-wrapping-right-then-down screen, text, xmin, ymin, xmax, ymax, cursor-x, cursor-y, color, background-color
 330 }
 331
 332 fn draw-text-wrapping-right-then-down-from-cursor-over-full-screen screen: (addr screen), text: (addr array byte), color: int, background-color: int {
 333   var width/eax: int <- copy 0
 334   var height/ecx: int <- copy 0
 335   width, height <- screen-size screen
 336   draw-text-wrapping-right-then-down-from-cursor screen, text, 0/xmin, 0/ymin, width, height, color, background-color
 337 }
 338
 339 fn draw-int32-hex-wrapping-right-then-down screen: (addr screen), n: int, xmin: int, ymin: int, xmax: int, ymax: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 340   var stream-storage: (stream byte 0x100)
 341   var stream/esi: (addr stream byte) <- address stream-storage
 342   write-int32-hex stream, n
 343   var xcurr/edx: int <- copy x
 344   var ycurr/ecx: int <- copy y
 345   {
 346     var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 347     compare g, 0xffffffff/end-of-file
 348     break-if-=
 349     var c/eax: code-point <- to-code-point g
 350     var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
 351     xcurr <- add offset
 352     compare xcurr, xmax
 353     {
 354       break-if-<
 355       xcurr <- copy xmin
 356       ycurr <- increment
 357     }
 358     loop
 359   }
 360   set-cursor-position screen, xcurr, ycurr
 361   return xcurr, ycurr
 362 }
 363
 364 fn draw-int32-hex-wrapping-right-then-down-over-full-screen screen: (addr screen), n: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 365   var x2/eax: int <- copy 0
 366   var y2/ecx: int <- copy 0
 367   x2, y2 <- screen-size screen  # width, height
 368   x2, y2 <- draw-int32-hex-wrapping-right-then-down screen, n, 0/xmin, 0/ymin, x2, y2, x, y, color, background-color
 369   return x2, y2  # cursor-x, cursor-y
 370 }
 371
 372 fn draw-int32-hex-wrapping-right-then-down-from-cursor screen: (addr screen), n: int, xmin: int, ymin: int, xmax: int, ymax: int, color: int, background-color: int {
 373   var cursor-x/eax: int <- copy 0
 374   var cursor-y/ecx: int <- copy 0
 375   cursor-x, cursor-y <- cursor-position screen
 376   var end-x/edx: int <- copy cursor-x
 377   end-x <- increment
 378   compare end-x, xmax
 379   {
 380     break-if-<
 381     cursor-x <- copy xmin
 382     cursor-y <- increment
 383   }
 384   cursor-x, cursor-y <- draw-int32-hex-wrapping-right-then-down screen, n, xmin, ymin, xmax, ymax, cursor-x, cursor-y, color, background-color
 385 }
 386
 387 fn draw-int32-hex-wrapping-right-then-down-from-cursor-over-full-screen screen: (addr screen), n: int, color: int, background-color: int {
 388   var width/eax: int <- copy 0
 389   var height/ecx: int <- copy 0
 390   width, height <- screen-size screen
 391   draw-int32-hex-wrapping-right-then-down-from-cursor screen, n, 0/xmin, 0/ymin, width, height, color, background-color
 392 }
 393
 394 fn draw-int32-decimal-wrapping-right-then-down screen: (addr screen), n: int, xmin: int, ymin: int, xmax: int, ymax: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 395   var stream-storage: (stream byte 0x100)
 396   var stream/esi: (addr stream byte) <- address stream-storage
 397   write-int32-decimal stream, n
 398   var xcurr/edx: int <- copy x
 399   var ycurr/ecx: int <- copy y
 400   {
 401     var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 402     compare g, 0xffffffff/end-of-file
 403     break-if-=
 404     var c/eax: code-point <- to-code-point g
 405     var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
 406     xcurr <- add offset
 407     compare xcurr, xmax
 408     {
 409       break-if-<
 410       xcurr <- copy xmin
 411       ycurr <- increment
 412     }
 413     loop
 414   }
 415   set-cursor-position screen, xcurr, ycurr
 416   return xcurr, ycurr
 417 }
 418
 419 fn draw-int32-decimal-wrapping-right-then-down-over-full-screen screen: (addr screen), n: int, x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 420   var x2/eax: int <- copy 0
 421   var y2/ecx: int <- copy 0
 422   x2, y2 <- screen-size screen  # width, height
 423   x2, y2 <- draw-int32-decimal-wrapping-right-then-down screen, n, 0/xmin, 0/ymin, x2, y2, x, y, color, background-color
 424   return x2, y2  # cursor-x, cursor-y
 425 }
 426
 427 fn draw-int32-decimal-wrapping-right-then-down-from-cursor screen: (addr screen), n: int, xmin: int, ymin: int, xmax: int, ymax: int, color: int, background-color: int {
 428   var cursor-x/eax: int <- copy 0
 429   var cursor-y/ecx: int <- copy 0
 430   cursor-x, cursor-y <- cursor-position screen
 431   var end-x/edx: int <- copy cursor-x
 432   end-x <- increment
 433   compare end-x, xmax
 434   {
 435     break-if-<
 436     cursor-x <- copy xmin
 437     cursor-y <- increment
 438   }
 439   cursor-x, cursor-y <- draw-int32-decimal-wrapping-right-then-down screen, n, xmin, ymin, xmax, ymax, cursor-x, cursor-y, color, background-color
 440 }
 441
 442 fn draw-int32-decimal-wrapping-right-then-down-from-cursor-over-full-screen screen: (addr screen), n: int, color: int, background-color: int {
 443   var width/eax: int <- copy 0
 444   var height/ecx: int <- copy 0
 445   width, height <- screen-size screen
 446   draw-int32-decimal-wrapping-right-then-down-from-cursor screen, n, 0/xmin, 0/ymin, width, height, color, background-color
 447 }
 448
 449 ## Text direction: down then right
 450
 451 # draw a single line of text vertically from x, y to ymax
 452 # return the next 'y' coordinate
 453 # if there isn't enough space, truncate
 454 fn draw-text-downward screen: (addr screen), text: (addr array byte), x: int, y: int, ymax: int, color: int, background-color: int -> _/eax: int {
 455   var stream-storage: (stream byte 0x100)
 456   var stream/esi: (addr stream byte) <- address stream-storage
 457   write stream, text
 458   var ycurr/eax: int <- draw-stream-downward screen, stream, x, y, ymax, color, background-color
 459   return ycurr
 460 }
 461
 462 # draw a single-line stream vertically from x, y to ymax
 463 # return the next 'y' coordinate
 464 # if there isn't enough space, truncate
 465 # TODO: should we track horizontal width?
 466 fn draw-stream-downward screen: (addr screen), stream: (addr stream byte), x: int, y: int, ymax: int, color: int, background-color: int -> _/eax: int {
 467   var ycurr/ecx: int <- copy y
 468   {
 469     var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 470     compare g, 0xffffffff/end-of-file
 471     break-if-=
 472     var c/eax: code-point <- to-code-point g
 473     var dummy/eax: int <- draw-code-point screen, c, x, ycurr, color, background-color
 474     ycurr <- increment
 475     loop
 476   }
 477   set-cursor-position screen, x, ycurr
 478   return ycurr
 479 }
 480
 481 fn draw-text-downward-from-cursor screen: (addr screen), text: (addr array byte), ymax: int, color: int, background-color: int {
 482   var cursor-x/eax: int <- copy 0
 483   var cursor-y/ecx: int <- copy 0
 484   cursor-x, cursor-y <- cursor-position screen
 485   var result/eax: int <- draw-text-downward screen, text, cursor-x, cursor-y, ymax, color, background-color
 486 }
 487
 488 # draw text down and right in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
 489 # return the next (x, y) coordinate in raster order where drawing stopped
 490 # that way the caller can draw more if given the same min and max bounding-box.
 491 # if there isn't enough space, truncate
 492 fn draw-text-wrapping-down-then-right 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 {
 493   var stream-storage: (stream byte 0x100)
 494   var stream/esi: (addr stream byte) <- address stream-storage
 495   write stream, text
 496   var x/eax: int <- copy _x
 497   var y/ecx: int <- copy _y
 498   x, y <- draw-stream-wrapping-down-then-right screen, stream, xmin, ymin, xmax, ymax, x, y, color, background-color
 499   return x, y
 500 }
 501
 502 # draw a stream down and right in the rectangle from (xmin, ymin) to (xmax, ymax), starting from (x, y), wrapping as necessary
 503 # return the next (x, y) coordinate in raster order where drawing stopped
 504 # that way the caller can draw more if given the same min and max bounding-box.
 505 # if there isn't enough space, truncate
 506 # TODO: should we track horizontal width? just always offset by 2 for now
 507 fn draw-stream-wrapping-down-then-right 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 {
 508   var xcurr/edx: int <- copy x
 509   var ycurr/ecx: int <- copy y
 510   {
 511     var g/eax: code-point-utf8 <- read-code-point-utf8 stream
 512     compare g, 0xffffffff/end-of-file
 513     break-if-=
 514     var c/eax: code-point <- to-code-point g
 515     var offset/eax: int <- draw-code-point screen, c, xcurr, ycurr, color, background-color
 516     ycurr <- increment
 517     compare ycurr, ymax
 518     {
 519       break-if-<
 520       xcurr <- add 2
 521       ycurr <- copy ymin
 522     }
 523     loop
 524   }
 525   set-cursor-position screen, xcurr, ycurr
 526   return xcurr, ycurr
 527 }
 528
 529 fn draw-text-wrapping-down-then-right-over-full-screen screen: (addr screen), text: (addr array byte), x: int, y: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
 530   var x2/eax: int <- copy 0
 531   var y2/ecx: int <- copy 0
 532   x2, y2 <- screen-size screen  # width, height
 533   x2, y2 <- draw-text-wrapping-down-then-right screen, text, 0/xmin, 0/ymin, x2, y2, x, y, color, background-color
 534   return x2, y2  # cursor-x, cursor-y
 535 }
 536
 537 fn draw-text-wrapping-down-then-right-from-cursor screen: (addr screen), text: (addr array byte), xmin: int, ymin: int, xmax: int, ymax: int, color: int, background-color: int {
 538   var cursor-x/eax: int <- copy 0
 539   var cursor-y/ecx: int <- copy 0
 540   cursor-x, cursor-y <- cursor-position screen
 541   var end-y/edx: int <- copy cursor-y
 542   end-y <- increment
 543   compare end-y, ymax
 544   {
 545     break-if-<
 546     cursor-x <- increment
 547     cursor-y <- copy ymin
 548   }
 549   cursor-x, cursor-y <- draw-text-wrapping-down-then-right screen, text, xmin, ymin, xmax, ymax, cursor-x, cursor-y, color, background-color
 550 }
 551
 552 fn draw-text-wrapping-down-then-right-from-cursor-over-full-screen screen: (addr screen), text: (addr array byte), color: int, background-color: int {
 553   var width/eax: int <- copy 0
 554   var height/ecx: int <- copy 0
 555   width, height <- screen-size screen
 556   draw-text-wrapping-down-then-right-from-cursor screen, text, 0/xmin, 0/ymin, width, height, color, background-color
 557 }