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