https://github.com/akkartik/mu/blob/main/shell/grapheme-stack.mu

      1 # grapheme stacks are the smallest unit of editable text
      2
      3 type grapheme-stack {
      4   data: (handle array grapheme)
      5   top: int
      6 }
      7
      8 fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
      9   var self/esi: (addr grapheme-stack) <- copy _self
     10   var d/edi: (addr handle array grapheme) <- get self, data
     11   populate d, n
     12   var top/eax: (addr int) <- get self, top
     13   copy-to *top, 0
     14 }
     15
     16 fn clear-grapheme-stack _self: (addr grapheme-stack) {
     17   var self/esi: (addr grapheme-stack) <- copy _self
     18   var top/eax: (addr int) <- get self, top
     19   copy-to *top, 0
     20 }
     21
     22 fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
     23   var self/esi: (addr grapheme-stack) <- copy _self
     24   var top/eax: (addr int) <- get self, top
     25   compare *top, 0
     26   {
     27     break-if-!=
     28     return 1/true
     29   }
     30   return 0/false
     31 }
     32
     33 fn grapheme-stack-length _self: (addr grapheme-stack) -> _/eax: int {
     34   var self/esi: (addr grapheme-stack) <- copy _self
     35   var top/eax: (addr int) <- get self, top
     36   return *top
     37 }
     38
     39 fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
     40   var self/esi: (addr grapheme-stack) <- copy _self
     41   var top-addr/ecx: (addr int) <- get self, top
     42   var data-ah/edx: (addr handle array grapheme) <- get self, data
     43   var data/eax: (addr array grapheme) <- lookup *data-ah
     44   var top/edx: int <- copy *top-addr
     45   var dest-addr/edx: (addr grapheme) <- index data, top
     46   var val/eax: grapheme <- copy _val
     47   copy-to *dest-addr, val
     48   add-to *top-addr, 1
     49 }
     50
     51 fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
     52   var self/esi: (addr grapheme-stack) <- copy _self
     53   var top-addr/ecx: (addr int) <- get self, top
     54   {
     55     compare *top-addr, 0
     56     break-if->
     57     return -1
     58   }
     59   subtract-from *top-addr, 1
     60   var data-ah/edx: (addr handle array grapheme) <- get self, data
     61   var data/eax: (addr array grapheme) <- lookup *data-ah
     62   var top/edx: int <- copy *top-addr
     63   var result-addr/eax: (addr grapheme) <- index data, top
     64   return *result-addr
     65 }
     66
     67 fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
     68   var src/esi: (addr grapheme-stack) <- copy _src
     69   var data-ah/edi: (addr handle array grapheme) <- get src, data
     70   var _data/eax: (addr array grapheme) <- lookup *data-ah
     71   var data/edi: (addr array grapheme) <- copy _data
     72   var top-addr/ecx: (addr int) <- get src, top
     73   var i/eax: int <- copy 0
     74   {
     75     compare i, *top-addr
     76     break-if->=
     77     var g/edx: (addr grapheme) <- index data, i
     78     push-grapheme-stack dest, *g
     79     i <- increment
     80     loop
     81   }
     82 }
     83
     84 # dump stack to screen from bottom to top
     85 # hardcoded colors:
     86 #   matching paren
     87 fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int, color: int, background-color: int -> _/eax: int, _/ecx: int {
     88   var self/esi: (addr grapheme-stack) <- copy _self
     89   var matching-open-paren-index/edx: int <- get-matching-open-paren-index self, highlight-matching-open-paren?, open-paren-depth
     90   var data-ah/edi: (addr handle array grapheme) <- get self, data
     91   var _data/eax: (addr array grapheme) <- lookup *data-ah
     92   var data/edi: (addr array grapheme) <- copy _data
     93   var x/eax: int <- copy _x
     94   var y/ecx: int <- copy _y
     95   var top-addr/esi: (addr int) <- get self, top
     96   var i/ebx: int <- copy 0
     97   {
     98     compare i, *top-addr
     99     break-if->=
    100     {
    101       var g/esi: (addr grapheme) <- index data, i
    102       var fg: int
    103       {
    104         var tmp/eax: int <- copy color
    105         copy-to fg, tmp
    106       }
    107       {
    108         compare i, matching-open-paren-index
    109         break-if-!=
    110         copy-to fg, 0xf/highlight
    111       }
    112       x, y <- render-grapheme screen, *g, xmin, ymin, xmax, ymax, x, y, fg, background-color
    113     }
    114     i <- increment
    115     loop
    116   }
    117   return x, y
    118 }
    119
    120 # helper for small words
    121 fn render-stack-from-bottom screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int {
    122   var _width/eax: int <- copy 0
    123   var _height/ecx: int <- copy 0
    124   _width, _height <- screen-size screen
    125   var width/edx: int <- copy _width
    126   var height/ebx: int <- copy _height
    127   var x2/eax: int <- copy 0
    128   var y2/ecx: int <- copy 0
    129   x2, y2 <- render-stack-from-bottom-wrapping-right-then-down screen, self, x, y, width, height, x, y, highlight-matching-open-paren?, open-paren-depth, 3/fg=cyan, 0xc5/bg=blue-bg
    130   return x2  # y2? yolo
    131 }
    132
    133 # dump stack to screen from top to bottom
    134 # optionally render a 'cursor' with the top grapheme
    135 # hard-coded colors:
    136 #   matching paren
    137 #   cursor
    138 fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr grapheme-stack), xmin: int, ymin: int, xmax: int, ymax: int, _x: int, _y: int, render-cursor?: boolean, color: int, background-color: int -> _/eax: int, _/ecx: int {
    139   var self/esi: (addr grapheme-stack) <- copy _self
    140   var matching-close-paren-index/edx: int <- get-matching-close-paren-index self, render-cursor?
    141   var data-ah/eax: (addr handle array grapheme) <- get self, data
    142   var _data/eax: (addr array grapheme) <- lookup *data-ah
    143   var data/edi: (addr array grapheme) <- copy _data
    144   var x/eax: int <- copy _x
    145   var y/ecx: int <- copy _y
    146   var top-addr/ebx: (addr int) <- get self, top
    147   var i/ebx: int <- copy *top-addr
    148   i <- decrement
    149   # if render-cursor?, peel off first iteration
    150   {
    151     compare render-cursor?, 0/false
    152     break-if-=
    153     compare i, 0
    154     break-if-<
    155     var g/esi: (addr grapheme) <- index data, i
    156     x, y <- render-grapheme screen, *g, xmin, ymin, xmax, ymax, x, y, background-color, color
    157     i <- decrement
    158   }
    159   # remaining iterations
    160   {
    161     compare i, 0
    162     break-if-<
    163     # highlight matching paren if needed
    164     var fg: int
    165     {
    166       var tmp/eax: int <- copy color
    167       copy-to fg, tmp
    168     }
    169     compare i, matching-close-paren-index
    170     {
    171       break-if-!=
    172       copy-to fg, 0xf/highlight
    173     }
    174     #
    175     var g/esi: (addr grapheme) <- index data, i
    176     x, y <- render-grapheme screen, *g, xmin, ymin, xmax, ymax, x, y, fg, background-color
    177     i <- decrement
    178     loop
    179   }
    180   return x, y
    181 }
    182
    183 # helper for small words
    184 fn render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int {
    185   var _width/eax: int <- copy 0
    186   var _height/ecx: int <- copy 0
    187   _width, _height <- screen-size screen
    188   var width/edx: int <- copy _width
    189   var height/ebx: int <- copy _height
    190   var x2/eax: int <- copy 0
    191   var y2/ecx: int <- copy 0
    192   x2, y2 <- render-stack-from-top-wrapping-right-then-down screen, self, x, y, width, height, x, y, render-cursor?, 3/fg=cyan, 0xc5/bg=blue-bg
    193   return x2  # y2? yolo
    194 }
    195
    196 fn test-render-grapheme-stack {
    197   # setup: gs = "abc"
    198   var gs-storage: grapheme-stack
    199   var gs/edi: (addr grapheme-stack) <- address gs-storage
    200   initialize-grapheme-stack gs, 5
    201   var g/eax: grapheme <- copy 0x61/a
    202   push-grapheme-stack gs, g
    203   g <- copy 0x62/b
    204   push-grapheme-stack gs, g
    205   g <- copy 0x63/c
    206   push-grapheme-stack gs, g
    207   # setup: screen
    208   var screen-on-stack: screen
    209   var screen/esi: (addr screen) <- address screen-on-stack
    210   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    211   #
    212   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 0/y, 0/no-highlight-matching-open-paren, 0/open-paren-depth
    213   check-screen-row screen, 0/y, "abc ", "F - test-render-grapheme-stack from bottom"
    214   check-ints-equal x, 3, "F - test-render-grapheme-stack from bottom: result"
    215   check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   ", "F - test-render-grapheme-stack from bottom: bg"
    216   #
    217   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 1/y, 0/cursor=false
    218   check-screen-row screen, 1/y, "cba ", "F - test-render-grapheme-stack from top without cursor"
    219   check-ints-equal x, 3, "F - test-render-grapheme-stack from top without cursor: result"
    220   check-background-color-in-screen-row screen, 3/bg=reverse, 1/y, "   ", "F - test-render-grapheme-stack from top without cursor: bg"
    221   #
    222   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
    223   check-screen-row screen, 2/y, "cba ", "F - test-render-grapheme-stack from top with cursor"
    224   check-ints-equal x, 3, "F - test-render-grapheme-stack from top with cursor: result"
    225   check-background-color-in-screen-row screen, 3/bg=reverse, 2/y, "|   ", "F - test-render-grapheme-stack from top with cursor: bg"
    226 }
    227
    228 fn test-render-grapheme-stack-while-highlighting-matching-close-paren {
    229   # setup: gs = "(b)"
    230   var gs-storage: grapheme-stack
    231   var gs/edi: (addr grapheme-stack) <- address gs-storage
    232   initialize-grapheme-stack gs, 5
    233   var g/eax: grapheme <- copy 0x29/close-paren
    234   push-grapheme-stack gs, g
    235   g <- copy 0x62/b
    236   push-grapheme-stack gs, g
    237   g <- copy 0x28/open-paren
    238   push-grapheme-stack gs, g
    239   # setup: screen
    240   var screen-on-stack: screen
    241   var screen/esi: (addr screen) <- address screen-on-stack
    242   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    243   #
    244   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
    245   check-screen-row                      screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren"
    246   check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: cursor"
    247   check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "  ) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: matching paren"
    248 }
    249
    250 fn test-render-grapheme-stack-while-highlighting-matching-close-paren-2 {
    251   # setup: gs = "(a (b)) c"
    252   var gs-storage: grapheme-stack
    253   var gs/edi: (addr grapheme-stack) <- address gs-storage
    254   initialize-grapheme-stack gs, 0x10
    255   var g/eax: grapheme <- copy 0x63/c
    256   push-grapheme-stack gs, g
    257   g <- copy 0x20/space
    258   push-grapheme-stack gs, g
    259   g <- copy 0x29/close-paren
    260   push-grapheme-stack gs, g
    261   g <- copy 0x29/close-paren
    262   push-grapheme-stack gs, g
    263   g <- copy 0x62/b
    264   push-grapheme-stack gs, g
    265   g <- copy 0x28/open-paren
    266   push-grapheme-stack gs, g
    267   g <- copy 0x20/space
    268   push-grapheme-stack gs, g
    269   g <- copy 0x61/a
    270   push-grapheme-stack gs, g
    271   g <- copy 0x28/open-paren
    272   push-grapheme-stack gs, g
    273   # setup: screen
    274   var screen-on-stack: screen
    275   var screen/esi: (addr screen) <- address screen-on-stack
    276   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    277   #
    278   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
    279   check-screen-row                      screen,               2/y, "(a (b)) c ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2"
    280   check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|         ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: cursor"
    281   check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "      )   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: matching paren"
    282 }
    283
    284 fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end {
    285   # setup: gs = "(b)"
    286   var gs-storage: grapheme-stack
    287   var gs/edi: (addr grapheme-stack) <- address gs-storage
    288   initialize-grapheme-stack gs, 5
    289   var g/eax: grapheme <- copy 0x28/open-paren
    290   push-grapheme-stack gs, g
    291   g <- copy 0x62/b
    292   push-grapheme-stack gs, g
    293   g <- copy 0x29/close-paren
    294   push-grapheme-stack gs, g
    295   # setup: screen
    296   var screen-on-stack: screen
    297   var screen/esi: (addr screen) <- address screen-on-stack
    298   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    299   #
    300   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
    301   check-screen-row          screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end"
    302   check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(   ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end: matching paren"
    303 }
    304
    305 fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2 {
    306   # setup: gs = "a((b))"
    307   var gs-storage: grapheme-stack
    308   var gs/edi: (addr grapheme-stack) <- address gs-storage
    309   initialize-grapheme-stack gs, 0x10
    310   var g/eax: grapheme <- copy 0x61/a
    311   push-grapheme-stack gs, g
    312   g <- copy 0x28/open-paren
    313   push-grapheme-stack gs, g
    314   g <- copy 0x28/open-paren
    315   push-grapheme-stack gs, g
    316   g <- copy 0x62/b
    317   push-grapheme-stack gs, g
    318   g <- copy 0x29/close-paren
    319   push-grapheme-stack gs, g
    320   g <- copy 0x29/close-paren
    321   push-grapheme-stack gs, g
    322   # setup: screen
    323   var screen-on-stack: screen
    324   var screen/esi: (addr screen) <- address screen-on-stack
    325   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    326   #
    327   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
    328   check-screen-row          screen,               2/y, "a((b)) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2"
    329   check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (     ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2: matching paren"
    330 }
    331
    332 fn test-render-grapheme-stack-while-highlighting-matching-open-paren {
    333   # setup: gs = "(b"
    334   var gs-storage: grapheme-stack
    335   var gs/edi: (addr grapheme-stack) <- address gs-storage
    336   initialize-grapheme-stack gs, 5
    337   var g/eax: grapheme <- copy 0x28/open-paren
    338   push-grapheme-stack gs, g
    339   g <- copy 0x62/b
    340   push-grapheme-stack gs, g
    341   # setup: screen
    342   var screen-on-stack: screen
    343   var screen/esi: (addr screen) <- address screen-on-stack
    344   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    345   #
    346   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
    347   check-screen-row          screen,               2/y, "(b ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren"
    348   check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(  ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren: matching paren"
    349 }
    350
    351 fn test-render-grapheme-stack-while-highlighting-matching-open-paren-2 {
    352   # setup: gs = "a((b)"
    353   var gs-storage: grapheme-stack
    354   var gs/edi: (addr grapheme-stack) <- address gs-storage
    355   initialize-grapheme-stack gs, 0x10
    356   var g/eax: grapheme <- copy 0x61/a
    357   push-grapheme-stack gs, g
    358   g <- copy 0x28/open-paren
    359   push-grapheme-stack gs, g
    360   g <- copy 0x28/open-paren
    361   push-grapheme-stack gs, g
    362   g <- copy 0x62/b
    363   push-grapheme-stack gs, g
    364   g <- copy 0x29/close-paren
    365   push-grapheme-stack gs, g
    366   # setup: screen
    367   var screen-on-stack: screen
    368   var screen/esi: (addr screen) <- address screen-on-stack
    369   initialize-screen screen, 5, 4, 0/no-pixel-graphics
    370   #
    371   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
    372   check-screen-row          screen,               2/y, "a((b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2"
    373   check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (    ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2: matching paren"
    374 }
    375
    376 # return the index of the matching close-paren of the grapheme at cursor (top of stack)
    377 # or top index if there's no matching close-paren
    378 fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?: boolean -> _/edx: int {
    379   var self/esi: (addr grapheme-stack) <- copy _self
    380   var top-addr/edx: (addr int) <- get self, top
    381   # if not rendering cursor, return
    382   compare render-cursor?, 0/false
    383   {
    384     break-if-!=
    385     return *top-addr
    386   }
    387   var data-ah/eax: (addr handle array grapheme) <- get self, data
    388   var data/eax: (addr array grapheme) <- lookup *data-ah
    389   var i/ecx: int <- copy *top-addr
    390   # if stack is empty, return
    391   compare i, 0
    392   {
    393     break-if->
    394     return *top-addr
    395   }
    396   # if cursor is not '(' return
    397   i <- decrement
    398   var g/esi: (addr grapheme) <- index data, i
    399   compare *g, 0x28/open-paren
    400   {
    401     break-if-=
    402     return *top-addr
    403   }
    404   # otherwise scan to matching paren
    405   var paren-count/ebx: int <- copy 1
    406   i <- decrement
    407   {
    408     compare i, 0
    409     break-if-<
    410     var g/esi: (addr grapheme) <- index data, i
    411     compare *g, 0x28/open-paren
    412     {
    413       break-if-!=
    414       paren-count <- increment
    415     }
    416     compare *g, 0x29/close-paren
    417     {
    418       break-if-!=
    419       compare paren-count, 1
    420       {
    421         break-if-!=
    422         return i
    423       }
    424       paren-count <- decrement
    425     }
    426     i <- decrement
    427     loop
    428   }
    429   return *top-addr
    430 }
    431
    432 # return the index of the first open-paren at the given depth
    433 # or top index if there's no matching close-paren
    434 fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean, depth: int -> _/edx: int {
    435   var self/esi: (addr grapheme-stack) <- copy _self
    436   var top-addr/edx: (addr int) <- get self, top
    437   # if not rendering cursor, return
    438   compare control, 0/false
    439   {
    440     break-if-!=
    441     return *top-addr
    442   }
    443   var data-ah/eax: (addr handle array grapheme) <- get self, data
    444   var data/eax: (addr array grapheme) <- lookup *data-ah
    445   var i/ecx: int <- copy *top-addr
    446   # if stack is empty, return
    447   compare i, 0
    448   {
    449     break-if->
    450     return *top-addr
    451   }
    452   # scan to matching open paren
    453   var paren-count/ebx: int <- copy 0
    454   i <- decrement
    455   {
    456     compare i, 0
    457     break-if-<
    458     var g/esi: (addr grapheme) <- index data, i
    459     compare *g, 0x29/close-paren
    460     {
    461       break-if-!=
    462       paren-count <- increment
    463     }
    464     compare *g, 0x28/open-paren
    465     {
    466       break-if-!=
    467       compare paren-count, depth
    468       {
    469         break-if-!=
    470         return i
    471       }
    472       paren-count <- decrement
    473     }
    474     i <- decrement
    475     loop
    476   }
    477   return *top-addr
    478 }
    479
    480 # compare from bottom
    481 # beware: modifies 'stream', which must be disposed of after a false result
    482 fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
    483   var self/esi: (addr grapheme-stack) <- copy _self
    484   var data-ah/edi: (addr handle array grapheme) <- get self, data
    485   var _data/eax: (addr array grapheme) <- lookup *data-ah
    486   var data/edi: (addr array grapheme) <- copy _data
    487   var top-addr/ecx: (addr int) <- get self, top
    488   var i/ebx: int <- copy 0
    489   {
    490     compare i, *top-addr
    491     break-if->=
    492     # if curr != expected, return false
    493     {
    494       var curr-a/edx: (addr grapheme) <- index data, i
    495       var expected/eax: grapheme <- read-grapheme s
    496       {
    497         compare expected, *curr-a
    498         break-if-=
    499         return 0/false
    500       }
    501     }
    502     i <- increment
    503     loop
    504   }
    505   return 1   # true
    506 }
    507
    508 # compare from bottom
    509 # beware: modifies 'stream', which must be disposed of after a false result
    510 fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
    511   var self/esi: (addr grapheme-stack) <- copy _self
    512   var data-ah/edi: (addr handle array grapheme) <- get self, data
    513   var _data/eax: (addr array grapheme) <- lookup *data-ah
    514   var data/edi: (addr array grapheme) <- copy _data
    515   var top-addr/eax: (addr int) <- get self, top
    516   var i/ebx: int <- copy *top-addr
    517   i <- decrement
    518   {
    519     compare i, 0
    520     break-if-<
    521     {
    522       var curr-a/edx: (addr grapheme) <- index data, i
    523       var expected/eax: grapheme <- read-grapheme s
    524       # if curr != expected, return false
    525       {
    526         compare expected, *curr-a
    527         break-if-=
    528         return 0/false
    529       }
    530     }
    531     i <- decrement
    532     loop
    533   }
    534   return 1   # true
    535 }
    536
    537 fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
    538   var self/esi: (addr grapheme-stack) <- copy _self
    539   var data-ah/eax: (addr handle array grapheme) <- get self, data
    540   var _data/eax: (addr array grapheme) <- lookup *data-ah
    541   var data/edx: (addr array grapheme) <- copy _data
    542   var top-addr/ecx: (addr int) <- get self, top
    543   var i/ebx: int <- copy 0
    544   var result/eax: boolean <- copy 1/true
    545   $grapheme-stack-is-integer?:loop: {
    546     compare i, *top-addr
    547     break-if->=
    548     var g/edx: (addr grapheme) <- index data, i
    549     result <- decimal-digit? *g
    550     compare result, 0/false
    551     break-if-=
    552     i <- increment
    553     loop
    554   }
    555   return result
    556 }