about summary refs log tree commit diff stats
path: root/513grapheme-stack.mu
diff options
context:
space:
mode:
Diffstat (limited to '513grapheme-stack.mu')
-rw-r--r--513grapheme-stack.mu336
1 files changed, 168 insertions, 168 deletions
diff --git a/513grapheme-stack.mu b/513grapheme-stack.mu
index 3228cfb3..3aa0fd4e 100644
--- a/513grapheme-stack.mu
+++ b/513grapheme-stack.mu
@@ -1,26 +1,26 @@
-# grapheme stacks are the smallest unit of editable text
+# code-point-utf8 stacks are the smallest unit of editable text
 
-type grapheme-stack {
-  data: (handle array grapheme)
+type code-point-utf8-stack {
+  data: (handle array code-point-utf8)
   top: int
 }
 
-fn initialize-grapheme-stack _self: (addr grapheme-stack), n: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var d/edi: (addr handle array grapheme) <- get self, data
+fn initialize-code-point-utf8-stack _self: (addr code-point-utf8-stack), n: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var d/edi: (addr handle array code-point-utf8) <- get self, data
   populate d, n
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn clear-grapheme-stack _self: (addr grapheme-stack) {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn clear-code-point-utf8-stack _self: (addr code-point-utf8-stack) {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   copy-to *top, 0
 }
 
-fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn code-point-utf8-stack-empty? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   compare *top, 0
   {
@@ -30,26 +30,26 @@ fn grapheme-stack-empty? _self: (addr grapheme-stack) -> _/eax: boolean {
   return 0/false
 }
 
-fn grapheme-stack-length _self: (addr grapheme-stack) -> _/eax: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn code-point-utf8-stack-length _self: (addr code-point-utf8-stack) -> _/eax: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top/eax: (addr int) <- get self, top
   return *top
 }
 
-fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn push-code-point-utf8-stack _self: (addr code-point-utf8-stack), _val: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var dest-addr/edx: (addr grapheme) <- index data, top
-  var val/eax: grapheme <- copy _val
+  var dest-addr/edx: (addr code-point-utf8) <- index data, top
+  var val/eax: code-point-utf8 <- copy _val
   copy-to *dest-addr, val
   add-to *top-addr, 1
 }
 
-fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn pop-code-point-utf8-stack _self: (addr code-point-utf8-stack) -> _/eax: code-point-utf8 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/ecx: (addr int) <- get self, top
   {
     compare *top-addr, 0
@@ -57,25 +57,25 @@ fn pop-grapheme-stack _self: (addr grapheme-stack) -> _/eax: grapheme {
     return -1
   }
   subtract-from *top-addr, 1
-  var data-ah/edx: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/edx: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var top/edx: int <- copy *top-addr
-  var result-addr/eax: (addr grapheme) <- index data, top
+  var result-addr/eax: (addr code-point-utf8) <- index data, top
   return *result-addr
 }
 
-fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) {
-  var src/esi: (addr grapheme-stack) <- copy _src
-  var data-ah/edi: (addr handle array grapheme) <- get src, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn copy-code-point-utf8-stack _src: (addr code-point-utf8-stack), dest: (addr code-point-utf8-stack) {
+  var src/esi: (addr code-point-utf8-stack) <- copy _src
+  var data-ah/edi: (addr handle array code-point-utf8) <- get src, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get src, top
   var i/eax: int <- copy 0
   {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
-    push-grapheme-stack dest, *g
+    var g/edx: (addr code-point-utf8) <- index data, i
+    push-code-point-utf8-stack dest, *g
     i <- increment
     loop
   }
@@ -84,12 +84,12 @@ fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack)
 # dump stack to screen from bottom to top
 # hardcoded colors:
 #   matching paren
-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 {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-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 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var matching-open-paren-index/edx: int <- get-matching-open-paren-index self, highlight-matching-open-paren?, open-paren-depth
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var x/eax: int <- copy _x
   var y/ecx: int <- copy _y
   var top-addr/esi: (addr int) <- get self, top
@@ -100,7 +100,7 @@ fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _sel
     {
       var c: code-point
       {
-        var g/eax: (addr grapheme) <- index data, i
+        var g/eax: (addr code-point-utf8) <- index data, i
         var tmp/eax: code-point <- to-code-point *g
         copy-to c, tmp
       }
@@ -123,7 +123,7 @@ fn render-stack-from-bottom-wrapping-right-then-down screen: (addr screen), _sel
 }
 
 # helper for small words
-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 {
+fn render-stack-from-bottom screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, highlight-matching-open-paren?: boolean, open-paren-depth: int -> _/eax: int {
   var _width/eax: int <- copy 0
   var _height/ecx: int <- copy 0
   _width, _height <- screen-size screen
@@ -136,16 +136,16 @@ fn render-stack-from-bottom screen: (addr screen), self: (addr grapheme-stack),
 }
 
 # dump stack to screen from top to bottom
-# optionally render a 'cursor' with the top grapheme
+# optionally render a 'cursor' with the top code-point-utf8
 # hard-coded colors:
 #   matching paren
 #   cursor
-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 {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self: (addr code-point-utf8-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 {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var matching-close-paren-index/edx: int <- get-matching-close-paren-index self, render-cursor?
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var x/eax: int <- copy _x
   var y/ecx: int <- copy _y
   var top-addr/ebx: (addr int) <- get self, top
@@ -159,7 +159,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
     break-if-<
     var c: code-point
     {
-      var g/eax: (addr grapheme) <- index data, i
+      var g/eax: (addr code-point-utf8) <- index data, i
       var tmp/eax: code-point <- to-code-point *g
       copy-to c, tmp
     }
@@ -184,7 +184,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
     #
     var c: code-point
     {
-      var g/eax: (addr grapheme) <- index data, i
+      var g/eax: (addr code-point-utf8) <- index data, i
       var tmp/eax: code-point <- to-code-point *g
       copy-to c, tmp
     }
@@ -196,7 +196,7 @@ fn render-stack-from-top-wrapping-right-then-down screen: (addr screen), _self:
 }
 
 # helper for small words
-fn render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int {
+fn render-stack-from-top screen: (addr screen), self: (addr code-point-utf8-stack), x: int, y: int, render-cursor?: boolean -> _/eax: int {
   var _width/eax: int <- copy 0
   var _height/ecx: int <- copy 0
   _width, _height <- screen-size screen
@@ -208,190 +208,190 @@ fn render-stack-from-top screen: (addr screen), self: (addr grapheme-stack), x:
   return x2  # y2? yolo
 }
 
-fn test-render-grapheme-stack {
+fn test-render-code-point-utf8-stack {
   # setup: gs = "abc"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x63/c
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 0/y, 0/no-highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row screen, 0/y, "abc ", "F - test-render-grapheme-stack from bottom"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from bottom: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   ", "F - test-render-grapheme-stack from bottom: bg"
+  check-screen-row screen, 0/y, "abc ", "F - test-render-code-point-utf8-stack from bottom"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from bottom: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 0/y, "   ", "F - test-render-code-point-utf8-stack from bottom: bg"
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 1/y, 0/cursor=false
-  check-screen-row screen, 1/y, "cba ", "F - test-render-grapheme-stack from top without cursor"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from top without cursor: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 1/y, "   ", "F - test-render-grapheme-stack from top without cursor: bg"
+  check-screen-row screen, 1/y, "cba ", "F - test-render-code-point-utf8-stack from top without cursor"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from top without cursor: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 1/y, "   ", "F - test-render-code-point-utf8-stack from top without cursor: bg"
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row screen, 2/y, "cba ", "F - test-render-grapheme-stack from top with cursor"
-  check-ints-equal x, 3, "F - test-render-grapheme-stack from top with cursor: result"
-  check-background-color-in-screen-row screen, 3/bg=reverse, 2/y, "|   ", "F - test-render-grapheme-stack from top with cursor: bg"
+  check-screen-row screen, 2/y, "cba ", "F - test-render-code-point-utf8-stack from top with cursor"
+  check-ints-equal x, 3, "F - test-render-code-point-utf8-stack from top with cursor: result"
+  check-background-color-in-screen-row screen, 3/bg=reverse, 2/y, "|   ", "F - test-render-code-point-utf8-stack from top with cursor: bg"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-close-paren {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-close-paren {
   # setup: gs = "(b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x29/close-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row                      screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren"
-  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: cursor"
-  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "  ) ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren: matching paren"
+  check-screen-row                      screen,               2/y, "(b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren"
+  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren: cursor"
+  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "  ) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-close-paren-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2 {
   # setup: gs = "(a (b)) c"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x63/c
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x63/c
+  push-code-point-utf8-stack gs, g
   g <- copy 0x20/space
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x20/space
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x61/a
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-top screen, gs, 0/x, 2/y, 1/cursor=true
-  check-screen-row                      screen,               2/y, "(a (b)) c ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2"
-  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|         ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: cursor"
-  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "      )   ", "F - test-render-grapheme-stack-while-highlighting-matching-close-paren-2: matching paren"
+  check-screen-row                      screen,               2/y, "(a (b)) c ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2"
+  check-background-color-in-screen-row  screen, 3/bg=reverse,  2/y, "|         ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2: cursor"
+  check-screen-row-in-color             screen, 0xf/fg=white, 2/y, "      )   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-close-paren-2: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end {
   # setup: gs = "(b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x28/open-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
-  check-screen-row          screen,               2/y, "(b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end"
-  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"
+  check-screen-row          screen,               2/y, "(b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(   ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2 {
   # setup: gs = "a((b))"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 1/open-paren-depth
-  check-screen-row          screen,               2/y, "a((b)) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2"
-  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"
+  check-screen-row          screen,               2/y, "a((b)) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (     ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-with-close-paren-at-end-2: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren {
   # setup: gs = "(b"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 5
-  var g/eax: grapheme <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 5
+  var g/eax: code-point-utf8 <- copy 0x28/open-paren
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row          screen,               2/y, "(b ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(  ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren: matching paren"
+  check-screen-row          screen,               2/y, "(b ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, "(  ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren: matching paren"
 }
 
-fn test-render-grapheme-stack-while-highlighting-matching-open-paren-2 {
+fn test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2 {
   # setup: gs = "a((b)"
-  var gs-storage: grapheme-stack
-  var gs/edi: (addr grapheme-stack) <- address gs-storage
-  initialize-grapheme-stack gs, 0x10
-  var g/eax: grapheme <- copy 0x61/a
-  push-grapheme-stack gs, g
+  var gs-storage: code-point-utf8-stack
+  var gs/edi: (addr code-point-utf8-stack) <- address gs-storage
+  initialize-code-point-utf8-stack gs, 0x10
+  var g/eax: code-point-utf8 <- copy 0x61/a
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x28/open-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x62/b
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   g <- copy 0x29/close-paren
-  push-grapheme-stack gs, g
+  push-code-point-utf8-stack gs, g
   # setup: screen
   var screen-storage: screen
   var screen/esi: (addr screen) <- address screen-storage
   initialize-screen screen, 5, 4, 0/no-pixel-graphics
   #
   var x/eax: int <- render-stack-from-bottom screen, gs, 0/x, 2/y, 1/highlight-matching-open-paren, 0/open-paren-depth
-  check-screen-row          screen,               2/y, "a((b) ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2"
-  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (    ", "F - test-render-grapheme-stack-while-highlighting-matching-open-paren-2: matching paren"
+  check-screen-row          screen,               2/y, "a((b) ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2"
+  check-screen-row-in-color screen, 0xf/fg=white, 2/y, " (    ", "F - test-render-code-point-utf8-stack-while-highlighting-matching-open-paren-2: matching paren"
 }
 
-# return the index of the matching close-paren of the grapheme at cursor (top of stack)
+# return the index of the matching close-paren of the code-point-utf8 at cursor (top of stack)
 # or top index if there's no matching close-paren
-fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?: boolean -> _/edx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn get-matching-close-paren-index _self: (addr code-point-utf8-stack), render-cursor?: boolean -> _/edx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/edx: (addr int) <- get self, top
   # if not rendering cursor, return
   compare render-cursor?, 0/false
@@ -399,8 +399,8 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
     break-if-!=
     return *top-addr
   }
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var i/ecx: int <- copy *top-addr
   # if stack is empty, return
   compare i, 0
@@ -410,7 +410,7 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
   }
   # if cursor is not '(' return
   i <- decrement
-  var g/esi: (addr grapheme) <- index data, i
+  var g/esi: (addr code-point-utf8) <- index data, i
   compare *g, 0x28/open-paren
   {
     break-if-=
@@ -422,7 +422,7 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
   {
     compare i, 0
     break-if-<
-    var g/esi: (addr grapheme) <- index data, i
+    var g/esi: (addr code-point-utf8) <- index data, i
     compare *g, 0x28/open-paren
     {
       break-if-!=
@@ -446,8 +446,8 @@ fn get-matching-close-paren-index _self: (addr grapheme-stack), render-cursor?:
 
 # return the index of the first open-paren at the given depth
 # or top index if there's no matching close-paren
-fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean, depth: int -> _/edx: int {
-  var self/esi: (addr grapheme-stack) <- copy _self
+fn get-matching-open-paren-index _self: (addr code-point-utf8-stack), control: boolean, depth: int -> _/edx: int {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
   var top-addr/edx: (addr int) <- get self, top
   # if not rendering cursor, return
   compare control, 0/false
@@ -455,8 +455,8 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
     break-if-!=
     return *top-addr
   }
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var data/eax: (addr array grapheme) <- lookup *data-ah
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var data/eax: (addr array code-point-utf8) <- lookup *data-ah
   var i/ecx: int <- copy *top-addr
   # if stack is empty, return
   compare i, 0
@@ -470,7 +470,7 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
   {
     compare i, 0
     break-if-<
-    var g/esi: (addr grapheme) <- index data, i
+    var g/esi: (addr code-point-utf8) <- index data, i
     compare *g, 0x29/close-paren
     {
       break-if-!=
@@ -494,11 +494,11 @@ fn get-matching-open-paren-index _self: (addr grapheme-stack), control: boolean,
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn prefix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   {
@@ -506,8 +506,8 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     break-if->=
     # if curr != expected, return false
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       {
         compare expected, *curr-a
         break-if-=
@@ -522,11 +522,11 @@ fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
 
 # compare from bottom
 # beware: modifies 'stream', which must be disposed of after a false result
-fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/edi: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edi: (addr array grapheme) <- copy _data
+fn suffix-match? _self: (addr code-point-utf8-stack), s: (addr stream byte) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/edi: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edi: (addr array code-point-utf8) <- copy _data
   var top-addr/eax: (addr int) <- get self, top
   var i/ebx: int <- copy *top-addr
   i <- decrement
@@ -534,8 +534,8 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
     compare i, 0
     break-if-<
     {
-      var curr-a/edx: (addr grapheme) <- index data, i
-      var expected/eax: grapheme <- read-grapheme s
+      var curr-a/edx: (addr code-point-utf8) <- index data, i
+      var expected/eax: code-point-utf8 <- read-code-point-utf8 s
       # if curr != expected, return false
       {
         compare expected, *curr-a
@@ -549,18 +549,18 @@ fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> _/eax: b
   return 1   # true
 }
 
-fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> _/eax: boolean {
-  var self/esi: (addr grapheme-stack) <- copy _self
-  var data-ah/eax: (addr handle array grapheme) <- get self, data
-  var _data/eax: (addr array grapheme) <- lookup *data-ah
-  var data/edx: (addr array grapheme) <- copy _data
+fn code-point-utf8-stack-is-decimal-integer? _self: (addr code-point-utf8-stack) -> _/eax: boolean {
+  var self/esi: (addr code-point-utf8-stack) <- copy _self
+  var data-ah/eax: (addr handle array code-point-utf8) <- get self, data
+  var _data/eax: (addr array code-point-utf8) <- lookup *data-ah
+  var data/edx: (addr array code-point-utf8) <- copy _data
   var top-addr/ecx: (addr int) <- get self, top
   var i/ebx: int <- copy 0
   var result/eax: boolean <- copy 1/true
-  $grapheme-stack-is-integer?:loop: {
+  $code-point-utf8-stack-is-integer?:loop: {
     compare i, *top-addr
     break-if->=
-    var g/edx: (addr grapheme) <- index data, i
+    var g/edx: (addr code-point-utf8) <- index data, i
     result <- decimal-digit? *g
     compare result, 0/false
     break-if-=
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-05-18 22:27:46 +0000