# Mu - shell/gap-buffer.mu

https://github.com/akkartik/mu/blob/main/shell/gap-buffer.mu

       1 # primitive for editing text
       2
       3 type gap-buffer {
       4   left: grapheme-stack
       5   right: grapheme-stack
       6   # some fields for scanning incrementally through a gap-buffer
       7   left-read-index: int
       8   right-read-index: int
       9 }
      10
      11 fn initialize-gap-buffer _self: (addr gap-buffer), capacity: int {
      12   var self/esi: (addr gap-buffer) <- copy _self
      13   var left/eax: (addr grapheme-stack) <- get self, left
      14   initialize-grapheme-stack left, capacity
      15   var right/eax: (addr grapheme-stack) <- get self, right
      16   initialize-grapheme-stack right, capacity
      17 }
      18
      19 fn clear-gap-buffer _self: (addr gap-buffer) {
      20   var self/esi: (addr gap-buffer) <- copy _self
      21   var left/eax: (addr grapheme-stack) <- get self, left
      22   clear-grapheme-stack left
      23   var right/eax: (addr grapheme-stack) <- get self, right
      24   clear-grapheme-stack right
      25 }
      26
      27 fn gap-buffer-capacity _gap: (addr gap-buffer) -> _/ecx: int {
      28   var gap/esi: (addr gap-buffer) <- copy _gap
      29   var left/eax: (addr grapheme-stack) <- get gap, left
      30   var left-data-ah/eax: (addr handle array grapheme) <- get left, data
      31   var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
      32   var result/eax: int <- length left-data
      33   return result
      34 }
      35
      36 # just for tests
      37 fn initialize-gap-buffer-with self: (addr gap-buffer), s: (addr array byte) {
      38   initialize-gap-buffer self, 0x10/capacity
      39   var stream-storage: (stream byte 0x10/capacity)
      40   var stream/ecx: (addr stream byte) <- address stream-storage
      41   write stream, s
      42   {
      43     var done?/eax: boolean <- stream-empty? stream
      44     compare done?, 0/false
      45     break-if-!=
      46     var g/eax: grapheme <- read-grapheme stream
      47     add-grapheme-at-gap self, g
      48     loop
      49   }
      50 }
      51
      52 fn load-gap-buffer-from-stream self: (addr gap-buffer), in: (addr stream byte) {
      53   rewind-stream in
      54   {
      55     var done?/eax: boolean <- stream-empty? in
      56     compare done?, 0/false
      57     break-if-!=
      58     var key/eax: byte <- read-byte in
      59     compare key, 0/null
      60     break-if-=
      61     var g/eax: grapheme <- copy key
      62     edit-gap-buffer self, g
      63     loop
      64   }
      65 }
      66
      67 fn emit-gap-buffer _self: (addr gap-buffer), out: (addr stream byte) {
      68   var self/esi: (addr gap-buffer) <- copy _self
      69   clear-stream out
      70   var left/eax: (addr grapheme-stack) <- get self, left
      71   emit-stack-from-bottom left, out
      72   var right/eax: (addr grapheme-stack) <- get self, right
      73   emit-stack-from-top right, out
      74 }
      75
      76 fn append-gap-buffer _self: (addr gap-buffer), out: (addr stream byte) {
      77   var self/esi: (addr gap-buffer) <- copy _self
      78   var left/eax: (addr grapheme-stack) <- get self, left
      79   emit-stack-from-bottom left, out
      80   var right/eax: (addr grapheme-stack) <- get self, right
      81   emit-stack-from-top right, out
      82 }
      83
      84 # dump stack from bottom to top
      85 fn emit-stack-from-bottom _self: (addr grapheme-stack), out: (addr stream byte) {
      86   var self/esi: (addr grapheme-stack) <- copy _self
      87   var data-ah/edi: (addr handle array grapheme) <- get self, data
      88   var _data/eax: (addr array grapheme) <- lookup *data-ah
      89   var data/edi: (addr array grapheme) <- copy _data
      90   var top-addr/ecx: (addr int) <- get self, top
      91   var i/eax: int <- copy 0
      92   {
      93     compare i, *top-addr
      94     break-if->=
      95     var g/edx: (addr grapheme) <- index data, i
      96     write-grapheme out, *g
      97     i <- increment
      98     loop
      99   }
     100 }
     101
     102 # dump stack from top to bottom
     103 fn emit-stack-from-top _self: (addr grapheme-stack), out: (addr stream byte) {
     104   var self/esi: (addr grapheme-stack) <- copy _self
     105   var data-ah/edi: (addr handle array grapheme) <- get self, data
     106   var _data/eax: (addr array grapheme) <- lookup *data-ah
     107   var data/edi: (addr array grapheme) <- copy _data
     108   var top-addr/ecx: (addr int) <- get self, top
     109   var i/eax: int <- copy *top-addr
     110   i <- decrement
     111   {
     112     compare i, 0
     113     break-if-<
     114     var g/edx: (addr grapheme) <- index data, i
     115     write-grapheme out, *g
     116     i <- decrement
     117     loop
     118   }
     119 }
     120
     121 # We implicitly render everything editable in a single color, and assume the
     122 # cursor is a single other color.
     123 fn render-gap-buffer-wrapping-right-then-down screen: (addr screen), _gap: (addr gap-buffer), xmin: int, ymin: int, xmax: int, ymax: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int {
     124   var gap/esi: (addr gap-buffer) <- copy _gap
     125   var left/edx: (addr grapheme-stack) <- get gap, left
     126   var highlight-matching-open-paren?/ebx: boolean <- copy 0/false
     127   var matching-open-paren-depth/edi: int <- copy 0
     128   highlight-matching-open-paren?, matching-open-paren-depth <- highlight-matching-open-paren? gap, render-cursor?
     129   var x2/eax: int <- copy 0
     130   var y2/ecx: int <- copy 0
     131   x2, y2 <- render-stack-from-bottom-wrapping-right-then-down screen, left, xmin, ymin, xmax, ymax, xmin, ymin, highlight-matching-open-paren?, matching-open-paren-depth, color, background-color
     132   var right/edx: (addr grapheme-stack) <- get gap, right
     133   x2, y2 <- render-stack-from-top-wrapping-right-then-down screen, right, xmin, ymin, xmax, ymax, x2, y2, render-cursor?, color, background-color
     134   # decide whether we still need to print a cursor
     135   var bg/ebx: int <- copy background-color
     136   compare render-cursor?, 0/false
     137   {
     138     break-if-=
     139     # if the right side is empty, grapheme stack didn't print the cursor
     140     var empty?/eax: boolean <- grapheme-stack-empty? right
     141     compare empty?, 0/false
     142     break-if-=
     143     bg <- copy 7/cursor
     144   }
     145   # print a grapheme either way so that cursor position doesn't affect printed width
     146   var space/edx: grapheme <- copy 0x20
     147   x2, y2 <- render-grapheme screen, space, xmin, ymin, xmax, ymax, x2, y2, color, bg
     148   return x2, y2
     149 }
     150
     151 fn render-gap-buffer screen: (addr screen), gap: (addr gap-buffer), x: int, y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int {
     152   var _width/eax: int <- copy 0
     153   var _height/ecx: int <- copy 0
     154   _width, _height <- screen-size screen
     155   var width/edx: int <- copy _width
     156   var height/ebx: int <- copy _height
     157   var x2/eax: int <- copy 0
     158   var y2/ecx: int <- copy 0
     159   x2, y2 <- render-gap-buffer-wrapping-right-then-down screen, gap, x, y, width, height, render-cursor?, color, background-color
     160   return x2  # y2? yolo
     161 }
     162
     163 fn gap-buffer-length _gap: (addr gap-buffer) -> _/eax: int {
     164   var gap/esi: (addr gap-buffer) <- copy _gap
     165   var left/eax: (addr grapheme-stack) <- get gap, left
     166   var tmp/eax: (addr int) <- get left, top
     167   var left-length/ecx: int <- copy *tmp
     168   var right/esi: (addr grapheme-stack) <- get gap, right
     169   tmp <- get right, top
     170   var result/eax: int <- copy *tmp
     171   result <- add left-length
     172   return result
     173 }
     174
     175 fn add-grapheme-at-gap _self: (addr gap-buffer), g: grapheme {
     176   var self/esi: (addr gap-buffer) <- copy _self
     177   var left/eax: (addr grapheme-stack) <- get self, left
     178   push-grapheme-stack left, g
     179 }
     180
     181 fn add-code-point-at-gap self: (addr gap-buffer), c: code-point {
     182   var g/eax: grapheme <- copy c
     183   add-grapheme-at-gap self, g
     184 }
     185
     186 fn gap-to-start self: (addr gap-buffer) {
     187   {
     188     var curr/eax: grapheme <- gap-left self
     189     compare curr, -1
     190     loop-if-!=
     191   }
     192 }
     193
     194 fn gap-to-end self: (addr gap-buffer) {
     195   {
     196     var curr/eax: grapheme <- gap-right self
     197     compare curr, -1
     198     loop-if-!=
     199   }
     200 }
     201
     202 fn gap-at-start? _self: (addr gap-buffer) -> _/eax: boolean {
     203   var self/esi: (addr gap-buffer) <- copy _self
     204   var left/eax: (addr grapheme-stack) <- get self, left
     205   var result/eax: boolean <- grapheme-stack-empty? left
     206   return result
     207 }
     208
     209 fn gap-at-end? _self: (addr gap-buffer) -> _/eax: boolean {
     210   var self/esi: (addr gap-buffer) <- copy _self
     211   var right/eax: (addr grapheme-stack) <- get self, right
     212   var result/eax: boolean <- grapheme-stack-empty? right
     213   return result
     214 }
     215
     216 fn gap-right _self: (addr gap-buffer) -> _/eax: grapheme {
     217   var self/esi: (addr gap-buffer) <- copy _self
     218   var g/eax: grapheme <- copy 0
     219   var right/ecx: (addr grapheme-stack) <- get self, right
     220   g <- pop-grapheme-stack right
     221   compare g, -1
     222   {
     223     break-if-=
     224     var left/ecx: (addr grapheme-stack) <- get self, left
     225     push-grapheme-stack left, g
     226   }
     227   return g
     228 }
     229
     230 fn gap-left _self: (addr gap-buffer) -> _/eax: grapheme {
     231   var self/esi: (addr gap-buffer) <- copy _self
     232   var g/eax: grapheme <- copy 0
     233   {
     234     var left/ecx: (addr grapheme-stack) <- get self, left
     235     g <- pop-grapheme-stack left
     236   }
     237   compare g, -1
     238   {
     239     break-if-=
     240     var right/ecx: (addr grapheme-stack) <- get self, right
     241     push-grapheme-stack right, g
     242   }
     243   return g
     244 }
     245
     246 fn index-of-gap _self: (addr gap-buffer) -> _/eax: int {
     247   var self/eax: (addr gap-buffer) <- copy _self
     248   var left/eax: (addr grapheme-stack) <- get self, left
     249   var top-addr/eax: (addr int) <- get left, top
     250   var result/eax: int <- copy *top-addr
     251   return result
     252 }
     253
     254 fn first-grapheme-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
     255   var self/esi: (addr gap-buffer) <- copy _self
     256   # try to read from left
     257   var left/eax: (addr grapheme-stack) <- get self, left
     258   var top-addr/ecx: (addr int) <- get left, top
     259   compare *top-addr, 0
     260   {
     261     break-if-<=
     262     var data-ah/eax: (addr handle array grapheme) <- get left, data
     263     var data/eax: (addr array grapheme) <- lookup *data-ah
     264     var result-addr/eax: (addr grapheme) <- index data, 0
     265     return *result-addr
     266   }
     267   # try to read from right
     268   var right/eax: (addr grapheme-stack) <- get self, right
     269   top-addr <- get right, top
     270   compare *top-addr, 0
     271   {
     272     break-if-<=
     273     var data-ah/eax: (addr handle array grapheme) <- get right, data
     274     var data/eax: (addr array grapheme) <- lookup *data-ah
     275     var top/ecx: int <- copy *top-addr
     276     top <- decrement
     277     var result-addr/eax: (addr grapheme) <- index data, top
     278     return *result-addr
     279   }
     280   # give up
     281   return -1
     282 }
     283
     284 fn grapheme-before-cursor-in-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
     285   var self/esi: (addr gap-buffer) <- copy _self
     286   # try to read from left
     287   var left/ecx: (addr grapheme-stack) <- get self, left
     288   var top-addr/edx: (addr int) <- get left, top
     289   compare *top-addr, 0
     290   {
     291     break-if-<=
     292     var result/eax: grapheme <- pop-grapheme-stack left
     293     push-grapheme-stack left, result
     294     return result
     295   }
     296   # give up
     297   return -1
     298 }
     299
     300 fn delete-before-gap _self: (addr gap-buffer) {
     301   var self/eax: (addr gap-buffer) <- copy _self
     302   var left/eax: (addr grapheme-stack) <- get self, left
     303   var dummy/eax: grapheme <- pop-grapheme-stack left
     304 }
     305
     306 fn pop-after-gap _self: (addr gap-buffer) -> _/eax: grapheme {
     307   var self/eax: (addr gap-buffer) <- copy _self
     308   var right/eax: (addr grapheme-stack) <- get self, right
     309   var result/eax: grapheme <- pop-grapheme-stack right
     310   return result
     311 }
     312
     313 fn gap-buffer-equal? _self: (addr gap-buffer), s: (addr array byte) -> _/eax: boolean {
     314   var self/esi: (addr gap-buffer) <- copy _self
     315   # complication: graphemes may be multiple bytes
     316   # so don't rely on length
     317   # instead turn the expected result into a stream and arrange to read from it in order
     318   var stream-storage: (stream byte 0x10/capacity)
     319   var expected-stream/ecx: (addr stream byte) <- address stream-storage
     320   write expected-stream, s
     321   # compare left
     322   var left/edx: (addr grapheme-stack) <- get self, left
     323   var result/eax: boolean <- prefix-match? left, expected-stream
     324   compare result, 0/false
     325   {
     326     break-if-!=
     327     return result
     328   }
     329   # compare right
     330   var right/edx: (addr grapheme-stack) <- get self, right
     331   result <- suffix-match? right, expected-stream
     332   compare result, 0/false
     333   {
     334     break-if-!=
     335     return result
     336   }
     337   # ensure there's nothing left over
     338   result <- stream-empty? expected-stream
     339   return result
     340 }
     341
     342 fn test-gap-buffer-equal-from-end {
     343   var _g: gap-buffer
     344   var g/esi: (addr gap-buffer) <- address _g
     345   initialize-gap-buffer g, 0x10
     346   #
     347   add-code-point-at-gap g, 0x61/a
     348   add-code-point-at-gap g, 0x61/a
     349   add-code-point-at-gap g, 0x61/a
     350   # gap is at end (right is empty)
     351   var result/eax: boolean <- gap-buffer-equal? g, "aaa"
     352   check result, "F - test-gap-buffer-equal-from-end"
     353 }
     354
     355 fn test-gap-buffer-equal-from-middle {
     356   var _g: gap-buffer
     357   var g/esi: (addr gap-buffer) <- address _g
     358   initialize-gap-buffer g, 0x10
     359   #
     360   add-code-point-at-gap g, 0x61/a
     361   add-code-point-at-gap g, 0x61/a
     362   add-code-point-at-gap g, 0x61/a
     363   var dummy/eax: grapheme <- gap-left g
     364   # gap is in the middle
     365   var result/eax: boolean <- gap-buffer-equal? g, "aaa"
     366   check result, "F - test-gap-buffer-equal-from-middle"
     367 }
     368
     369 fn test-gap-buffer-equal-from-start {
     370   var _g: gap-buffer
     371   var g/esi: (addr gap-buffer) <- address _g
     372   initialize-gap-buffer g, 0x10
     373   #
     374   add-code-point-at-gap g, 0x61/a
     375   add-code-point-at-gap g, 0x61/a
     376   add-code-point-at-gap g, 0x61/a
     377   var dummy/eax: grapheme <- gap-left g
     378   dummy <- gap-left g
     379   dummy <- gap-left g
     380   # gap is at the start
     381   var result/eax: boolean <- gap-buffer-equal? g, "aaa"
     382   check result, "F - test-gap-buffer-equal-from-start"
     383 }
     384
     385 fn test-gap-buffer-equal-fails {
     386   # g = "aaa"
     387   var _g: gap-buffer
     388   var g/esi: (addr gap-buffer) <- address _g
     389   initialize-gap-buffer g, 0x10
     390   add-code-point-at-gap g, 0x61/a
     391   add-code-point-at-gap g, 0x61/a
     392   add-code-point-at-gap g, 0x61/a
     393   #
     394   var result/eax: boolean <- gap-buffer-equal? g, "aa"
     395   check-not result, "F - test-gap-buffer-equal-fails"
     396 }
     397
     398 fn gap-buffers-equal? self: (addr gap-buffer), g: (addr gap-buffer) -> _/eax: boolean {
     399   var tmp/eax: int <- gap-buffer-length self
     400   var len/ecx: int <- copy tmp
     401   var leng/eax: int <- gap-buffer-length g
     402   compare len, leng
     403   {
     404     break-if-=
     405     return 0/false
     406   }
     407   var i/edx: int <- copy 0
     408   {
     409     compare i, len
     410     break-if->=
     411     {
     412       var tmp/eax: grapheme <- gap-index self, i
     413       var curr/ecx: grapheme <- copy tmp
     414       var currg/eax: grapheme <- gap-index g, i
     415       compare curr, currg
     416       break-if-=
     417       return 0/false
     418     }
     419     i <- increment
     420     loop
     421   }
     422   return 1/true
     423 }
     424
     425 fn gap-index _self: (addr gap-buffer), _n: int -> _/eax: grapheme {
     426   var self/esi: (addr gap-buffer) <- copy _self
     427   var n/ebx: int <- copy _n
     428   # if n < left->length, index into left
     429   var left/edi: (addr grapheme-stack) <- get self, left
     430   var left-len-a/edx: (addr int) <- get left, top
     431   compare n, *left-len-a
     432   {
     433     break-if->=
     434     var data-ah/eax: (addr handle array grapheme) <- get left, data
     435     var data/eax: (addr array grapheme) <- lookup *data-ah
     436     var result/eax: (addr grapheme) <- index data, n
     437     return *result
     438   }
     439   # shrink n
     440   n <- subtract *left-len-a
     441   # if n < right->length, index into right
     442   var right/edi: (addr grapheme-stack) <- get self, right
     443   var right-len-a/edx: (addr int) <- get right, top
     444   compare n, *right-len-a
     445   {
     446     break-if->=
     447     var data-ah/eax: (addr handle array grapheme) <- get right, data
     448     var data/eax: (addr array grapheme) <- lookup *data-ah
     449     # idx = right->len - n - 1
     450     var idx/ebx: int <- copy n
     451     idx <- subtract *right-len-a
     452     idx <- negate
     453     idx <- subtract 1
     454     var result/eax: (addr grapheme) <- index data, idx
     455     return *result
     456   }
     457   # error
     458   abort "gap-index: out of bounds"
     459   return 0
     460 }
     461
     462 fn test-gap-buffers-equal? {
     463   var _a: gap-buffer
     464   var a/esi: (addr gap-buffer) <- address _a
     465   initialize-gap-buffer-with a, "abc"
     466   var _b: gap-buffer
     467   var b/edi: (addr gap-buffer) <- address _b
     468   initialize-gap-buffer-with b, "abc"
     469   var _c: gap-buffer
     470   var c/ebx: (addr gap-buffer) <- address _c
     471   initialize-gap-buffer-with c, "ab"
     472   var _d: gap-buffer
     473   var d/edx: (addr gap-buffer) <- address _d
     474   initialize-gap-buffer-with d, "abd"
     475   #
     476   var result/eax: boolean <- gap-buffers-equal? a, a
     477   check result, "F - test-gap-buffers-equal? - reflexive"
     478   result <- gap-buffers-equal? a, b
     479   check result, "F - test-gap-buffers-equal? - equal"
     480   # length not equal
     481   result <- gap-buffers-equal? a, c
     482   check-not result, "F - test-gap-buffers-equal? - not equal"
     483   # contents not equal
     484   result <- gap-buffers-equal? a, d
     485   check-not result, "F - test-gap-buffers-equal? - not equal 2"
     486   result <- gap-buffers-equal? d, a
     487   check-not result, "F - test-gap-buffers-equal? - not equal 3"
     488 }
     489
     490 fn test-gap-buffer-index {
     491   var gap-storage: gap-buffer
     492   var gap/esi: (addr gap-buffer) <- address gap-storage
     493   initialize-gap-buffer-with gap, "abc"
     494   # gap is at end, all contents are in left
     495   var g/eax: grapheme <- gap-index gap, 0
     496   var x/ecx: int <- copy g
     497   check-ints-equal x, 0x61/a, "F - test-gap-index/left-1"
     498   var g/eax: grapheme <- gap-index gap, 1
     499   var x/ecx: int <- copy g
     500   check-ints-equal x, 0x62/b, "F - test-gap-index/left-2"
     501   var g/eax: grapheme <- gap-index gap, 2
     502   var x/ecx: int <- copy g
     503   check-ints-equal x, 0x63/c, "F - test-gap-index/left-3"
     504   # now check when everything is to the right
     505   gap-to-start gap
     506   rewind-gap-buffer gap
     507   var g/eax: grapheme <- gap-index gap, 0
     508   var x/ecx: int <- copy g
     509   check-ints-equal x, 0x61/a, "F - test-gap-index/right-1"
     510   var g/eax: grapheme <- gap-index gap, 1
     511   var x/ecx: int <- copy g
     512   check-ints-equal x, 0x62/b, "F - test-gap-index/right-2"
     513   var g/eax: grapheme <- gap-index gap, 2
     514   var x/ecx: int <- copy g
     515   check-ints-equal x, 0x63/c, "F - test-gap-index/right-3"
     516 }
     517
     518 fn copy-gap-buffer _src-ah: (addr handle gap-buffer), _dest-ah: (addr handle gap-buffer) {
     519   # obtain src-a, dest-a
     520   var src-ah/eax: (addr handle gap-buffer) <- copy _src-ah
     521   var _src-a/eax: (addr gap-buffer) <- lookup *src-ah
     522   var src-a/esi: (addr gap-buffer) <- copy _src-a
     523   var dest-ah/eax: (addr handle gap-buffer) <- copy _dest-ah
     524   var _dest-a/eax: (addr gap-buffer) <- lookup *dest-ah
     525   var dest-a/edi: (addr gap-buffer) <- copy _dest-a
     526   # copy left grapheme-stack
     527   var src/ecx: (addr grapheme-stack) <- get src-a, left
     528   var dest/edx: (addr grapheme-stack) <- get dest-a, left
     529   copy-grapheme-stack src, dest
     530   # copy right grapheme-stack
     531   src <- get src-a, right
     532   dest <- get dest-a, right
     533   copy-grapheme-stack src, dest
     534 }
     535
     536 fn gap-buffer-is-decimal-integer? _self: (addr gap-buffer) -> _/eax: boolean {
     537   var self/esi: (addr gap-buffer) <- copy _self
     538   var curr/ecx: (addr grapheme-stack) <- get self, left
     539   var result/eax: boolean <- grapheme-stack-is-decimal-integer? curr
     540   {
     541     compare result, 0/false
     542     break-if-=
     543     curr <- get self, right
     544     result <- grapheme-stack-is-decimal-integer? curr
     545   }
     546   return result
     547 }
     548
     549 fn test-render-gap-buffer-without-cursor {
     550   # setup
     551   var gap-storage: gap-buffer
     552   var gap/esi: (addr gap-buffer) <- address gap-storage
     553   initialize-gap-buffer-with gap, "abc"
     554   # setup: screen
     555   var screen-on-stack: screen
     556   var screen/edi: (addr screen) <- address screen-on-stack
     557   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     558   #
     559   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 0/no-cursor, 3/fg, 0xc5/bg=blue-bg
     560   check-screen-row screen, 0/y, "abc ", "F - test-render-gap-buffer-without-cursor"
     561   check-ints-equal x, 4, "F - test-render-gap-buffer-without-cursor: result"
     562                                                                 # abc
     563   check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, "    ", "F - test-render-gap-buffer-without-cursor: bg"
     564 }
     565
     566 fn test-render-gap-buffer-with-cursor-at-end {
     567   # setup
     568   var gap-storage: gap-buffer
     569   var gap/esi: (addr gap-buffer) <- address gap-storage
     570   initialize-gap-buffer-with gap, "abc"
     571   gap-to-end gap
     572   # setup: screen
     573   var screen-on-stack: screen
     574   var screen/edi: (addr screen) <- address screen-on-stack
     575   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     576   #
     577   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     578   check-screen-row screen, 0/y, "abc ", "F - test-render-gap-buffer-with-cursor-at-end"
     579   # we've drawn one extra grapheme for the cursor
     580   check-ints-equal x, 4, "F - test-render-gap-buffer-with-cursor-at-end: result"
     581                                                                 # abc
     582   check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, "   |", "F - test-render-gap-buffer-with-cursor-at-end: bg"
     583 }
     584
     585 fn test-render-gap-buffer-with-cursor-in-middle {
     586   # setup
     587   var gap-storage: gap-buffer
     588   var gap/esi: (addr gap-buffer) <- address gap-storage
     589   initialize-gap-buffer-with gap, "abc"
     590   gap-to-end gap
     591   var dummy/eax: grapheme <- gap-left gap
     592   # setup: screen
     593   var screen-on-stack: screen
     594   var screen/edi: (addr screen) <- address screen-on-stack
     595   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     596   #
     597   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     598   check-screen-row screen, 0/y, "abc ", "F - test-render-gap-buffer-with-cursor-in-middle"
     599   check-ints-equal x, 4, "F - test-render-gap-buffer-with-cursor-in-middle: result"
     600                                                                 # abc
     601   check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, "  | ", "F - test-render-gap-buffer-with-cursor-in-middle: bg"
     602 }
     603
     604 fn test-render-gap-buffer-with-cursor-at-start {
     605   var gap-storage: gap-buffer
     606   var gap/esi: (addr gap-buffer) <- address gap-storage
     607   initialize-gap-buffer-with gap, "abc"
     608   gap-to-start gap
     609   # setup: screen
     610   var screen-on-stack: screen
     611   var screen/edi: (addr screen) <- address screen-on-stack
     612   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     613   #
     614   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     615   check-screen-row screen, 0/y, "abc ", "F - test-render-gap-buffer-with-cursor-at-start"
     616   check-ints-equal x, 4, "F - test-render-gap-buffer-with-cursor-at-start: result"
     617                                                                 # abc
     618   check-background-color-in-screen-row screen, 7/bg=cursor, 0/y, "|   ", "F - test-render-gap-buffer-with-cursor-at-start: bg"
     619 }
     620
     621 fn test-render-gap-buffer-highlight-matching-close-paren {
     622   var gap-storage: gap-buffer
     623   var gap/esi: (addr gap-buffer) <- address gap-storage
     624   initialize-gap-buffer-with gap, "(a)"
     625   gap-to-start gap
     626   # setup: screen
     627   var screen-on-stack: screen
     628   var screen/edi: (addr screen) <- address screen-on-stack
     629   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     630   #
     631   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     632   check-screen-row                     screen, 0/y,                   "(a) ", "F - test-render-gap-buffer-highlight-matching-close-paren"
     633   check-ints-equal x, 4, "F - test-render-gap-buffer-highlight-matching-close-paren: result"
     634   check-background-color-in-screen-row screen, 7/bg=cursor,      0/y, "|   ", "F - test-render-gap-buffer-highlight-matching-close-paren: cursor"
     635   check-screen-row-in-color            screen, 0xf/fg=highlight, 0/y, "  ) ", "F - test-render-gap-buffer-highlight-matching-close-paren: matching paren"
     636 }
     637
     638 fn test-render-gap-buffer-highlight-matching-open-paren {
     639   var gap-storage: gap-buffer
     640   var gap/esi: (addr gap-buffer) <- address gap-storage
     641   initialize-gap-buffer-with gap, "(a)"
     642   gap-to-end gap
     643   var dummy/eax: grapheme <- gap-left gap
     644   # setup: screen
     645   var screen-on-stack: screen
     646   var screen/edi: (addr screen) <- address screen-on-stack
     647   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     648   #
     649   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     650   check-screen-row                     screen, 0/y,                   "(a) ", "F - test-render-gap-buffer-highlight-matching-open-paren"
     651   check-ints-equal x, 4, "F - test-render-gap-buffer-highlight-matching-open-paren: result"
     652   check-background-color-in-screen-row screen, 7/bg=cursor,      0/y, "  | ", "F - test-render-gap-buffer-highlight-matching-open-paren: cursor"
     653   check-screen-row-in-color            screen, 0xf/fg=highlight, 0/y, "(   ", "F - test-render-gap-buffer-highlight-matching-open-paren: matching paren"
     654 }
     655
     656 fn test-render-gap-buffer-highlight-matching-open-paren-of-end {
     657   var gap-storage: gap-buffer
     658   var gap/esi: (addr gap-buffer) <- address gap-storage
     659   initialize-gap-buffer-with gap, "(a)"
     660   gap-to-end gap
     661   # setup: screen
     662   var screen-on-stack: screen
     663   var screen/edi: (addr screen) <- address screen-on-stack
     664   initialize-screen screen, 5, 4, 0/no-pixel-graphics
     665   #
     666   var x/eax: int <- render-gap-buffer screen, gap, 0/x, 0/y, 1/show-cursor, 3/fg, 0xc5/bg=blue-bg
     667   check-screen-row                     screen, 0/y,                   "(a) ", "F - test-render-gap-buffer-highlight-matching-open-paren-of-end"
     668   check-ints-equal x, 4, "F - test-render-gap-buffer-highlight-matching-open-paren-of-end: result"
     669   check-background-color-in-screen-row screen, 7/bg=cursor,      0/y, "   |", "F - test-render-gap-buffer-highlight-matching-open-paren-of-end: cursor"
     670   check-screen-row-in-color            screen, 0xf/fg=highlight, 0/y, "(   ", "F - test-render-gap-buffer-highlight-matching-open-paren-of-end: matching paren"
     671 }
     672
     673 # should I highlight a matching open paren? And if so, at what depth from top of left?
     674 # basically there are two cases to disambiguate here:
     675 #   Usually the cursor is at top of right. Highlight first '(' at depth 0 from top of left.
     676 #   If right is empty, match the ')' _before_ cursor. Highlight first '(' at depth _1_ from top of left.
     677 fn highlight-matching-open-paren? _gap: (addr gap-buffer), render-cursor?: boolean -> _/ebx: boolean, _/edi: int {
     678   # if not rendering cursor, return
     679   compare render-cursor?, 0/false
     680   {
     681     break-if-!=
     682     return 0/false, 0
     683   }
     684   var gap/esi: (addr gap-buffer) <- copy _gap
     685   var stack/edi: (addr grapheme-stack) <- get gap, right
     686   var top-addr/eax: (addr int) <- get stack, top
     687   var top-index/ecx: int <- copy *top-addr
     688   compare top-index, 0
     689   {
     690     break-if->
     691     # if cursor at end, return (char before cursor == ')', 1)
     692     stack <- get gap, left
     693     top-addr <- get stack, top
     694     top-index <- copy *top-addr
     695     compare top-index, 0
     696     {
     697       break-if->
     698       return 0/false, 0
     699     }
     700     top-index <- decrement
     701     var data-ah/eax: (addr handle array grapheme) <- get stack, data
     702     var data/eax: (addr array grapheme) <- lookup *data-ah
     703     var g/eax: (addr grapheme) <- index data, top-index
     704     compare *g, 0x29/close-paren
     705     {
     706       break-if-=
     707       return 0/false, 0
     708     }
     709     return 1/true, 1
     710   }
     711   # cursor is not at end; return (char at cursor == ')')
     712   top-index <- decrement
     713   var data-ah/eax: (addr handle array grapheme) <- get stack, data
     714   var data/eax: (addr array grapheme) <- lookup *data-ah
     715   var g/eax: (addr grapheme) <- index data, top-index
     716   compare *g, 0x29/close-paren
     717   {
     718     break-if-=
     719     return 0/false, 0
     720   }
     721   return 1/true, 0
     722 }
     723
     724 fn test-highlight-matching-open-paren {
     725   var gap-storage: gap-buffer
     726   var gap/esi: (addr gap-buffer) <- address gap-storage
     727   initialize-gap-buffer-with gap, "(a)"
     728   gap-to-end gap
     729   var highlight-matching-open-paren?/ebx: boolean <- copy 0/false
     730   var open-paren-depth/edi: int <- copy 0
     731   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 0/no-cursor
     732   check-not highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: no cursor"
     733   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 1/render-cursor
     734   check highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: at end immediately after ')'"
     735   check-ints-equal open-paren-depth, 1, "F - test-highlight-matching-open-paren: depth at end immediately after ')'"
     736   var dummy/eax: grapheme <- gap-left gap
     737   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 1/render-cursor
     738   check highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: on ')'"
     739   dummy <- gap-left gap
     740   highlight-matching-open-paren?, open-paren-depth <- highlight-matching-open-paren? gap, 1/render-cursor
     741   check-not highlight-matching-open-paren?, "F - test-highlight-matching-open-paren: not on ')'"
     742 }
     743
     744 ## some primitives for scanning through a gap buffer
     745 # don't modify the gap buffer while scanning
     746 # this includes moving the cursor around
     747
     748 # restart scan without affecting gap-buffer contents
     749 fn rewind-gap-buffer _self: (addr gap-buffer) {
     750   var self/esi: (addr gap-buffer) <- copy _self
     751   var dest/eax: (addr int) <- get self, left-read-index
     752   copy-to *dest, 0
     753   dest <- get self, right-read-index
     754   copy-to *dest, 0
     755 }
     756
     757 fn gap-buffer-scan-done? _self: (addr gap-buffer) -> _/eax: boolean {
     758   var self/esi: (addr gap-buffer) <- copy _self
     759   # more in left?
     760   var left/eax: (addr grapheme-stack) <- get self, left
     761   var left-size/eax: int <- grapheme-stack-length left
     762   var left-read-index/ecx: (addr int) <- get self, left-read-index
     763   compare *left-read-index, left-size
     764   {
     765     break-if->=
     766     return 0/false
     767   }
     768   # more in right?
     769   var right/eax: (addr grapheme-stack) <- get self, right
     770   var right-size/eax: int <- grapheme-stack-length right
     771   var right-read-index/ecx: (addr int) <- get self, right-read-index
     772   compare *right-read-index, right-size
     773   {
     774     break-if->=
     775     return 0/false
     776   }
     777   #
     778   return 1/true
     779 }
     780
     781 fn peek-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
     782   var self/esi: (addr gap-buffer) <- copy _self
     783   # more in left?
     784   var left/ecx: (addr grapheme-stack) <- get self, left
     785   var left-size/eax: int <- grapheme-stack-length left
     786   var left-read-index-a/edx: (addr int) <- get self, left-read-index
     787   compare *left-read-index-a, left-size
     788   {
     789     break-if->=
     790     var left-data-ah/eax: (addr handle array grapheme) <- get left, data
     791     var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
     792     var left-read-index/ecx: int <- copy *left-read-index-a
     793     var result/eax: (addr grapheme) <- index left-data, left-read-index
     794     return *result
     795   }
     796   # more in right?
     797   var right/ecx: (addr grapheme-stack) <- get self, right
     798   var _right-size/eax: int <- grapheme-stack-length right
     799   var right-size/ebx: int <- copy _right-size
     800   var right-read-index-a/edx: (addr int) <- get self, right-read-index
     801   compare *right-read-index-a, right-size
     802   {
     803     break-if->=
     804     # read the right from reverse
     805     var right-data-ah/eax: (addr handle array grapheme) <- get right, data
     806     var right-data/eax: (addr array grapheme) <- lookup *right-data-ah
     807     var right-read-index/ebx: int <- copy right-size
     808     right-read-index <- subtract *right-read-index-a
     809     right-read-index <- subtract 1
     810     var result/eax: (addr grapheme) <- index right-data, right-read-index
     811     return *result
     812   }
     813   # if we get here there's nothing left
     814   return 0/nul
     815 }
     816
     817 fn read-from-gap-buffer _self: (addr gap-buffer) -> _/eax: grapheme {
     818   var self/esi: (addr gap-buffer) <- copy _self
     819   # more in left?
     820   var left/ecx: (addr grapheme-stack) <- get self, left
     821   var left-size/eax: int <- grapheme-stack-length left
     822   var left-read-index-a/edx: (addr int) <- get self, left-read-index
     823   compare *left-read-index-a, left-size
     824   {
     825     break-if->=
     826     var left-data-ah/eax: (addr handle array grapheme) <- get left, data
     827     var left-data/eax: (addr array grapheme) <- lookup *left-data-ah
     828     var left-read-index/ecx: int <- copy *left-read-index-a
     829     var result/eax: (addr grapheme) <- index left-data, left-read-index
     830     increment *left-read-index-a
     831     return *result
     832   }
     833   # more in right?
     834   var right/ecx: (addr grapheme-stack) <- get self, right
     835   var _right-size/eax: int <- grapheme-stack-length right
     836   var right-size/ebx: int <- copy _right-size
     837   var right-read-index-a/edx: (addr int) <- get self, right-read-index
     838   compare *right-read-index-a, right-size
     839   {
     840     break-if->=
     841     # read the right from reverse
     842     var right-data-ah/eax: (addr handle array grapheme) <- get right, data
     843     var right-data/eax: (addr array grapheme) <- lookup *right-data-ah
     844     var right-read-index/ebx: int <- copy right-size
     845     right-read-index <- subtract *right-read-index-a
     846     right-read-index <- subtract 1
     847     var result/eax: (addr grapheme) <- index right-data, right-read-index
     848     increment *right-read-index-a
     849     return *result
     850   }
     851   # if we get here there's nothing left
     852   return 0/nul
     853 }
     854
     855 fn test-read-from-gap-buffer {
     856   var gap-storage: gap-buffer
     857   var gap/esi: (addr gap-buffer) <- address gap-storage
     858   initialize-gap-buffer-with gap, "abc"
     859   # gap is at end, all contents are in left
     860   var done?/eax: boolean <- gap-buffer-scan-done? gap
     861   check-not done?, "F - test-read-from-gap-buffer/left-1/done"
     862   var g/eax: grapheme <- read-from-gap-buffer gap
     863   var x/ecx: int <- copy g
     864   check-ints-equal x, 0x61/a, "F - test-read-from-gap-buffer/left-1"
     865   var done?/eax: boolean <- gap-buffer-scan-done? gap
     866   check-not done?, "F - test-read-from-gap-buffer/left-2/done"
     867   var g/eax: grapheme <- read-from-gap-buffer gap
     868   var x/ecx: int <- copy g
     869   check-ints-equal x, 0x62/b, "F - test-read-from-gap-buffer/left-2"
     870   var done?/eax: boolean <- gap-buffer-scan-done? gap
     871   check-not done?, "F - test-read-from-gap-buffer/left-3/done"
     872   var g/eax: grapheme <- read-from-gap-buffer gap
     873   var x/ecx: int <- copy g
     874   check-ints-equal x, 0x63/c, "F - test-read-from-gap-buffer/left-3"
     875   var done?/eax: boolean <- gap-buffer-scan-done? gap
     876   check done?, "F - test-read-from-gap-buffer/left-4/done"
     877   var g/eax: grapheme <- read-from-gap-buffer gap
     878   var x/ecx: int <- copy g
     879   check-ints-equal x, 0/nul, "F - test-read-from-gap-buffer/left-4"
     880   # now check when everything is to the right
     881   gap-to-start gap
     882   rewind-gap-buffer gap
     883   var done?/eax: boolean <- gap-buffer-scan-done? gap
     884   check-not done?, "F - test-read-from-gap-buffer/right-1/done"
     885   var g/eax: grapheme <- read-from-gap-buffer gap
     886   var x/ecx: int <- copy g
     887   check-ints-equal x, 0x61/a, "F - test-read-from-gap-buffer/right-1"
     888   var done?/eax: boolean <- gap-buffer-scan-done? gap
     889   check-not done?, "F - test-read-from-gap-buffer/right-2/done"
     890   var g/eax: grapheme <- read-from-gap-buffer gap
     891   var x/ecx: int <- copy g
     892   check-ints-equal x, 0x62/b, "F - test-read-from-gap-buffer/right-2"
     893   var done?/eax: boolean <- gap-buffer-scan-done? gap
     894   check-not done?, "F - test-read-from-gap-buffer/right-3/done"
     895   var g/eax: grapheme <- read-from-gap-buffer gap
     896   var x/ecx: int <- copy g
     897   check-ints-equal x, 0x63/c, "F - test-read-from-gap-buffer/right-3"
     898   var done?/eax: boolean <- gap-buffer-scan-done? gap
     899   check done?, "F - test-read-from-gap-buffer/right-4/done"
     900   var g/eax: grapheme <- read-from-gap-buffer gap
     901   var x/ecx: int <- copy g
     902   check-ints-equal x, 0/nul, "F - test-read-from-gap-buffer/right-4"
     903 }
     904
     905 fn skip-whitespace-from-gap-buffer self: (addr gap-buffer) {
     906   var done?/eax: boolean <- gap-buffer-scan-done? self
     907   compare done?, 0/false
     908   break-if-!=
     909   var g/eax: grapheme <- peek-from-gap-buffer self
     910   {
     911     compare g, 0x20/space
     912     break-if-=
     913     compare g, 0xa/newline
     914     break-if-=
     915     return
     916   }
     917   g <- read-from-gap-buffer self
     918   loop
     919 }
     920
     921 fn edit-gap-buffer self: (addr gap-buffer), key: grapheme {
     922   var g/edx: grapheme <- copy key
     923   {
     924     compare g, 8/backspace
     925     break-if-!=
     926     delete-before-gap self
     927     return
     928   }
     929   {
     930     compare g, 0x80/left-arrow
     931     break-if-!=
     932     var dummy/eax: grapheme <- gap-left self
     933     return
     934   }
     935   {
     936     compare g, 0x83/right-arrow
     937     break-if-!=
     938     var dummy/eax: grapheme <- gap-right self
     939     return
     940   }
     941   {
     942     compare g, 6/ctrl-f
     943     break-if-!=
     944     gap-to-start-of-next-word self
     945     return
     946   }
     947   {
     948     compare g, 2/ctrl-b
     949     break-if-!=
     950     gap-to-end-of-previous-word self
     951     return
     952   }
     953   {
     954     compare g, 1/ctrl-a
     955     break-if-!=
     956     gap-to-previous-start-of-line self
     957     return
     958   }
     959   {
     960     compare g, 5/ctrl-e
     961     break-if-!=
     962     gap-to-next-end-of-line self
     963     return
     964   }
     965   {
     966     compare g, 0x81/down-arrow
     967     break-if-!=
     968     gap-down self
     969     return
     970   }
     971   {
     972     compare g, 0x82/up-arrow
     973     break-if-!=
     974     gap-up self
     975     return
     976   }
     977   {
     978     compare g, 0x15/ctrl-u
     979     break-if-!=
     980     clear-gap-buffer self
     981     return
     982   }
     983   {
     984     compare g, 9/tab
     985     break-if-!=
     986     # tab = 2 spaces
     987     add-code-point-at-gap self, 0x20/space
     988     add-code-point-at-gap self, 0x20/space
     989     return
     990   }
     991   # default: insert character
     992   add-grapheme-at-gap self, g
     993 }
     994
     995 fn gap-to-start-of-next-word self: (addr gap-buffer) {
     996   var curr/eax: grapheme <- copy 0
     997   # skip to next space
     998   {
     999     curr <- gap-right self
    1000     compare curr, -1
    1001     break-if-=
    1002     compare curr, 0x20/space
    1003     break-if-=
    1004     compare curr, 0xa/newline
    1005     break-if-=
    1006     loop
    1007   }
    1008   # skip past spaces
    1009   {
    1010     curr <- gap-right self
    1011     compare curr, -1
    1012     break-if-=
    1013     compare curr, 0x20/space
    1014     loop-if-=
    1015     compare curr, 0xa/space
    1016     loop-if-=
    1017     curr <- gap-left self
    1018     break
    1019   }
    1020 }
    1021
    1022 fn gap-to-end-of-previous-word self: (addr gap-buffer) {
    1023   var curr/eax: grapheme <- copy 0
    1024   # skip to previous space
    1025   {
    1026     curr <- gap-left self
    1027     compare curr, -1
    1028     break-if-=
    1029     compare curr, 0x20/space
    1030     break-if-=
    1031     compare curr, 0xa/newline
    1032     break-if-=
    1033     loop
    1034   }
    1035   # skip past all spaces but one
    1036   {
    1037     curr <- gap-left self
    1038     compare curr, -1
    1039     break-if-=
    1040     compare curr, 0x20/space
    1041     loop-if-=
    1042     compare curr, 0xa/space
    1043     loop-if-=
    1044     curr <- gap-right self
    1045     break
    1046   }
    1047 }
    1048
    1049 fn gap-to-previous-start-of-line self: (addr gap-buffer) {
    1050   # skip past immediate newline
    1051   var dummy/eax: grapheme <- gap-left self
    1052   # skip to previous newline
    1053   {
    1054     dummy <- gap-left self
    1055     {
    1056       compare dummy, -1
    1057       break-if-!=
    1058       return
    1059     }
    1060     {
    1061       compare dummy, 0xa/newline
    1062       break-if-!=
    1063       dummy <- gap-right self
    1064       return
    1065     }
    1066     loop
    1067   }
    1068 }
    1069
    1070 fn gap-to-next-end-of-line self: (addr gap-buffer) {
    1071   # skip past immediate newline
    1072   var dummy/eax: grapheme <- gap-right self
    1073   # skip to next newline
    1074   {
    1075     dummy <- gap-right self
    1076     {
    1077       compare dummy, -1
    1078       break-if-!=
    1079       return
    1080     }
    1081     {
    1082       compare dummy, 0xa/newline
    1083       break-if-!=
    1084       dummy <- gap-left self
    1085       return
    1086     }
    1087     loop
    1088   }
    1089 }
    1090
    1091 fn gap-up self: (addr gap-buffer) {
    1092   # compute column
    1093   var col/edx: int <- count-columns-to-start-of-line self
    1094   #
    1095   gap-to-previous-start-of-line self
    1096   # skip ahead by up to col on previous line
    1097   var i/ecx: int <- copy 0
    1098   {
    1099     compare i, col
    1100     break-if->=
    1101     var curr/eax: grapheme <- gap-right self
    1102     {
    1103       compare curr, -1
    1104       break-if-!=
    1105       return
    1106     }
    1107     compare curr, 0xa/newline
    1108     {
    1109       break-if-!=
    1110       curr <- gap-left self
    1111       return
    1112     }
    1113     i <- increment
    1114     loop
    1115   }
    1116 }
    1117
    1118 fn gap-down self: (addr gap-buffer) {
    1119   # compute column
    1120   var col/edx: int <- count-columns-to-start-of-line self
    1121   # skip to start of next line
    1122   gap-to-end-of-line self
    1123   var dummy/eax: grapheme <- gap-right self
    1124   # skip ahead by up to col on previous line
    1125   var i/ecx: int <- copy 0
    1126   {
    1127     compare i, col
    1128     break-if->=
    1129     var curr/eax: grapheme <- gap-right self
    1130     {
    1131       compare curr, -1
    1132       break-if-!=
    1133       return
    1134     }
    1135     compare curr, 0xa/newline
    1136     {
    1137       break-if-!=
    1138       curr <- gap-left self
    1139       return
    1140     }
    1141     i <- increment
    1142     loop
    1143   }
    1144 }
    1145
    1146 fn count-columns-to-start-of-line self: (addr gap-buffer) -> _/edx: int {
    1147   var count/edx: int <- copy 0
    1148   var dummy/eax: grapheme <- copy 0
    1149   # skip to previous newline
    1150   {
    1151     dummy <- gap-left self
    1152     {
    1153       compare dummy, -1
    1154       break-if-!=
    1155       return count
    1156     }
    1157     {
    1158       compare dummy, 0xa/newline
    1159       break-if-!=
    1160       dummy <- gap-right self
    1161       return count
    1162     }
    1163     count <- increment
    1164     loop
    1165   }
    1166   return count
    1167 }
    1168
    1169 fn gap-to-end-of-line self: (addr gap-buffer) {
    1170   var dummy/eax: grapheme <- copy 0
    1171   # skip to next newline
    1172   {
    1173     dummy <- gap-right self
    1174     {
    1175       compare dummy, -1
    1176       break-if-!=
    1177       return
    1178     }
    1179     {
    1180       compare dummy, 0xa/newline
    1181       break-if-!=
    1182       dummy <- gap-left self
    1183       return
    1184     }
    1185     loop
    1186   }
    1187 }