From d409be9b29b4bbfdf10fa26620fa6abbe45a87da Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Tue, 20 Oct 2020 23:06:24 -0700 Subject: 7088 --- html/apps/tile/grapheme-stack.mu.html | 334 +++++++++++++++++++--------------- 1 file changed, 188 insertions(+), 146 deletions(-) (limited to 'html/apps/tile/grapheme-stack.mu.html') diff --git a/html/apps/tile/grapheme-stack.mu.html b/html/apps/tile/grapheme-stack.mu.html index 32f7aa0b..38285b25 100644 --- a/html/apps/tile/grapheme-stack.mu.html +++ b/html/apps/tile/grapheme-stack.mu.html @@ -69,152 +69,194 @@ if ('onhashchange' in window) { 11 copy-to *top, 0 12 } 13 - 14 fn grapheme-stack-empty? _self: (addr grapheme-stack) -> result/eax: boolean { - 15 $grapheme-stack-empty?:body: { - 16 var self/esi: (addr grapheme-stack) <- copy _self - 17 var top/eax: (addr int) <- get self, top - 18 compare *top, 0 - 19 { - 20 break-if-= - 21 result <- copy 1 # false - 22 break $grapheme-stack-empty?:body - 23 } - 24 result <- copy 0 # false - 25 } - 26 } - 27 - 28 fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme { - 29 var self/esi: (addr grapheme-stack) <- copy _self - 30 var top-addr/ecx: (addr int) <- get self, top - 31 var data-ah/edx: (addr handle array grapheme) <- get self, data - 32 var data/eax: (addr array grapheme) <- lookup *data-ah - 33 var top/edx: int <- copy *top-addr - 34 var dest-addr/edx: (addr grapheme) <- index data, top - 35 var val/eax: grapheme <- copy _val - 36 copy-to *dest-addr, val - 37 add-to *top-addr, 1 - 38 } - 39 - 40 fn pop-grapheme-stack _self: (addr grapheme-stack) -> val/eax: grapheme { - 41 $pop-grapheme-stack:body: { - 42 var self/esi: (addr grapheme-stack) <- copy _self - 43 var top-addr/ecx: (addr int) <- get self, top - 44 { - 45 compare *top-addr, 0 - 46 break-if-> - 47 val <- copy -1 - 48 break $pop-grapheme-stack:body - 49 } - 50 subtract-from *top-addr, 1 - 51 var data-ah/edx: (addr handle array grapheme) <- get self, data - 52 var data/eax: (addr array grapheme) <- lookup *data-ah - 53 var top/edx: int <- copy *top-addr - 54 var result-addr/eax: (addr grapheme) <- index data, top - 55 val <- copy *result-addr - 56 } - 57 } - 58 - 59 # dump stack to screen from bottom to top - 60 # don't move the cursor or anything - 61 fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen) { - 62 var self/esi: (addr grapheme-stack) <- copy _self - 63 var data-ah/edi: (addr handle array grapheme) <- get self, data - 64 var _data/eax: (addr array grapheme) <- lookup *data-ah - 65 var data/edi: (addr array grapheme) <- copy _data - 66 var top-addr/ecx: (addr int) <- get self, top - 67 var i/eax: int <- copy 0 - 68 { - 69 compare i, *top-addr - 70 break-if->= - 71 var g/edx: (addr grapheme) <- index data, i - 72 print-grapheme screen, *g - 73 i <- increment - 74 loop - 75 } - 76 } - 77 - 78 # dump stack to screen from top to bottom - 79 # don't move the cursor or anything - 80 fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen) { - 81 var self/esi: (addr grapheme-stack) <- copy _self - 82 var data-ah/edi: (addr handle array grapheme) <- get self, data - 83 var _data/eax: (addr array grapheme) <- lookup *data-ah - 84 var data/edi: (addr array grapheme) <- copy _data - 85 var top-addr/ecx: (addr int) <- get self, top - 86 var i/eax: int <- copy *top-addr - 87 i <- decrement - 88 { - 89 compare i, 0 - 90 break-if-< - 91 var g/edx: (addr grapheme) <- index data, i - 92 print-grapheme screen, *g - 93 i <- decrement - 94 loop - 95 } - 96 } - 97 - 98 # compare from bottom - 99 # beware: modifies 'stream', which must be disposed of after a false result -100 fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> result/eax: boolean { -101 $prefix-match?:body: { -102 var self/esi: (addr grapheme-stack) <- copy _self -103 var data-ah/edi: (addr handle array grapheme) <- get self, data -104 var _data/eax: (addr array grapheme) <- lookup *data-ah -105 var data/edi: (addr array grapheme) <- copy _data -106 var top-addr/ecx: (addr int) <- get self, top -107 var i/ebx: int <- copy 0 -108 { -109 compare i, *top-addr -110 break-if->= -111 # if curr != expected, return false -112 { -113 var curr-a/edx: (addr grapheme) <- index data, i -114 var expected/eax: grapheme <- read-grapheme s -115 { -116 compare expected, *curr-a -117 break-if-= -118 result <- copy 0 # false -119 break $prefix-match?:body -120 } -121 } -122 i <- increment -123 loop -124 } -125 result <- copy 1 # true -126 } -127 } -128 -129 # compare from bottom -130 # beware: modifies 'stream', which must be disposed of after a false result -131 fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> result/eax: boolean { -132 $suffix-match?:body: { -133 var self/esi: (addr grapheme-stack) <- copy _self -134 var data-ah/edi: (addr handle array grapheme) <- get self, data -135 var _data/eax: (addr array grapheme) <- lookup *data-ah -136 var data/edi: (addr array grapheme) <- copy _data -137 var top-addr/eax: (addr int) <- get self, top -138 var i/ebx: int <- copy *top-addr -139 i <- decrement -140 { -141 compare i, 0 -142 break-if-< -143 { -144 var curr-a/edx: (addr grapheme) <- index data, i -145 var expected/eax: grapheme <- read-grapheme s -146 # if curr != expected, return false -147 { -148 compare expected, *curr-a -149 break-if-= -150 result <- copy 0 # false -151 break $suffix-match?:body -152 } -153 } -154 i <- decrement -155 loop -156 } -157 result <- copy 1 # true -158 } -159 } + 14 fn clear-grapheme-stack _self: (addr grapheme-stack) { + 15 var self/esi: (addr grapheme-stack) <- copy _self + 16 var top/eax: (addr int) <- get self, top + 17 copy-to *top, 0 + 18 } + 19 + 20 fn grapheme-stack-empty? _self: (addr grapheme-stack) -> result/eax: boolean { + 21 $grapheme-stack-empty?:body: { + 22 var self/esi: (addr grapheme-stack) <- copy _self + 23 var top/eax: (addr int) <- get self, top + 24 compare *top, 0 + 25 { + 26 break-if-!= + 27 result <- copy 1 # true + 28 break $grapheme-stack-empty?:body + 29 } + 30 result <- copy 0 # false + 31 } + 32 } + 33 + 34 fn push-grapheme-stack _self: (addr grapheme-stack), _val: grapheme { + 35 var self/esi: (addr grapheme-stack) <- copy _self + 36 var top-addr/ecx: (addr int) <- get self, top + 37 var data-ah/edx: (addr handle array grapheme) <- get self, data + 38 var data/eax: (addr array grapheme) <- lookup *data-ah + 39 var top/edx: int <- copy *top-addr + 40 var dest-addr/edx: (addr grapheme) <- index data, top + 41 var val/eax: grapheme <- copy _val + 42 copy-to *dest-addr, val + 43 add-to *top-addr, 1 + 44 } + 45 + 46 fn pop-grapheme-stack _self: (addr grapheme-stack) -> val/eax: grapheme { + 47 $pop-grapheme-stack:body: { + 48 var self/esi: (addr grapheme-stack) <- copy _self + 49 var top-addr/ecx: (addr int) <- get self, top + 50 { + 51 compare *top-addr, 0 + 52 break-if-> + 53 val <- copy -1 + 54 break $pop-grapheme-stack:body + 55 } + 56 subtract-from *top-addr, 1 + 57 var data-ah/edx: (addr handle array grapheme) <- get self, data + 58 var data/eax: (addr array grapheme) <- lookup *data-ah + 59 var top/edx: int <- copy *top-addr + 60 var result-addr/eax: (addr grapheme) <- index data, top + 61 val <- copy *result-addr + 62 } + 63 } + 64 + 65 fn copy-grapheme-stack _src: (addr grapheme-stack), dest: (addr grapheme-stack) { + 66 var src/esi: (addr grapheme-stack) <- copy _src + 67 var data-ah/edi: (addr handle array grapheme) <- get src, data + 68 var _data/eax: (addr array grapheme) <- lookup *data-ah + 69 var data/edi: (addr array grapheme) <- copy _data + 70 var top-addr/ecx: (addr int) <- get src, top + 71 var i/eax: int <- copy 0 + 72 { + 73 compare i, *top-addr + 74 break-if->= + 75 var g/edx: (addr grapheme) <- index data, i + 76 push-grapheme-stack dest, *g + 77 i <- increment + 78 loop + 79 } + 80 } + 81 + 82 # dump stack to screen from bottom to top + 83 # don't move the cursor or anything + 84 fn render-stack-from-bottom _self: (addr grapheme-stack), screen: (addr screen) { + 85 var self/esi: (addr grapheme-stack) <- copy _self + 86 var data-ah/edi: (addr handle array grapheme) <- get self, data + 87 var _data/eax: (addr array grapheme) <- lookup *data-ah + 88 var data/edi: (addr array grapheme) <- copy _data + 89 var top-addr/ecx: (addr int) <- get self, top + 90 var i/eax: int <- copy 0 + 91 { + 92 compare i, *top-addr + 93 break-if->= + 94 var g/edx: (addr grapheme) <- index data, i + 95 print-grapheme screen, *g + 96 i <- increment + 97 loop + 98 } + 99 } +100 +101 # dump stack to screen from top to bottom +102 # don't move the cursor or anything +103 fn render-stack-from-top _self: (addr grapheme-stack), screen: (addr screen) { +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 print-grapheme screen, *g +116 i <- decrement +117 loop +118 } +119 } +120 +121 # compare from bottom +122 # beware: modifies 'stream', which must be disposed of after a false result +123 fn prefix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> result/eax: boolean { +124 $prefix-match?:body: { +125 var self/esi: (addr grapheme-stack) <- copy _self +126 var data-ah/edi: (addr handle array grapheme) <- get self, data +127 var _data/eax: (addr array grapheme) <- lookup *data-ah +128 var data/edi: (addr array grapheme) <- copy _data +129 var top-addr/ecx: (addr int) <- get self, top +130 var i/ebx: int <- copy 0 +131 { +132 compare i, *top-addr +133 break-if->= +134 # if curr != expected, return false +135 { +136 var curr-a/edx: (addr grapheme) <- index data, i +137 var expected/eax: grapheme <- read-grapheme s +138 { +139 compare expected, *curr-a +140 break-if-= +141 result <- copy 0 # false +142 break $prefix-match?:body +143 } +144 } +145 i <- increment +146 loop +147 } +148 result <- copy 1 # true +149 } +150 } +151 +152 # compare from bottom +153 # beware: modifies 'stream', which must be disposed of after a false result +154 fn suffix-match? _self: (addr grapheme-stack), s: (addr stream byte) -> result/eax: boolean { +155 $suffix-match?:body: { +156 var self/esi: (addr grapheme-stack) <- copy _self +157 var data-ah/edi: (addr handle array grapheme) <- get self, data +158 var _data/eax: (addr array grapheme) <- lookup *data-ah +159 var data/edi: (addr array grapheme) <- copy _data +160 var top-addr/eax: (addr int) <- get self, top +161 var i/ebx: int <- copy *top-addr +162 i <- decrement +163 { +164 compare i, 0 +165 break-if-< +166 { +167 var curr-a/edx: (addr grapheme) <- index data, i +168 var expected/eax: grapheme <- read-grapheme s +169 # if curr != expected, return false +170 { +171 compare expected, *curr-a +172 break-if-= +173 result <- copy 0 # false +174 break $suffix-match?:body +175 } +176 } +177 i <- decrement +178 loop +179 } +180 result <- copy 1 # true +181 } +182 } +183 +184 fn grapheme-stack-is-decimal-integer? _self: (addr grapheme-stack) -> result/eax: boolean { +185 var self/esi: (addr grapheme-stack) <- copy _self +186 var data-ah/eax: (addr handle array grapheme) <- get self, data +187 var _data/eax: (addr array grapheme) <- lookup *data-ah +188 var data/edx: (addr array grapheme) <- copy _data +189 var top-addr/ecx: (addr int) <- get self, top +190 var i/ebx: int <- copy 0 +191 $grapheme-stack-is-integer?:loop: { +192 compare i, *top-addr +193 break-if->= +194 var g/edx: (addr grapheme) <- index data, i +195 result <- is-decimal-digit? *g +196 compare result, 0 # false +197 break-if-= +198 i <- increment +199 loop +200 } +201 } -- cgit 1.4.1-2-gfad0