akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

6774

This commit is contained in:
Kartik Agaram 2020-09-11 00:59:56 -07:00
parent 3a4be20aba
commit 91a5f3e103
26 changed files with 2627 additions and 1228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
html/109stream-equal.subx.html generated
View File

@ -621,7 +621,7 @@ if ('onhashchange' in window) {
<span id="L562" class="LineNr">562 </span> c3/return
<span id="L563" class="LineNr">563 </span>
<span id="L564" class="LineNr">564 </span><span class="subxComment"># helper for later tests</span>
<span id="L565" class="LineNr">565 </span><span class="subxFunction">check-next-stream-line-equal</span>:
<span id="L565" class="LineNr">565 </span><span class="subxFunction">check-next-stream-line-equal</span>: <span class="subxComment"># f: (addr stream byte), s: (addr array byte), msg: (addr array byte)</span>
<span id="L566" class="LineNr">566 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L567" class="LineNr">567 </span> 55/push-ebp
<span id="L568" class="LineNr">568 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>

2
html/112read-byte.subx.html generated
View File

@ -331,7 +331,7 @@ if ('onhashchange' in window) {
<span id="L269" class="LineNr">269 </span> c3/return
<span id="L270" class="LineNr">270 </span>
<span id="L271" class="LineNr">271 </span><span class="subxComment"># Return next byte value in eax, with top 3 bytes cleared.</span>
<span id="L272" class="LineNr">272 </span><span class="subxComment"># Abort on reaching end of file.</span>
<span id="L272" class="LineNr">272 </span><span class="subxComment"># Abort on reaching end of stream.</span>
<span id="L273" class="LineNr">273 </span><span class="subxFunction">read-byte</span>: <span class="subxComment"># s: (addr stream byte) -&gt; result/eax: byte</span>
<span id="L274" class="LineNr">274 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L275" class="LineNr">275 </span> 55/push-ebp

2
html/117write-int-hex.subx.html generated
View File

@ -414,7 +414,7 @@ if ('onhashchange' in window) {
<span id="L353" class="LineNr">353 </span> e8/call <a href='115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L354" class="LineNr">354 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L355" class="LineNr">355 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L356" class="Folded">356 </span><span class="Folded">+-- 18 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L356" class="Folded">356 </span><span class="Folded">+-- 18 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L374" class="LineNr">374 </span> <span class="subxComment"># check-stream-equal(_test-stream, &quot;0x008899aa&quot;, msg)</span>
<span id="L375" class="LineNr">375 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L376" class="LineNr">376 </span> 68/push <span class="Constant">&quot;F - test-write-int32-hex-buffered&quot;</span>/imm32

2
html/123slice.subx.html generated
View File

@ -1228,7 +1228,7 @@ if ('onhashchange' in window) {
<span id="L1167" class="LineNr">1167 </span> 8b/copy 1/mod/*+disp8 3/rm32/ebx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ebx+4) to eax</span>
<span id="L1168" class="LineNr">1168 </span> <span class="subxComment"># skip payload-&gt;allocid</span>
<span id="L1169" class="LineNr">1169 </span> 05/add-to-eax 4/imm32
<span id="L1170" class="Folded">1170 </span><span class="Folded">+-- 26 lines: #? # dump eax ---------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1170" class="Folded">1170 </span><span class="Folded">+-- 26 lines: #? # dump eax ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1196" class="LineNr">1196 </span> <span class="subxComment"># eax = string-equal?(eax, &quot;Abc&quot;)</span>
<span id="L1197" class="LineNr">1197 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1198" class="LineNr">1198 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32

2
html/126write-int-decimal.subx.html generated
View File

@ -298,7 +298,7 @@ if ('onhashchange' in window) {
<span id="L235" class="LineNr">235 </span> e8/call <a href='126write-int-decimal.subx.html#L8'>write-int32-decimal</a>/disp32
<span id="L236" class="LineNr">236 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L237" class="LineNr">237 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L238" class="Folded">238 </span><span class="Folded">+-- 26 lines: #? # dump _test-stream ------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L238" class="Folded">238 </span><span class="Folded">+-- 26 lines: #? # dump _test-stream ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L264" class="LineNr">264 </span> <span class="subxComment"># check-stream-equal(_test-stream, &quot;-9&quot;, msg)</span>
<span id="L265" class="LineNr">265 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L266" class="LineNr">266 </span> 68/push <span class="Constant">&quot;F - test-write-int32-decimal-negative&quot;</span>/imm32

2
html/130emit.subx.html generated
View File

@ -493,7 +493,7 @@ if ('onhashchange' in window) {
<span id="L432" class="LineNr">432 </span> e8/call <a href='115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L433" class="LineNr">433 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L434" class="LineNr">434 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L435" class="Folded">435 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L435" class="Folded">435 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L461" class="LineNr">461 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;abcd/xyz&quot;)</span>
<span id="L462" class="LineNr">462 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L463" class="LineNr">463 </span> 68/push <span class="Constant">&quot;F - test-emit-non-number-with-all-hex-digits&quot;</span>/imm32

2
html/134emit-hex-array.subx.html generated
View File

@ -150,7 +150,7 @@ if ('onhashchange' in window) {
<span id="L90" class="LineNr"> 90 </span> e8/call <a href='115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L91" class="LineNr"> 91 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L92" class="LineNr"> 92 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L93" class="Folded"> 93 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L93" class="Folded"> 93 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L126" class="LineNr">126 </span> <span class="subxComment"># check-next-stream-line-equal(_test-output-stream, &quot;01 02 03 &quot;, msg)</span>
<span id="L127" class="LineNr">127 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L128" class="LineNr">128 </span> 68/push <span class="Constant">&quot;F - test-emit-hex-array&quot;</span>/imm32

47
html/302stack_allocate.subx.html generated
View File

@ -90,33 +90,32 @@ if ('onhashchange' in window) {
<span id="L33" class="LineNr">33 </span><span class="subxComment"># n must be positive</span>
<span id="L34" class="LineNr">34 </span><span class="subxFunction">push-n-zero-bytes</span>: <span class="subxComment"># n: int</span>
<span id="L35" class="LineNr">35 </span><span class="Constant">$push-n-zero-bytes:prologue</span>:
<span id="L36" class="LineNr">36 </span> 89/&lt;- *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L59'>Push-n-zero-bytes-ebp</a></span> 5/r32/ebp <span class="subxComment"># spill ebp without affecting stack</span>
<span id="L36" class="LineNr">36 </span> 89/&lt;- *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L56'>Push-n-zero-bytes-ebp</a></span> 5/r32/ebp <span class="subxComment"># spill ebp without affecting stack</span>
<span id="L37" class="LineNr">37 </span> 89/&lt;- %ebp 4/r32/esp
<span id="L38" class="LineNr">38 </span><span class="Constant">$push-n-zero-bytes:copy-ra</span>:
<span id="L39" class="LineNr">39 </span> <span class="subxComment"># -- esp = ebp</span>
<span id="L40" class="LineNr">40 </span> 50/push-eax
<span id="L41" class="LineNr">41 </span> <span class="subxComment"># -- esp+8 = ebp+4</span>
<span id="L42" class="LineNr">42 </span> <span class="subxComment"># -- esp+4 = ebp</span>
<span id="L43" class="LineNr">43 </span> 8b/-&gt; *(esp+4) 0/r32/eax
<span id="L44" class="LineNr">44 </span> 2b/subtract *(ebp+4) 4/r32/esp
<span id="L45" class="LineNr">45 </span> <span class="subxComment"># -- esp+4+n = ebp</span>
<span id="L46" class="LineNr">46 </span> 89/&lt;- *(esp+4) 0/r32/eax
<span id="L47" class="LineNr">47 </span> 58/pop-to-eax
<span id="L48" class="LineNr">48 </span> <span class="subxComment"># -- esp+n = ebp</span>
<span id="L49" class="LineNr">49 </span><span class="Constant">$push-n-zero-bytes:bulk-cleaning</span>:
<span id="L50" class="LineNr">50 </span> 89/&lt;- *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L61'>Push-n-zero-bytes-esp</a></span> 4/r32/esp
<span id="L51" class="LineNr">51 </span> 81 0/subop/add *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L61'>Push-n-zero-bytes-esp</a></span> 4/imm32
<span id="L52" class="LineNr">52 </span> 81 0/subop/add *(ebp+4) 4/imm32
<span id="L53" class="LineNr">53 </span> (<a href='120allocate.subx.html#L877'>zero-out</a> *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L61'>Push-n-zero-bytes-esp</a></span> *(ebp+4)) <span class="subxComment"># n+4</span>
<span id="L54" class="LineNr">54 </span><span class="Constant">$push-n-zero-bytes:epilogue</span>:
<span id="L55" class="LineNr">55 </span> 8b/-&gt; *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L59'>Push-n-zero-bytes-ebp</a></span> 5/r32/ebp <span class="subxComment"># restore spill</span>
<span id="L56" class="LineNr">56 </span> c3/return
<span id="L57" class="LineNr">57 </span>
<span id="L58" class="LineNr">58 </span>== data
<span id="L59" class="LineNr">59 </span><span class="SpecialChar">Push-n-zero-bytes-ebp</span>: <span class="subxComment"># (addr int)</span>
<span id="L60" class="LineNr">60 </span> 0/imm32
<span id="L61" class="LineNr">61 </span><span class="SpecialChar">Push-n-zero-bytes-esp</span>: <span class="subxComment"># (addr int)</span>
<span id="L62" class="LineNr">62 </span> 0/imm32
<span id="L40" class="LineNr">40 </span> 89/&lt;- *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L60'>Push-n-zero-bytes-eax</a></span> 0/r32/eax
<span id="L41" class="LineNr">41 </span> 8b/-&gt; *esp 0/r32/eax
<span id="L42" class="LineNr">42 </span> 2b/subtract *(ebp+4) 4/r32/esp
<span id="L43" class="LineNr">43 </span> <span class="subxComment"># -- esp+n = ebp</span>
<span id="L44" class="LineNr">44 </span> 89/&lt;- *esp 0/r32/eax
<span id="L45" class="LineNr">45 </span> 8b/-&gt; *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L60'>Push-n-zero-bytes-eax</a></span> 0/r32/eax
<span id="L46" class="LineNr">46 </span><span class="Constant">$push-n-zero-bytes:bulk-cleaning</span>:
<span id="L47" class="LineNr">47 </span> 89/&lt;- *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L58'>Push-n-zero-bytes-esp</a></span> 4/r32/esp
<span id="L48" class="LineNr">48 </span> 81 0/subop/add *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L58'>Push-n-zero-bytes-esp</a></span> 4/imm32
<span id="L49" class="LineNr">49 </span> 81 0/subop/add *(ebp+4) 4/imm32
<span id="L50" class="LineNr">50 </span> (<a href='120allocate.subx.html#L877'>zero-out</a> *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L58'>Push-n-zero-bytes-esp</a></span> *(ebp+4)) <span class="subxComment"># n+4</span>
<span id="L51" class="LineNr">51 </span><span class="Constant">$push-n-zero-bytes:epilogue</span>:
<span id="L52" class="LineNr">52 </span> 8b/-&gt; *<span class="SpecialChar"><a href='302stack_allocate.subx.html#L56'>Push-n-zero-bytes-ebp</a></span> 5/r32/ebp <span class="subxComment"># restore spill</span>
<span id="L53" class="LineNr">53 </span> c3/return
<span id="L54" class="LineNr">54 </span>
<span id="L55" class="LineNr">55 </span>== data
<span id="L56" class="LineNr">56 </span><span class="SpecialChar">Push-n-zero-bytes-ebp</span>: <span class="subxComment"># (addr int)</span>
<span id="L57" class="LineNr">57 </span> 0/imm32
<span id="L58" class="LineNr">58 </span><span class="SpecialChar">Push-n-zero-bytes-esp</span>: <span class="subxComment"># (addr int)</span>
<span id="L59" class="LineNr">59 </span> 0/imm32
<span id="L60" class="LineNr">60 </span><span class="SpecialChar">Push-n-zero-bytes-eax</span>:
<span id="L61" class="LineNr">61 </span> 0/imm32
</pre>
</body>
</html>

216
html/306files.subx.html generated
View File

@ -55,69 +55,159 @@ if ('onhashchange' in window) {
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/306files.subx'>https://github.com/akkartik/mu/blob/master/306files.subx</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span>== code
<span id="L2" class="LineNr"> 2 </span>
<span id="L3" class="LineNr"> 3 </span><span class="subxFunction">open</span>: <span class="subxComment"># filename: (addr array byte), write?: boolean, out: (addr handle buffered-file)</span>
<span id="L4" class="LineNr"> 4 </span> <span class="subxComment"># hard-coded parameter: file-buffer-size of created buffered-file</span>
<span id="L5" class="LineNr"> 5 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L6" class="LineNr"> 6 </span> 55/push-ebp
<span id="L7" class="LineNr"> 7 </span> 89/&lt;- %ebp 4/r32/esp
<span id="L8" class="LineNr"> 8 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L9" class="LineNr"> 9 </span> 50/push-eax
<span id="L10" class="LineNr">10 </span> 51/push-ecx
<span id="L11" class="LineNr">11 </span> 52/push-edx
<span id="L12" class="LineNr">12 </span> 53/push-ebx
<span id="L13" class="LineNr">13 </span> 56/push-esi
<span id="L14" class="LineNr">14 </span> 57/push-edi
<span id="L15" class="LineNr">15 </span> <span class="subxComment"># ecx = filename</span>
<span id="L16" class="LineNr">16 </span> 8b/-&gt; *(ebp+8) 1/r32/ecx
<span id="L17" class="LineNr">17 </span> <span class="subxComment"># var size/edx: int = filename-&gt;length + 1 for the trailing null character</span>
<span id="L18" class="LineNr">18 </span> 8b/-&gt; *ecx 2/r32/edx
<span id="L19" class="LineNr">19 </span> 42/increment-edx
<span id="L20" class="LineNr">20 </span> <span class="subxComment"># var s/esi: (stream size)</span>
<span id="L21" class="LineNr">21 </span> 29/subtract-from %esp 2/r32/edx
<span id="L22" class="LineNr">22 </span> 52/push-edx <span class="subxComment"># size</span>
<span id="L23" class="LineNr">23 </span> 68/push 0/imm32/read
<span id="L24" class="LineNr">24 </span> 68/push 0/imm32/write
<span id="L25" class="LineNr">25 </span> 89/&lt;- %esi 4/r32/esp
<span id="L26" class="LineNr">26 </span> <span class="subxComment"># copy filename and a final null character</span>
<span id="L27" class="LineNr">27 </span> (<a href='106stream.subx.html#L17'>clear-stream</a> %esi)
<span id="L28" class="LineNr">28 </span> (<a href='108write.subx.html#L24'>write</a> %esi %ecx)
<span id="L29" class="LineNr">29 </span> <span class="subxComment"># spill edx</span>
<span id="L30" class="LineNr">30 </span> 52/push-edx
<span id="L31" class="LineNr">31 </span> <span class="subxComment"># var fd/ecx: fd = open(filename)</span>
<span id="L32" class="LineNr">32 </span> 8d/copy-address *(esi+0xc) 3/r32/ebx
<span id="L33" class="LineNr">33 </span> 8b/-&gt; *(ebp+0xc) 1/r32/ecx/flags
<span id="L34" class="LineNr">34 </span> ba/copy-to-edx 0x180/imm32/permissions
<span id="L35" class="LineNr">35 </span> e8/call syscall_open/disp32
<span id="L36" class="LineNr">36 </span> 89/&lt;- %ecx 0/r32/eax
<span id="L37" class="LineNr">37 </span> <span class="subxComment"># restore edx</span>
<span id="L38" class="LineNr">38 </span> 5a/pop-to-edx
<span id="L39" class="LineNr">39 </span> <span class="subxComment"># allocate a buffered-file</span>
<span id="L40" class="LineNr">40 </span> (<a href='120allocate.subx.html#L66'>allocate</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> 0x1010 *(ebp+0x10)) <span class="subxComment"># file-buffer-size + 16 for other fields</span>
<span id="L41" class="LineNr">41 </span> <span class="subxComment"># var out-addr/edi: (addr buffered-file)</span>
<span id="L42" class="LineNr">42 </span> 8b/-&gt; *(ebp+0x10) 7/r32/edi
<span id="L43" class="LineNr">43 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *edi *(edi+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L44" class="LineNr">44 </span> 89/&lt;- %edi 0/r32/eax
<span id="L45" class="LineNr">45 </span> <span class="subxComment"># out-addr-&gt;size = 4KB</span>
<span id="L46" class="LineNr">46 </span> c7 0/subop/copy *(edi+0xc) 0x1000/imm32/file-buffer-size <span class="subxComment"># Stream-size + 4 for fd</span>
<span id="L47" class="LineNr">47 </span> <span class="subxComment"># out-addr-&gt;fd = fd</span>
<span id="L48" class="LineNr">48 </span> 89/&lt;- *edi 1/r32/ecx
<span id="L49" class="LineNr">49 </span><span class="Constant">$open:end</span>:
<span id="L50" class="LineNr">50 </span> <span class="subxS1Comment"># . reclaim locals</span>
<span id="L51" class="LineNr">51 </span> 01/add-to %esp 2/r32/edx
<span id="L52" class="LineNr">52 </span> 81 0/subop/add %esp 0xc/imm32
<span id="L53" class="LineNr">53 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L54" class="LineNr">54 </span> 5f/pop-to-edi
<span id="L55" class="LineNr">55 </span> 5e/pop-to-esi
<span id="L56" class="LineNr">56 </span> 5b/pop-to-ebx
<span id="L57" class="LineNr">57 </span> 5a/pop-to-edx
<span id="L58" class="LineNr">58 </span> 59/pop-to-ecx
<span id="L59" class="LineNr">59 </span> 58/pop-to-eax
<span id="L60" class="LineNr">60 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L61" class="LineNr">61 </span> 89/&lt;- %esp 5/r32/ebp
<span id="L62" class="LineNr">62 </span> 5d/pop-to-ebp
<span id="L63" class="LineNr">63 </span> c3/return
<span id="L1" class="LineNr"> 1 </span><span class="subxComment"># Methods for constructing buffered-file objects.</span>
<span id="L2" class="LineNr"> 2 </span><span class="subxComment">#</span>
<span id="L3" class="LineNr"> 3 </span><span class="subxComment"># TODO: There are hard-coded parameters here for buffer sizes. When they</span>
<span id="L4" class="LineNr"> 4 </span><span class="subxComment"># overflow, tracking down what's going on can get hairy.</span>
<span id="L5" class="LineNr"> 5 </span><span class="subxComment">#</span>
<span id="L6" class="LineNr"> 6 </span><span class="subxComment"># HACK: buffered-file stores naked addrs. This is safe because buffered-file</span>
<span id="L7" class="LineNr"> 7 </span><span class="subxComment"># objects are opaque. But still sub-optimal; they'll be harder to reclaim when</span>
<span id="L8" class="LineNr"> 8 </span><span class="subxComment"># we get around to that.</span>
<span id="L9" class="LineNr"> 9 </span>
<span id="L10" class="LineNr"> 10 </span>== code
<span id="L11" class="LineNr"> 11 </span>
<span id="L12" class="LineNr"> 12 </span><span class="subxFunction">open</span>: <span class="subxComment"># filename: (addr array byte), write?: boolean, out: (addr handle buffered-file)</span>
<span id="L13" class="LineNr"> 13 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L14" class="LineNr"> 14 </span> 55/push-ebp
<span id="L15" class="LineNr"> 15 </span> 89/&lt;- %ebp 4/r32/esp
<span id="L16" class="LineNr"> 16 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L17" class="LineNr"> 17 </span> 50/push-eax
<span id="L18" class="LineNr"> 18 </span> 51/push-ecx
<span id="L19" class="LineNr"> 19 </span> 52/push-edx
<span id="L20" class="LineNr"> 20 </span> 53/push-ebx
<span id="L21" class="LineNr"> 21 </span> 56/push-esi
<span id="L22" class="LineNr"> 22 </span> 57/push-edi
<span id="L23" class="LineNr"> 23 </span> <span class="subxComment"># ecx = filename</span>
<span id="L24" class="LineNr"> 24 </span> 8b/-&gt; *(ebp+8) 1/r32/ecx
<span id="L25" class="LineNr"> 25 </span> <span class="subxComment"># var size/edx: int = filename-&gt;length + 1 for the trailing null character</span>
<span id="L26" class="LineNr"> 26 </span> 8b/-&gt; *ecx 2/r32/edx
<span id="L27" class="LineNr"> 27 </span> 42/increment-edx
<span id="L28" class="LineNr"> 28 </span> <span class="subxComment"># var s/esi: (stream size)</span>
<span id="L29" class="LineNr"> 29 </span> 29/subtract-from %esp 2/r32/edx
<span id="L30" class="LineNr"> 30 </span> 52/push-edx <span class="subxComment"># size</span>
<span id="L31" class="LineNr"> 31 </span> 68/push 0/imm32/read
<span id="L32" class="LineNr"> 32 </span> 68/push 0/imm32/write
<span id="L33" class="LineNr"> 33 </span> 89/&lt;- %esi 4/r32/esp
<span id="L34" class="LineNr"> 34 </span> <span class="subxComment"># copy filename and a final null character</span>
<span id="L35" class="LineNr"> 35 </span> (<a href='106stream.subx.html#L17'>clear-stream</a> %esi)
<span id="L36" class="LineNr"> 36 </span> (<a href='108write.subx.html#L24'>write</a> %esi %ecx)
<span id="L37" class="LineNr"> 37 </span> <span class="subxComment"># spill edx</span>
<span id="L38" class="LineNr"> 38 </span> 52/push-edx
<span id="L39" class="LineNr"> 39 </span> <span class="subxComment"># var fd/ecx: fd = open(filename)</span>
<span id="L40" class="LineNr"> 40 </span> 8d/copy-address *(esi+0xc) 3/r32/ebx
<span id="L41" class="LineNr"> 41 </span> 8b/-&gt; *(ebp+0xc) 1/r32/ecx/flags
<span id="L42" class="LineNr"> 42 </span> ba/copy-to-edx 0x180/imm32/permissions
<span id="L43" class="LineNr"> 43 </span> e8/call syscall_open/disp32
<span id="L44" class="LineNr"> 44 </span> 89/&lt;- %ecx 0/r32/eax
<span id="L45" class="LineNr"> 45 </span> <span class="subxComment"># restore edx</span>
<span id="L46" class="LineNr"> 46 </span> 5a/pop-to-edx
<span id="L47" class="LineNr"> 47 </span> <span class="subxComment"># allocate a buffered-file</span>
<span id="L48" class="LineNr"> 48 </span> (<a href='120allocate.subx.html#L66'>allocate</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> 0x1010 *(ebp+0x10)) <span class="subxComment"># file-buffer-size + 16 for other fields</span>
<span id="L49" class="LineNr"> 49 </span> <span class="subxComment"># var out-addr/edi: (addr buffered-file)</span>
<span id="L50" class="LineNr"> 50 </span> 8b/-&gt; *(ebp+0x10) 7/r32/edi
<span id="L51" class="LineNr"> 51 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *edi *(edi+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L52" class="LineNr"> 52 </span> 89/&lt;- %edi 0/r32/eax
<span id="L53" class="LineNr"> 53 </span> <span class="subxComment"># out-addr-&gt;size = 4KB</span>
<span id="L54" class="LineNr"> 54 </span> c7 0/subop/copy *(edi+0xc) 0x1000/imm32/file-buffer-size <span class="subxComment"># Stream-size + 4 for fd</span>
<span id="L55" class="LineNr"> 55 </span> <span class="subxComment"># out-addr-&gt;fd = fd</span>
<span id="L56" class="LineNr"> 56 </span> 89/&lt;- *edi 1/r32/ecx
<span id="L57" class="LineNr"> 57 </span><span class="Constant">$open:end</span>:
<span id="L58" class="LineNr"> 58 </span> <span class="subxS1Comment"># . reclaim locals</span>
<span id="L59" class="LineNr"> 59 </span> 01/add-to %esp 2/r32/edx
<span id="L60" class="LineNr"> 60 </span> 81 0/subop/add %esp 0xc/imm32
<span id="L61" class="LineNr"> 61 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L62" class="LineNr"> 62 </span> 5f/pop-to-edi
<span id="L63" class="LineNr"> 63 </span> 5e/pop-to-esi
<span id="L64" class="LineNr"> 64 </span> 5b/pop-to-ebx
<span id="L65" class="LineNr"> 65 </span> 5a/pop-to-edx
<span id="L66" class="LineNr"> 66 </span> 59/pop-to-ecx
<span id="L67" class="LineNr"> 67 </span> 58/pop-to-eax
<span id="L68" class="LineNr"> 68 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L69" class="LineNr"> 69 </span> 89/&lt;- %esp 5/r32/ebp
<span id="L70" class="LineNr"> 70 </span> 5d/pop-to-ebp
<span id="L71" class="LineNr"> 71 </span> c3/return
<span id="L72" class="LineNr"> 72 </span>
<span id="L73" class="LineNr"> 73 </span><span class="subxFunction">populate-buffered-file-containing</span>: <span class="subxComment"># contents: (addr array byte), out: (addr handle buffered-file)</span>
<span id="L74" class="LineNr"> 74 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L75" class="LineNr"> 75 </span> 55/push-ebp
<span id="L76" class="LineNr"> 76 </span> 89/&lt;- %ebp 4/r32/esp
<span id="L77" class="LineNr"> 77 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L78" class="LineNr"> 78 </span> 50/push-eax
<span id="L79" class="LineNr"> 79 </span> 51/push-ecx
<span id="L80" class="LineNr"> 80 </span> 56/push-esi
<span id="L81" class="LineNr"> 81 </span> 57/push-edi
<span id="L82" class="LineNr"> 82 </span> <span class="subxComment"># esi = contents</span>
<span id="L83" class="LineNr"> 83 </span> 8b/-&gt; *(ebp+8) 6/r32/esi
<span id="L84" class="LineNr"> 84 </span> <span class="subxComment"># var n/ecx: int = len(contents)</span>
<span id="L85" class="LineNr"> 85 </span> 8b/-&gt; *esi 1/r32/ecx
<span id="L86" class="LineNr"> 86 </span> <span class="subxComment"># var stream/edi: (handle stream byte)</span>
<span id="L87" class="LineNr"> 87 </span> 68/push 0/imm32
<span id="L88" class="LineNr"> 88 </span> 68/push 0/imm32
<span id="L89" class="LineNr"> 89 </span> 89/&lt;- %edi 4/r32/esp
<span id="L90" class="LineNr"> 90 </span> <span class="subxComment"># allocate stream</span>
<span id="L91" class="LineNr"> 91 </span> (<a href='121new-stream.subx.html#L8'>new-stream</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> %ecx 1 %edi)
<span id="L92" class="LineNr"> 92 </span> <span class="subxComment"># var stream-addr/edi: (addr stream byte) = lookup(stream)</span>
<span id="L93" class="LineNr"> 93 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *edi *(edi+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L94" class="LineNr"> 94 </span> 89/&lt;- %edi 0/r32/eax
<span id="L95" class="LineNr"> 95 </span> <span class="subxComment"># write contents to stream</span>
<span id="L96" class="LineNr"> 96 </span> (<a href='108write.subx.html#L24'>write</a> %edi %esi)
<span id="L97" class="LineNr"> 97 </span> <span class="subxComment"># allocate buffered-file</span>
<span id="L98" class="LineNr"> 98 </span> (<a href='120allocate.subx.html#L66'>allocate</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> 0x110 *(ebp+0xc))
<span id="L99" class="LineNr"> 99 </span> <span class="subxComment"># var out-addr/eax: (addr buffered-file)</span>
<span id="L100" class="LineNr">100 </span> 8b/-&gt; *(ebp+0xc) 0/r32/eax
<span id="L101" class="LineNr">101 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *eax *(eax+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L102" class="LineNr">102 </span> <span class="subxComment"># out-addr-&gt;size = 256 bytes</span>
<span id="L103" class="LineNr">103 </span> c7 0/subop/copy *(eax+0xc) 0x100/imm32/file-buffer-size
<span id="L104" class="LineNr">104 </span> <span class="subxComment"># out-addr-&gt;fd = stream</span>
<span id="L105" class="LineNr">105 </span> 89/&lt;- *eax 7/r32/edi
<span id="L106" class="LineNr">106 </span><span class="Constant">$populate-buffered-file-containing:end</span>:
<span id="L107" class="LineNr">107 </span> <span class="subxS1Comment"># . reclaim locals</span>
<span id="L108" class="LineNr">108 </span> 81 0/subop/add %esp 8/imm32
<span id="L109" class="LineNr">109 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L110" class="LineNr">110 </span> 5f/pop-to-edi
<span id="L111" class="LineNr">111 </span> 5e/pop-to-esi
<span id="L112" class="LineNr">112 </span> 59/pop-to-ecx
<span id="L113" class="LineNr">113 </span> 58/pop-to-eax
<span id="L114" class="LineNr">114 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L115" class="LineNr">115 </span> 89/&lt;- %esp 5/r32/ebp
<span id="L116" class="LineNr">116 </span> 5d/pop-to-ebp
<span id="L117" class="LineNr">117 </span> c3/return
<span id="L118" class="LineNr">118 </span>
<span id="L119" class="LineNr">119 </span><span class="subxFunction">new-buffered-file</span>: <span class="subxComment"># out: (addr handle buffered-file)</span>
<span id="L120" class="LineNr">120 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L121" class="LineNr">121 </span> 55/push-ebp
<span id="L122" class="LineNr">122 </span> 89/&lt;- %ebp 4/r32/esp
<span id="L123" class="LineNr">123 </span> <span class="subxS1Comment"># . save registers</span>
<span id="L124" class="LineNr">124 </span> 50/push-eax
<span id="L125" class="LineNr">125 </span> 51/push-ecx
<span id="L126" class="LineNr">126 </span> <span class="subxComment"># var stream/ecx: (handle stream byte)</span>
<span id="L127" class="LineNr">127 </span> 68/push 0/imm32
<span id="L128" class="LineNr">128 </span> 68/push 0/imm32
<span id="L129" class="LineNr">129 </span> 89/&lt;- %ecx 4/r32/esp
<span id="L130" class="LineNr">130 </span> <span class="subxComment"># allocate stream</span>
<span id="L131" class="LineNr">131 </span> (<a href='121new-stream.subx.html#L8'>new-stream</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> 0x100 1 %ecx)
<span id="L132" class="LineNr">132 </span> <span class="subxComment"># var stream-addr/ecx: (addr stream byte) = lookup(stream)</span>
<span id="L133" class="LineNr">133 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *ecx *(ecx+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L134" class="LineNr">134 </span> 89/&lt;- %ecx 0/r32/eax
<span id="L135" class="LineNr">135 </span> <span class="subxComment"># allocate buffered-file</span>
<span id="L136" class="LineNr">136 </span> (<a href='120allocate.subx.html#L66'>allocate</a> <span class="SpecialChar"><a href='120allocate.subx.html#L27'>Heap</a></span> 0x110 *(ebp+8))
<span id="L137" class="LineNr">137 </span> <span class="subxComment"># var out-addr/eax: (addr buffered-file)</span>
<span id="L138" class="LineNr">138 </span> 8b/-&gt; *(ebp+8) 0/r32/eax
<span id="L139" class="LineNr">139 </span> (<a href='120allocate.subx.html#L256'>lookup</a> *eax *(eax+4)) <span class="subxComment"># =&gt; eax</span>
<span id="L140" class="LineNr">140 </span> <span class="subxComment"># out-addr-&gt;size = 256 bytes</span>
<span id="L141" class="LineNr">141 </span> c7 0/subop/copy *(eax+0xc) 0x100/imm32/file-buffer-size
<span id="L142" class="LineNr">142 </span> <span class="subxComment"># out-addr-&gt;fd = stream</span>
<span id="L143" class="LineNr">143 </span> 89/&lt;- *eax 1/r32/ecx
<span id="L144" class="LineNr">144 </span><span class="Constant">$new-buffered-file:end</span>:
<span id="L145" class="LineNr">145 </span> <span class="subxS1Comment"># . reclaim locals</span>
<span id="L146" class="LineNr">146 </span> 81 0/subop/add %esp 8/imm32
<span id="L147" class="LineNr">147 </span> <span class="subxS1Comment"># . restore registers</span>
<span id="L148" class="LineNr">148 </span> 59/pop-to-ecx
<span id="L149" class="LineNr">149 </span> 58/pop-to-eax
<span id="L150" class="LineNr">150 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L151" class="LineNr">151 </span> 89/&lt;- %esp 5/r32/ebp
<span id="L152" class="LineNr">152 </span> 5d/pop-to-ebp
<span id="L153" class="LineNr">153 </span> c3/return
</pre>
</body>
</html>

18
html/400.mu.html generated
View File

@ -101,7 +101,7 @@ if ('onhashchange' in window) {
<span id="L46" class="LineNr"> 46 </span><span class="PreProc">sig</span> <a href='109stream-equal.subx.html#L9'>stream-data-equal?</a> f: (addr stream byte), s: (addr array byte)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L47" class="LineNr"> 47 </span><span class="PreProc">sig</span> <a href='109stream-equal.subx.html#L194'>check-stream-equal</a> f: (addr stream byte), s: (addr array byte), msg: (addr array byte)
<span id="L48" class="LineNr"> 48 </span><span class="PreProc">sig</span> <a href='109stream-equal.subx.html#L230'>next-stream-line-equal?</a> f: (addr stream byte), s: (addr array byte)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L49" class="LineNr"> 49 </span><span class="PreProc">sig</span> <a href='109stream-equal.subx.html#L565'>check-next-stream-line-equal</a>
<span id="L49" class="LineNr"> 49 </span><span class="PreProc">sig</span> <a href='109stream-equal.subx.html#L565'>check-next-stream-line-equal</a> f: (addr stream byte), s: (addr array byte), msg: (addr array byte)
<span id="L50" class="LineNr"> 50 </span><span class="PreProc">sig</span> <a href='110stop.subx.html#L44'>tailor-exit-descriptor</a> ed: (addr exit-descriptor), nbytes: int
<span id="L51" class="LineNr"> 51 </span><span class="PreProc">sig</span> <a href='110stop.subx.html#L92'>stop</a> ed: (addr exit-descriptor), value: int
<span id="L52" class="LineNr"> 52 </span><span class="Comment">#sig read f: fd or (addr stream byte), s: (addr stream byte) -&gt; num-bytes-read/eax: int</span>
@ -212,13 +212,15 @@ if ('onhashchange' in window) {
<span id="L157" class="LineNr">157 </span><span class="PreProc">sig</span> <a href='305keyboard.subx.html#L6'>enable-keyboard-immediate-mode</a>
<span id="L158" class="LineNr">158 </span><span class="PreProc">sig</span> <a href='305keyboard.subx.html#L72'>enable-keyboard-type-mode</a>
<span id="L159" class="LineNr">159 </span><span class="PreProc">sig</span> <a href='305keyboard.subx.html#L122'>read-key</a><span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: byte
<span id="L160" class="LineNr">160 </span><span class="PreProc">sig</span> <a href='306files.subx.html#L3'>open</a> filename: (addr array byte), write?: boolean, out: (addr handle buffered-file)
<span id="L161" class="LineNr">161 </span><span class="Comment">#sig size in: (addr array _) -&gt; result/eax: int</span>
<span id="L162" class="LineNr">162 </span>
<span id="L163" class="LineNr">163 </span><span class="PreProc">sig</span> <a href='309stream.subx.html#L6'>stream-empty?</a> s: (addr stream _)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L164" class="LineNr">164 </span><span class="PreProc">sig</span> <a href='309stream.subx.html#L30'>stream-full?</a> s: (addr stream _)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L165" class="LineNr">165 </span>
<span id="L166" class="LineNr">166 </span><span class="PreProc">sig</span> <a href='310copy-bytes.subx.html#L5'>copy-bytes</a> src: (addr byte), dest: (addr byte), n: int
<span id="L160" class="LineNr">160 </span><span class="PreProc">sig</span> <a href='306files.subx.html#L12'>open</a> filename: (addr array byte), write?: boolean, out: (addr handle buffered-file)
<span id="L161" class="LineNr">161 </span><span class="PreProc">sig</span> <a href='306files.subx.html#L73'>populate-buffered-file-containing</a> contents: (addr array byte), out: (addr handle buffered-file)
<span id="L162" class="LineNr">162 </span><span class="PreProc">sig</span> <a href='306files.subx.html#L119'>new-buffered-file</a> out: (addr handle buffered-file)
<span id="L163" class="LineNr">163 </span><span class="Comment">#sig size in: (addr array _) -&gt; result/eax: int</span>
<span id="L164" class="LineNr">164 </span>
<span id="L165" class="LineNr">165 </span><span class="PreProc">sig</span> <a href='309stream.subx.html#L6'>stream-empty?</a> s: (addr stream _)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L166" class="LineNr">166 </span><span class="PreProc">sig</span> <a href='309stream.subx.html#L30'>stream-full?</a> s: (addr stream _)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean
<span id="L167" class="LineNr">167 </span>
<span id="L168" class="LineNr">168 </span><span class="PreProc">sig</span> <a href='310copy-bytes.subx.html#L5'>copy-bytes</a> src: (addr byte), dest: (addr byte), n: int
</pre>
</body>
</html>

173
html/403unicode.mu.html generated
View File

@ -275,7 +275,7 @@ if ('onhashchange' in window) {
<span id="L215" class="LineNr">215 </span> <span class="PreProc">break-if-&lt;=</span>
<span id="L216" class="LineNr">216 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='112read-byte.subx.html#L273'>read-byte</a> in
<span id="L217" class="LineNr">217 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy tmp
<span id="L218" class="LineNr">218 </span> tmp2 <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> tmp2, num-byte-shifts
<span id="L218" class="LineNr">218 </span> tmp2 <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> tmp2, num-byte-shifts
<span id="L219" class="LineNr">219 </span> result <span class="SpecialChar">&lt;-</span> or tmp2
<span id="L220" class="LineNr">220 </span> <span class="Comment"># update loop state</span>
<span id="L221" class="LineNr">221 </span> num-byte-shifts <span class="SpecialChar">&lt;-</span> increment
@ -313,57 +313,126 @@ if ('onhashchange' in window) {
<span id="L253" class="LineNr">253 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> n, <span class="Constant">0x65</span>, <span class="Constant">&quot;F - test grapheme/6&quot;</span>
<span id="L254" class="LineNr">254 </span><span class="Delimiter">}</span>
<span id="L255" class="LineNr">255 </span>
<span id="L256" class="LineNr">256 </span><span class="Comment"># needed because available primitives only shift by a literal/constant number of bits</span>
<span id="L257" class="LineNr">257 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='403unicode.mu.html#L257'>shift-left-bytes</a></span> n: int, k: int<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: int <span class="Delimiter">{</span>
<span id="L258" class="LineNr">258 </span> <span class="PreProc">var</span> i/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L259" class="LineNr">259 </span> result <span class="SpecialChar">&lt;-</span> copy n
<span id="L260" class="LineNr">260 </span> <span class="Delimiter">{</span>
<span id="L261" class="LineNr">261 </span> compare i, k
<span id="L262" class="LineNr">262 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L263" class="LineNr">263 </span> compare i, <span class="Constant">4</span> <span class="Comment"># only 4 bytes in 32 bits</span>
<span id="L264" class="LineNr">264 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L265" class="LineNr">265 </span> result <span class="SpecialChar">&lt;-</span> shift-left <span class="Constant">8</span>
<span id="L266" class="LineNr">266 </span> i <span class="SpecialChar">&lt;-</span> increment
<span id="L267" class="LineNr">267 </span> <span class="PreProc">loop</span>
<span id="L268" class="LineNr">268 </span> <span class="Delimiter">}</span>
<span id="L269" class="LineNr">269 </span><span class="Delimiter">}</span>
<span id="L270" class="LineNr">270 </span>
<span id="L271" class="LineNr">271 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L271'>test-shift-left-bytes-0</a></span> <span class="Delimiter">{</span>
<span id="L272" class="LineNr">272 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">0</span>
<span id="L273" class="LineNr">273 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> 0&quot;</span>
<span id="L274" class="LineNr">274 </span><span class="Delimiter">}</span>
<span id="L275" class="LineNr">275 </span>
<span id="L276" class="LineNr">276 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L276'>test-shift-left-bytes-1</a></span> <span class="Delimiter">{</span>
<span id="L277" class="LineNr">277 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">1</span>
<span id="L278" class="LineNr">278 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x100</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> 1&quot;</span>
<span id="L279" class="LineNr">279 </span><span class="Delimiter">}</span>
<span id="L280" class="LineNr">280 </span>
<span id="L281" class="LineNr">281 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L281'>test-shift-left-bytes-2</a></span> <span class="Delimiter">{</span>
<span id="L282" class="LineNr">282 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">2</span>
<span id="L283" class="LineNr">283 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x10000</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> 2&quot;</span>
<span id="L284" class="LineNr">284 </span><span class="Delimiter">}</span>
<span id="L285" class="LineNr">285 </span>
<span id="L286" class="LineNr">286 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L286'>test-shift-left-bytes-3</a></span> <span class="Delimiter">{</span>
<span id="L287" class="LineNr">287 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">3</span>
<span id="L288" class="LineNr">288 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x1000000</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> 3&quot;</span>
<span id="L289" class="LineNr">289 </span><span class="Delimiter">}</span>
<span id="L290" class="LineNr">290 </span>
<span id="L291" class="LineNr">291 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L291'>test-shift-left-bytes-4</a></span> <span class="Delimiter">{</span>
<span id="L292" class="LineNr">292 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">4</span>
<span id="L293" class="LineNr">293 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> 4&quot;</span>
<span id="L294" class="LineNr">294 </span><span class="Delimiter">}</span>
<span id="L295" class="LineNr">295 </span>
<span id="L296" class="LineNr">296 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L296'>test-shift-left-bytes-5</a></span> <span class="Delimiter">{</span>
<span id="L297" class="LineNr">297 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L257'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">5</span>
<span id="L298" class="LineNr">298 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L257'>shift-left-bytes</a> &gt;4&quot;</span>
<span id="L299" class="LineNr">299 </span><span class="Delimiter">}</span>
<span id="L300" class="LineNr">300 </span>
<span id="L301" class="LineNr">301 </span><span class="Comment"># To run all tests, uncomment this and run:</span>
<span id="L302" class="LineNr">302 </span><span class="Comment"># $ ./translate_mu &amp;&amp; ./a.elf</span>
<span id="L303" class="LineNr">303 </span><span class="CommentedCode">#? fn main -&gt; r/ebx: int {</span>
<span id="L304" class="LineNr">304 </span><span class="CommentedCode">#? run-tests</span>
<span id="L305" class="LineNr">305 </span><span class="CommentedCode">#? r &lt;- copy 0</span>
<span id="L306" class="LineNr">306 </span><span class="CommentedCode">#? }</span>
<span id="L256" class="LineNr">256 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='403unicode.mu.html#L256'>read-grapheme-buffered</a></span> in: (addr buffered-file)<span class="PreProc"> -&gt; </span>out/<span class="Constant">eax</span>: grapheme <span class="Delimiter">{</span>
<span id="L257" class="LineNr">257 </span>$read-grapheme-buffered:body: <span class="Delimiter">{</span>
<span id="L258" class="LineNr">258 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='112read-byte.subx.html#L38'>read-byte-buffered</a> in
<span id="L259" class="LineNr">259 </span> <span class="PreProc">var</span> num-trailers/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L260" class="LineNr">260 </span> $read-grapheme-buffered:compute-length: <span class="Delimiter">{</span>
<span id="L261" class="LineNr">261 </span> <span class="Comment"># single byte: just return it</span>
<span id="L262" class="LineNr">262 </span> compare c, <span class="Constant">0xc0</span>
<span id="L263" class="LineNr">263 </span> <span class="Delimiter">{</span>
<span id="L264" class="LineNr">264 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L265" class="LineNr">265 </span> out <span class="SpecialChar">&lt;-</span> copy c
<span id="L266" class="LineNr">266 </span> num-trailers <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L267" class="LineNr">267 </span> <span class="PreProc">break</span> $read-grapheme-buffered:body
<span id="L268" class="LineNr">268 </span> <span class="Delimiter">}</span>
<span id="L269" class="LineNr">269 </span> compare c, <span class="Constant">0xfe</span>
<span id="L270" class="LineNr">270 </span> <span class="Delimiter">{</span>
<span id="L271" class="LineNr">271 </span> <span class="PreProc">break-if-&lt;</span>
<span id="L272" class="LineNr">272 </span> out <span class="SpecialChar">&lt;-</span> copy c
<span id="L273" class="LineNr">273 </span> <span class="PreProc">break</span> $read-grapheme-buffered:body
<span id="L274" class="LineNr">274 </span> <span class="Delimiter">}</span>
<span id="L275" class="LineNr">275 </span> <span class="Comment"># 2 bytes</span>
<span id="L276" class="LineNr">276 </span> compare c, <span class="Constant">0xe0</span>
<span id="L277" class="LineNr">277 </span> <span class="Delimiter">{</span>
<span id="L278" class="LineNr">278 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L279" class="LineNr">279 </span> num-trailers <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span>
<span id="L280" class="LineNr">280 </span> <span class="PreProc">break</span> $read-grapheme-buffered:compute-length
<span id="L281" class="LineNr">281 </span> <span class="Delimiter">}</span>
<span id="L282" class="LineNr">282 </span> <span class="Comment"># 3 bytes</span>
<span id="L283" class="LineNr">283 </span> compare c, <span class="Constant">0xf0</span>
<span id="L284" class="LineNr">284 </span> <span class="Delimiter">{</span>
<span id="L285" class="LineNr">285 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L286" class="LineNr">286 </span> num-trailers <span class="SpecialChar">&lt;-</span> copy <span class="Constant">2</span>
<span id="L287" class="LineNr">287 </span> <span class="PreProc">break</span> $read-grapheme-buffered:compute-length
<span id="L288" class="LineNr">288 </span> <span class="Delimiter">}</span>
<span id="L289" class="LineNr">289 </span> <span class="Comment"># 4 bytes</span>
<span id="L290" class="LineNr">290 </span> compare c, <span class="Constant">0xf8</span>
<span id="L291" class="LineNr">291 </span> <span class="Delimiter">{</span>
<span id="L292" class="LineNr">292 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L293" class="LineNr">293 </span> num-trailers <span class="SpecialChar">&lt;-</span> copy <span class="Constant">3</span>
<span id="L294" class="LineNr">294 </span> <span class="PreProc">break</span> $read-grapheme-buffered:compute-length
<span id="L295" class="LineNr">295 </span> <span class="Delimiter">}</span>
<span id="L296" class="LineNr">296 </span>$read-grapheme-buffered:abort: <span class="Delimiter">{</span>
<span id="L297" class="LineNr">297 </span> <span class="Comment"># TODO: print to stderr</span>
<span id="L298" class="LineNr">298 </span> <a href='304screen.subx.html#L122'>print-string-to-real-screen</a> <span class="Constant">&quot;utf-8 encodings larger than 4 bytes are not supported. First byte seen: &quot;</span>
<span id="L299" class="LineNr">299 </span> <span class="PreProc">var</span> n/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy c
<span id="L300" class="LineNr">300 </span> <a href='304screen.subx.html#L213'>print-int32-hex-to-real-screen</a> n
<span id="L301" class="LineNr">301 </span> <a href='304screen.subx.html#L122'>print-string-to-real-screen</a> <span class="Constant">&quot;\n&quot;</span>
<span id="L302" class="LineNr">302 </span> <span class="PreProc">var</span> exit-status/<span class="Constant">ebx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span>
<span id="L303" class="LineNr">303 </span> syscall_exit
<span id="L304" class="LineNr">304 </span> <span class="Delimiter">}</span>
<span id="L305" class="LineNr">305 </span> <span class="Delimiter">}</span>
<span id="L306" class="LineNr">306 </span> <span class="Comment"># prepend trailer bytes</span>
<span id="L307" class="LineNr">307 </span> <span class="PreProc">var</span> result/<span class="Constant">edi</span>: int <span class="SpecialChar">&lt;-</span> copy c
<span id="L308" class="LineNr">308 </span> <span class="PreProc">var</span> num-byte-shifts/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span>
<span id="L309" class="LineNr">309 </span> <span class="Delimiter">{</span>
<span id="L310" class="LineNr">310 </span> compare num-trailers, <span class="Constant">0</span>
<span id="L311" class="LineNr">311 </span> <span class="PreProc">break-if-&lt;=</span>
<span id="L312" class="LineNr">312 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='112read-byte.subx.html#L38'>read-byte-buffered</a> in
<span id="L313" class="LineNr">313 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy tmp
<span id="L314" class="LineNr">314 </span> tmp2 <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> tmp2, num-byte-shifts
<span id="L315" class="LineNr">315 </span> result <span class="SpecialChar">&lt;-</span> or tmp2
<span id="L316" class="LineNr">316 </span> <span class="Comment"># update loop state</span>
<span id="L317" class="LineNr">317 </span> num-byte-shifts <span class="SpecialChar">&lt;-</span> increment
<span id="L318" class="LineNr">318 </span> num-trailers <span class="SpecialChar">&lt;-</span> decrement
<span id="L319" class="LineNr">319 </span> <span class="PreProc">loop</span>
<span id="L320" class="LineNr">320 </span> <span class="Delimiter">}</span>
<span id="L321" class="LineNr">321 </span> out <span class="SpecialChar">&lt;-</span> copy result
<span id="L322" class="LineNr">322 </span><span class="Delimiter">}</span>
<span id="L323" class="LineNr">323 </span><span class="Delimiter">}</span>
<span id="L324" class="LineNr">324 </span>
<span id="L325" class="LineNr">325 </span><span class="Comment"># needed because available primitives only shift by a literal/constant number of bits</span>
<span id="L326" class="LineNr">326 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='403unicode.mu.html#L326'>shift-left-bytes</a></span> n: int, k: int<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: int <span class="Delimiter">{</span>
<span id="L327" class="LineNr">327 </span> <span class="PreProc">var</span> i/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L328" class="LineNr">328 </span> result <span class="SpecialChar">&lt;-</span> copy n
<span id="L329" class="LineNr">329 </span> <span class="Delimiter">{</span>
<span id="L330" class="LineNr">330 </span> compare i, k
<span id="L331" class="LineNr">331 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L332" class="LineNr">332 </span> compare i, <span class="Constant">4</span> <span class="Comment"># only 4 bytes in 32 bits</span>
<span id="L333" class="LineNr">333 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L334" class="LineNr">334 </span> result <span class="SpecialChar">&lt;-</span> shift-left <span class="Constant">8</span>
<span id="L335" class="LineNr">335 </span> i <span class="SpecialChar">&lt;-</span> increment
<span id="L336" class="LineNr">336 </span> <span class="PreProc">loop</span>
<span id="L337" class="LineNr">337 </span> <span class="Delimiter">}</span>
<span id="L338" class="LineNr">338 </span><span class="Delimiter">}</span>
<span id="L339" class="LineNr">339 </span>
<span id="L340" class="LineNr">340 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L340'>test-shift-left-bytes-0</a></span> <span class="Delimiter">{</span>
<span id="L341" class="LineNr">341 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">0</span>
<span id="L342" class="LineNr">342 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> 0&quot;</span>
<span id="L343" class="LineNr">343 </span><span class="Delimiter">}</span>
<span id="L344" class="LineNr">344 </span>
<span id="L345" class="LineNr">345 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L345'>test-shift-left-bytes-1</a></span> <span class="Delimiter">{</span>
<span id="L346" class="LineNr">346 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">1</span>
<span id="L347" class="LineNr">347 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x100</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> 1&quot;</span>
<span id="L348" class="LineNr">348 </span><span class="Delimiter">}</span>
<span id="L349" class="LineNr">349 </span>
<span id="L350" class="LineNr">350 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L350'>test-shift-left-bytes-2</a></span> <span class="Delimiter">{</span>
<span id="L351" class="LineNr">351 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">2</span>
<span id="L352" class="LineNr">352 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x10000</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> 2&quot;</span>
<span id="L353" class="LineNr">353 </span><span class="Delimiter">}</span>
<span id="L354" class="LineNr">354 </span>
<span id="L355" class="LineNr">355 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L355'>test-shift-left-bytes-3</a></span> <span class="Delimiter">{</span>
<span id="L356" class="LineNr">356 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">3</span>
<span id="L357" class="LineNr">357 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0x1000000</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> 3&quot;</span>
<span id="L358" class="LineNr">358 </span><span class="Delimiter">}</span>
<span id="L359" class="LineNr">359 </span>
<span id="L360" class="LineNr">360 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L360'>test-shift-left-bytes-4</a></span> <span class="Delimiter">{</span>
<span id="L361" class="LineNr">361 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">4</span>
<span id="L362" class="LineNr">362 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> 4&quot;</span>
<span id="L363" class="LineNr">363 </span><span class="Delimiter">}</span>
<span id="L364" class="LineNr">364 </span>
<span id="L365" class="LineNr">365 </span><span class="PreProc">fn</span> <span class="muTest"><a href='403unicode.mu.html#L365'>test-shift-left-bytes-5</a></span> <span class="Delimiter">{</span>
<span id="L366" class="LineNr">366 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='403unicode.mu.html#L326'>shift-left-bytes</a> <span class="Constant">1</span>, <span class="Constant">5</span>
<span id="L367" class="LineNr">367 </span> <a href='102test.subx.html#L23'>check-ints-equal</a> result, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='403unicode.mu.html#L326'>shift-left-bytes</a> &gt;4&quot;</span>
<span id="L368" class="LineNr">368 </span><span class="Delimiter">}</span>
<span id="L369" class="LineNr">369 </span>
<span id="L370" class="LineNr">370 </span><span class="Comment"># To run all tests, uncomment this and run:</span>
<span id="L371" class="LineNr">371 </span><span class="Comment"># $ ./translate_mu &amp;&amp; ./a.elf</span>
<span id="L372" class="LineNr">372 </span><span class="CommentedCode">#? fn main -&gt; r/ebx: int {</span>
<span id="L373" class="LineNr">373 </span><span class="CommentedCode">#? run-tests</span>
<span id="L374" class="LineNr">374 </span><span class="CommentedCode">#? r &lt;- copy 0</span>
<span id="L375" class="LineNr">375 </span><span class="CommentedCode">#? }</span>
</pre>
</body>
</html>

23
html/404stream.mu.html generated
View File

@ -102,6 +102,29 @@ if ('onhashchange' in window) {
<span id="L44" class="LineNr">44 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='309stream.subx.html#L30'>stream-full?</a> s2
<span id="L45" class="LineNr">45 </span> <a href='401test.mu.html#L3'>check-true</a> tmp, <span class="Constant">&quot;F - test-stream-full?&quot;</span>
<span id="L46" class="LineNr">46 </span><span class="Delimiter">}</span>
<span id="L47" class="LineNr">47 </span>
<span id="L48" class="LineNr">48 </span><span class="PreProc">fn</span> <span class="muTest"><a href='404stream.mu.html#L48'>test-fake-input-buffered-file</a></span> <span class="Delimiter">{</span>
<span id="L49" class="LineNr">49 </span> <span class="PreProc">var</span> foo: (handle buffered-file)
<span id="L50" class="LineNr">50 </span> <span class="PreProc">var</span> foo-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address foo
<span id="L51" class="LineNr">51 </span> <a href='306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;abc&quot;</span>, foo-ah
<span id="L52" class="LineNr">52 </span> <span class="PreProc">var</span> foo-addr/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='120allocate.subx.html#L256'>lookup</a> foo
<span id="L53" class="LineNr">53 </span> <span class="PreProc">var</span> s: (stream byte <span class="Constant">0x100</span>)
<span id="L54" class="LineNr">54 </span> <span class="PreProc">var</span> result/<span class="Constant">ecx</span>: (addr stream byte) <span class="SpecialChar">&lt;-</span> address s
<span id="L55" class="LineNr">55 </span> <a href='122read-line.subx.html#L9'>read-line-buffered</a> foo-addr, result
<span id="L56" class="LineNr">56 </span> <a href='109stream-equal.subx.html#L194'>check-stream-equal</a> result, <span class="Constant">&quot;abc&quot;</span>, <span class="Constant">&quot;F - test-fake-input-buffered-file&quot;</span>
<span id="L57" class="LineNr">57 </span><span class="Delimiter">}</span>
<span id="L58" class="LineNr">58 </span>
<span id="L59" class="LineNr">59 </span><span class="PreProc">fn</span> <span class="muTest"><a href='404stream.mu.html#L59'>test-fake-output-buffered-file</a></span> <span class="Delimiter">{</span>
<span id="L60" class="LineNr">60 </span> <span class="PreProc">var</span> foo: (handle buffered-file)
<span id="L61" class="LineNr">61 </span> <span class="PreProc">var</span> foo-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address foo
<span id="L62" class="LineNr">62 </span> <a href='306files.subx.html#L119'>new-buffered-file</a> foo-ah
<span id="L63" class="LineNr">63 </span> <span class="PreProc">var</span> foo-addr/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='120allocate.subx.html#L256'>lookup</a> foo
<span id="L64" class="LineNr">64 </span> <a href='116write-buffered.subx.html#L8'>write-buffered</a> foo-addr, <span class="Constant">&quot;abc&quot;</span>
<span id="L65" class="LineNr">65 </span> <span class="PreProc">var</span> s: (stream byte <span class="Constant">0x100</span>)
<span id="L66" class="LineNr">66 </span> <span class="PreProc">var</span> result/<span class="Constant">ecx</span>: (addr stream byte) <span class="SpecialChar">&lt;-</span> address s
<span id="L67" class="LineNr">67 </span> <a href='122read-line.subx.html#L9'>read-line-buffered</a> foo-addr, result
<span id="L68" class="LineNr">68 </span> <a href='109stream-equal.subx.html#L194'>check-stream-equal</a> result, <span class="Constant">&quot;abc&quot;</span>, <span class="Constant">&quot;F - test-fake-output-buffered-file&quot;</span>
<span id="L69" class="LineNr">69 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>

1352
html/405screen.mu.html generated
View File

File diff suppressed because it is too large Load Diff

34
html/apps/assort.subx.html generated
View File

@ -172,7 +172,7 @@ if ('onhashchange' in window) {
<span id="L110" class="LineNr"> 110 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L111" class="LineNr"> 111 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L112" class="LineNr"> 112 </span><span class="Constant">$subx-assort:<a href='../111read.subx.html#L48'>read</a></span>:
<span id="L113" class="Folded"> 113 </span><span class="Folded">+-- 9 lines: #? # print(&quot;read\n&quot;) --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L113" class="Folded"> 113 </span><span class="Folded">+-- 9 lines: #? # print(&quot;read\n&quot;) -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L122" class="LineNr"> 122 </span> <span class="subxComment"># read-segments(in, table)</span>
<span id="L123" class="LineNr"> 123 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L124" class="LineNr"> 124 </span> 51/push-ecx
@ -182,7 +182,7 @@ if ('onhashchange' in window) {
<span id="L128" class="LineNr"> 128 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L129" class="LineNr"> 129 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L130" class="LineNr"> 130 </span><span class="Constant">$subx-assort:<a href='../108write.subx.html#L24'>write</a></span>:
<span id="L131" class="Folded"> 131 </span><span class="Folded">+-- 9 lines: #? # print(&quot;write\n&quot;) -------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L131" class="Folded"> 131 </span><span class="Folded">+-- 9 lines: #? # print(&quot;write\n&quot;) ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L140" class="LineNr"> 140 </span> <span class="subxComment"># write-segments(out, table)</span>
<span id="L141" class="LineNr"> 141 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L142" class="LineNr"> 142 </span> 51/push-ecx
@ -385,7 +385,7 @@ if ('onhashchange' in window) {
<span id="L339" class="LineNr"> 339 </span> <span class="subxComment"># 10 11</span>
<span id="L340" class="LineNr"> 340 </span> <span class="subxComment"># == data 0x0a000000</span>
<span id="L341" class="LineNr"> 341 </span> <span class="subxComment"># 4 5/imm32</span>
<span id="L342" class="Folded"> 342 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L342" class="Folded"> 342 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L375" class="LineNr"> 375 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;== code 0x09000000&quot;, msg)</span>
<span id="L376" class="LineNr"> 376 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L377" class="LineNr"> 377 </span> 68/push <span class="Constant">&quot;F - <a href='assort.subx.html#L158'>test-subx-assort</a>/0&quot;</span>/imm32
@ -537,7 +537,7 @@ if ('onhashchange' in window) {
<span id="L523" class="LineNr"> 523 </span> <span class="subxComment"># if (line-&gt;write == 0) break</span>
<span id="L524" class="LineNr"> 524 </span> 81 7/subop/compare 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/imm32 <span class="subxComment"># compare *ecx</span>
<span id="L525" class="LineNr"> 525 </span> 0f 84/jump-if-= $read-segments:<span class="Constant">break</span>/disp32
<span id="L526" class="Folded"> 526 </span><span class="Folded">+-- 33 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L526" class="Folded"> 526 </span><span class="Folded">+-- 33 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L559" class="LineNr"> 559 </span> <span class="subxComment"># next-word-or-string(line, word-slice)</span>
<span id="L560" class="LineNr"> 560 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L561" class="LineNr"> 561 </span> 52/push-edx
@ -547,7 +547,7 @@ if ('onhashchange' in window) {
<span id="L565" class="LineNr"> 565 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L566" class="LineNr"> 566 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L567" class="LineNr"> 567 </span><span class="Constant">$read-segments:check1</span>:
<span id="L568" class="Folded"> 568 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check1\n&quot;) ------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L568" class="Folded"> 568 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check1\n&quot;) ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L577" class="LineNr"> 577 </span> <span class="subxComment"># if (slice-empty?(word-slice)) continue</span>
<span id="L578" class="LineNr"> 578 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
<span id="L579" class="LineNr"> 579 </span> <span class="subxS2Comment"># . . push args</span>
@ -560,7 +560,7 @@ if ('onhashchange' in window) {
<span id="L586" class="LineNr"> 586 </span> 3d/compare-eax-and 0/imm32/false
<span id="L587" class="LineNr"> 587 </span> 0f 85/jump-if-!= $read-segments:<span class="Constant">loop</span>/disp32
<span id="L588" class="LineNr"> 588 </span><span class="Constant">$read-segments:check-for-comment</span>:
<span id="L589" class="Folded"> 589 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check for comment\n&quot;) -------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L589" class="Folded"> 589 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check for comment\n&quot;) ----------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L598" class="LineNr"> 598 </span> <span class="subxComment"># if (slice-starts-with?(word-slice, &quot;#&quot;)) continue</span>
<span id="L599" class="LineNr"> 599 </span> <span class="subxS1Comment"># . var start/esi: (addr byte) = word-slice-&gt;start</span>
<span id="L600" class="LineNr"> 600 </span> 8b/copy 0/mod/indirect 2/rm32/edx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 6/r32/esi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy *ecx to esi</span>
@ -571,8 +571,8 @@ if ('onhashchange' in window) {
<span id="L605" class="LineNr"> 605 </span> 3d/compare-eax-and 0x23/imm32/hash
<span id="L606" class="LineNr"> 606 </span> 0f 84/jump-if-= $read-segments:<span class="Constant">loop</span>/disp32
<span id="L607" class="LineNr"> 607 </span><span class="Constant">$read-segments:check-for-segment-header</span>:
<span id="L608" class="Folded"> 608 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check for segment header\n&quot;) ------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L617" class="Folded"> 617 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L608" class="Folded"> 608 </span><span class="Folded">+-- 9 lines: #? # print(&quot;check for segment header\n&quot;) ---------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L617" class="Folded"> 617 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L657" class="LineNr"> 657 </span> <span class="subxComment"># if !slice-equal?(word-slice, &quot;==&quot;) goto next check</span>
<span id="L658" class="LineNr"> 658 </span> <span class="subxS1Comment"># . eax = slice-equal?(word-slice, &quot;==&quot;)</span>
<span id="L659" class="LineNr"> 659 </span> <span class="subxS2Comment"># . . push args</span>
@ -593,7 +593,7 @@ if ('onhashchange' in window) {
<span id="L674" class="LineNr"> 674 </span> e8/call <a href='../135next-word-or-string.subx.html#L8'>next-word-or-string</a>/disp32
<span id="L675" class="LineNr"> 675 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L676" class="LineNr"> 676 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L677" class="Folded"> 677 </span><span class="Folded">+-- 40 lines: #? # dump segment name ------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L677" class="Folded"> 677 </span><span class="Folded">+-- 40 lines: #? # dump segment name ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L717" class="LineNr"> 717 </span> <span class="subxComment"># var segment-slot/edi: (addr handle stream byte) = get-or-insert-slice(table, segment-name, row-size=16, Heap)</span>
<span id="L718" class="LineNr"> 718 </span> <span class="subxS1Comment"># . eax = get-or-insert-slice(table, segment-name, row-size=16, Heap)</span>
<span id="L719" class="LineNr"> 719 </span> <span class="subxS2Comment"># . . push args</span>
@ -607,7 +607,7 @@ if ('onhashchange' in window) {
<span id="L727" class="LineNr"> 727 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x10/imm32 <span class="subxComment"># add to esp</span>
<span id="L728" class="LineNr"> 728 </span> <span class="subxS1Comment"># . edi = eax</span>
<span id="L729" class="LineNr"> 729 </span> 89/copy 3/mod/direct 7/rm32/edi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to edi</span>
<span id="L730" class="Folded"> 730 </span><span class="Folded">+-- 33 lines: #? # print(&quot;slot: &quot; segment-slot &quot;\n&quot;) --------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L730" class="Folded"> 730 </span><span class="Folded">+-- 33 lines: #? # print(&quot;slot: &quot; segment-slot &quot;\n&quot;) -----------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L763" class="LineNr"> 763 </span> <span class="subxComment"># if (*segment-slot != 0) update curr-segment and continue</span>
<span id="L764" class="LineNr"> 764 </span> 81 7/subop/compare 0/mod/indirect 7/rm32/edi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/imm32 <span class="subxComment"># compare edi</span>
<span id="L765" class="LineNr"> 765 </span> 0f 84/jump-if-= $read-segments:create-segment/disp32
@ -648,11 +648,11 @@ if ('onhashchange' in window) {
<span id="L800" class="LineNr"> 800 </span> 89/copy 3/mod/direct 3/rm32/ebx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to ebx</span>
<span id="L801" class="LineNr"> 801 </span> <span class="subxComment"># fall through</span>
<span id="L802" class="LineNr"> 802 </span><span class="Constant">$read-segments:regular-line</span>:
<span id="L803" class="Folded"> 803 </span><span class="Folded">+-- 9 lines: #? # print(&quot;regular line\n&quot;) ------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L812" class="Folded"> 812 </span><span class="Folded">+-- 33 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L845" class="Folded"> 845 </span><span class="Folded">+-- 33 lines: #? # print(&quot;addr: &quot; curr-segment-&gt;write &quot;\n&quot;) -------------------------------------------------------------------------------------------------------------------------</span>
<span id="L878" class="Folded"> 878 </span><span class="Folded">+-- 33 lines: #? # print(&quot;write: &quot; curr-segment-&gt;write &quot;\n&quot;) ------------------------------------------------------------------------------------------------------------------------</span>
<span id="L911" class="Folded"> 911 </span><span class="Folded">+-- 33 lines: #? # print(&quot;size: &quot; curr-segment-&gt;size &quot;\n&quot;) --------------------------------------------------------------------------------------------------------------------------</span>
<span id="L803" class="Folded"> 803 </span><span class="Folded">+-- 9 lines: #? # print(&quot;regular line\n&quot;) ---------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L812" class="Folded"> 812 </span><span class="Folded">+-- 33 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L845" class="Folded"> 845 </span><span class="Folded">+-- 33 lines: #? # print(&quot;addr: &quot; curr-segment-&gt;write &quot;\n&quot;) ----------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L878" class="Folded"> 878 </span><span class="Folded">+-- 33 lines: #? # print(&quot;write: &quot; curr-segment-&gt;write &quot;\n&quot;) ---------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L911" class="Folded"> 911 </span><span class="Folded">+-- 33 lines: #? # print(&quot;size: &quot; curr-segment-&gt;size &quot;\n&quot;) -----------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L944" class="LineNr"> 944 </span> <span class="subxComment"># rewind-stream(line)</span>
<span id="L945" class="LineNr"> 945 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L946" class="LineNr"> 946 </span> 51/push-ecx
@ -660,7 +660,7 @@ if ('onhashchange' in window) {
<span id="L948" class="LineNr"> 948 </span> e8/call <a href='../106stream.subx.html#L56'>rewind-stream</a>/disp32
<span id="L949" class="LineNr"> 949 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L950" class="LineNr"> 950 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L951" class="Folded"> 951 </span><span class="Folded">+-- 9 lines: #? # print(&quot;write stream\n&quot;) ------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L951" class="Folded"> 951 </span><span class="Folded">+-- 9 lines: #? # print(&quot;write stream\n&quot;) ---------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L960" class="LineNr"> 960 </span> <span class="subxComment"># write-stream(curr-segment, line)</span>
<span id="L961" class="LineNr"> 961 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L962" class="LineNr"> 962 </span> 51/push-ecx
@ -670,7 +670,7 @@ if ('onhashchange' in window) {
<span id="L966" class="LineNr"> 966 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L967" class="LineNr"> 967 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L968" class="LineNr"> 968 </span> <span class="subxComment"># loop</span>
<span id="L969" class="Folded"> 969 </span><span class="Folded">+-- 9 lines: #? # print(&quot;loop\n&quot;) --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L969" class="Folded"> 969 </span><span class="Folded">+-- 9 lines: #? # print(&quot;loop\n&quot;) -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L978" class="LineNr"> 978 </span> e9/jump $read-segments:<span class="Constant">loop</span>/disp32
<span id="L979" class="LineNr"> 979 </span><span class="Constant">$read-segments:break</span>:
<span id="L980" class="LineNr"> 980 </span><span class="Constant">$read-segments:end</span>:

6
html/apps/braces.subx.html generated
View File

@ -328,7 +328,7 @@ if ('onhashchange' in window) {
<span id="L269" class="LineNr">269 </span> (<a href='braces.subx.html#L77'>subx-braces</a> <a href='../112read-byte.subx.html#L357'>_test-input-buffered-file</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L270" class="LineNr">270 </span> <span class="subxComment"># check that the line just passed through</span>
<span id="L271" class="LineNr">271 </span> (<a href='../115write-byte.subx.html#L81'>flush</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L272" class="Folded">272 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L272" class="Folded">272 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L277" class="LineNr">277 </span> (<a href='../109stream-equal.subx.html#L194'>check-stream-equal</a> <a href='../115write-byte.subx.html#L285'>_test-output-stream</a> <span class="Constant">&quot;== abcd 0x1 \n&quot;</span> <span class="Constant">&quot;F - test-subx-braces-passes-most-words-through&quot;</span>)
<span id="L278" class="LineNr">278 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L279" class="LineNr">279 </span> 89/&lt;- %esp 5/r32/ebp
@ -361,7 +361,7 @@ if ('onhashchange' in window) {
<span id="L306" class="LineNr">306 </span> (<a href='braces.subx.html#L77'>subx-braces</a> <a href='../112read-byte.subx.html#L357'>_test-input-buffered-file</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L307" class="LineNr">307 </span> <span class="subxComment"># check that the line just passed through</span>
<span id="L308" class="LineNr">308 </span> (<a href='../115write-byte.subx.html#L81'>flush</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L309" class="Folded">309 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L309" class="Folded">309 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L314" class="LineNr">314 </span> (<a href='../109stream-equal.subx.html#L194'>check-stream-equal</a> <a href='../115write-byte.subx.html#L285'>_test-output-stream</a> <span class="Constant">&quot;_loop0x00000001:\nab _break0x00000001/imm32 \ncd _loop0x00000001/imm32 \n_break0x00000001:\n&quot;</span> <span class="Constant">&quot;F - test-subx-braces-1&quot;</span>)
<span id="L315" class="LineNr">315 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L316" class="LineNr">316 </span> 89/&lt;- %esp 5/r32/ebp
@ -398,7 +398,7 @@ if ('onhashchange' in window) {
<span id="L347" class="LineNr">347 </span> (<a href='braces.subx.html#L77'>subx-braces</a> <a href='../112read-byte.subx.html#L357'>_test-input-buffered-file</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L348" class="LineNr">348 </span> <span class="subxComment"># check that the line just passed through</span>
<span id="L349" class="LineNr">349 </span> (<a href='../115write-byte.subx.html#L81'>flush</a> <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>)
<span id="L350" class="Folded">350 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L350" class="Folded">350 </span><span class="Folded">+-- 5 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L355" class="LineNr">355 </span> (<a href='../109stream-equal.subx.html#L194'>check-stream-equal</a> <a href='../115write-byte.subx.html#L285'>_test-output-stream</a> <span class="Constant">&quot;_loop0x00000001:\n_loop0x00000002:\nab _break0x00000002/imm32 \n_break0x00000002:\ncd _loop0x00000001/imm32 \n_break0x00000001:\n&quot;</span> <span class="Constant">&quot;F - test-subx-braces-2&quot;</span>)
<span id="L356" class="LineNr">356 </span> <span class="subxS1Comment"># . epilogue</span>
<span id="L357" class="LineNr">357 </span> 89/&lt;- %esp 5/r32/ebp

227
html/apps/browse.mu.html generated
View File

@ -1,227 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - apps/browse.mu</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.LineNr { }
.muFunction { color: #af5f00; text-decoration: underline; }
.SpecialChar { color: #d70000; }
.Comment { color: #005faf; }
.Constant { color: #008787; }
.Folded { color: #080808; background-color: #949494; }
.Delimiter { color: #c000c0; }
.PreProc { color: #c000c0; }
-->
</style>
<script type='text/javascript'>
<!--
/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
var lineNum;
lineNum = window.location.hash;
lineNum = lineNum.substr(1); /* strip off '#' */
if (lineNum.indexOf('L') == -1) {
lineNum = 'L'+lineNum;
}
var lineElem = document.getElementById(lineNum);
/* Always jump to new location even if the line was hidden inside a fold, or
* we corrected the raw number to a line ID.
*/
if (lineElem) {
lineElem.scrollIntoView(true);
}
return true;
}
if ('onhashchange' in window) {
window.onhashchange = JumpToLine;
}
-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/apps/browse.mu'>https://github.com/akkartik/mu/blob/master/apps/browse.mu</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span><span class="Comment"># Render text with word-wrap.</span>
<span id="L2" class="LineNr"> 2 </span><span class="Comment">#</span>
<span id="L3" class="LineNr"> 3 </span><span class="Comment"># To run:</span>
<span id="L4" class="LineNr"> 4 </span><span class="Comment"># $ ./translate_mu apps/browse.mu</span>
<span id="L5" class="LineNr"> 5 </span><span class="Comment"># $ ./a.elf __text_file__</span>
<span id="L6" class="LineNr"> 6 </span><span class="Comment">#</span>
<span id="L7" class="LineNr"> 7 </span><span class="Comment"># Press 'q' to quit. All other keys scroll down.</span>
<span id="L8" class="LineNr"> 8 </span>
<span id="L9" class="LineNr"> 9 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L9'>main</a></span> args-on-stack: (addr array addr array byte)<span class="PreProc"> -&gt; </span>exit-status/<span class="Constant">ebx</span>: int <span class="Delimiter">{</span>
<span id="L10" class="Folded"> 10 </span><span class="Folded">+-- 20 lines: # var file/esi: (addr buffered-file) = open args-on-stack[1] for reading --------------------------------------------------------------------------------------------------</span>
<span id="L30" class="LineNr"> 30 </span> <a href='../304screen.subx.html#L6'>enable-screen-grid-mode</a>
<span id="L31" class="LineNr"> 31 </span> <span class="PreProc">var</span> nrows/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L32" class="LineNr"> 32 </span> <span class="PreProc">var</span> ncols/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L33" class="LineNr"> 33 </span> nrows, ncols <span class="SpecialChar">&lt;-</span> <a href='../405screen.mu.html#L60'>screen-size</a> <span class="Constant">0</span>
<span id="L34" class="LineNr"> 34 </span> <a href='../305keyboard.subx.html#L6'>enable-keyboard-immediate-mode</a>
<span id="L35" class="LineNr"> 35 </span> <span class="Delimiter">{</span>
<span id="L36" class="LineNr"> 36 </span> <a href='browse.mu.html#L51'>render</a> file, nrows, ncols
<span id="L37" class="LineNr"> 37 </span> <span class="PreProc">var</span> key/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='../305keyboard.subx.html#L122'>read-key</a>
<span id="L38" class="LineNr"> 38 </span> compare key, <span class="Constant">0x71</span> <span class="Comment"># 'q'</span>
<span id="L39" class="LineNr"> 39 </span> <span class="PreProc">loop-if-!=</span>
<span id="L40" class="LineNr"> 40 </span> <span class="Delimiter">}</span>
<span id="L41" class="LineNr"> 41 </span> <a href='../305keyboard.subx.html#L72'>enable-keyboard-type-mode</a>
<span id="L42" class="LineNr"> 42 </span> <a href='../304screen.subx.html#L24'>enable-screen-type-mode</a>
<span id="L43" class="LineNr"> 43 </span> exit-status <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L44" class="LineNr"> 44 </span><span class="Delimiter">}</span>
<span id="L45" class="LineNr"> 45 </span>
<span id="L46" class="LineNr"> 46 </span><span class="PreProc">type</span> <a href='browse.mu.html#L46'>render-state</a> <span class="Delimiter">{</span>
<span id="L47" class="LineNr"> 47 </span> current-state: int <span class="Comment"># enum 0: normal, 1: bold</span>
<span id="L48" class="LineNr"> 48 </span><span class="Delimiter">}</span>
<span id="L49" class="LineNr"> 49 </span>
<span id="L50" class="LineNr"> 50 </span><span class="Comment"># decide how to lay out pages on screen</span>
<span id="L51" class="LineNr"> 51 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L51'>render</a></span> in: (addr buffered-file), nrows: int, ncols: int <span class="Delimiter">{</span>
<span id="L52" class="LineNr"> 52 </span> <span class="Comment"># Fit multiple pages on screen on separate columns, each wide enough to read</span>
<span id="L53" class="LineNr"> 53 </span> <span class="Comment"># comfortably.</span>
<span id="L54" class="LineNr"> 54 </span> <span class="Comment"># Pages are separated horizontally by a 'page margin'. Among other reasons,</span>
<span id="L55" class="LineNr"> 55 </span> <span class="Comment"># this allows the odd line to bleed out on the right if necessary.</span>
<span id="L56" class="LineNr"> 56 </span> <span class="Comment">#</span>
<span id="L57" class="LineNr"> 57 </span> <span class="Comment"># hardcoded parameters:</span>
<span id="L58" class="LineNr"> 58 </span> <span class="Comment"># top-margin</span>
<span id="L59" class="LineNr"> 59 </span> <span class="Comment"># page-margin</span>
<span id="L60" class="LineNr"> 60 </span> <span class="Comment"># page-width</span>
<span id="L61" class="LineNr"> 61 </span> <span class="PreProc">var</span> _r: <a href='browse.mu.html#L46'>render-state</a>
<span id="L62" class="LineNr"> 62 </span> <span class="PreProc">var</span> r/<span class="Constant">edi</span>: (addr <a href='browse.mu.html#L46'>render-state</a>) <span class="SpecialChar">&lt;-</span> address _r
<span id="L63" class="LineNr"> 63 </span> <span class="PreProc">var</span> toprow/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">2</span> <span class="Comment"># top-margin</span>
<span id="L64" class="LineNr"> 64 </span> <span class="PreProc">var</span> botrow/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy nrows
<span id="L65" class="LineNr"> 65 </span> <span class="PreProc">var</span> leftcol/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">5</span> <span class="Comment"># page-margin</span>
<span id="L66" class="LineNr"> 66 </span> <span class="PreProc">var</span> rightcol/<span class="Constant">ebx</span>: int <span class="SpecialChar">&lt;-</span> copy leftcol
<span id="L67" class="LineNr"> 67 </span> rightcol <span class="SpecialChar">&lt;-</span> add <span class="Constant">0x40</span> <span class="Comment"># page-width = 64 characters</span>
<span id="L68" class="LineNr"> 68 </span> <a href='../405screen.mu.html#L464'>start-color</a> <span class="Constant">0</span>, <span class="Constant">0xec</span>, <span class="Constant">7</span> <span class="Comment"># 236 = darkish gray</span>
<span id="L69" class="LineNr"> 69 </span> <span class="Delimiter">{</span>
<span id="L70" class="LineNr"> 70 </span> compare rightcol, ncols
<span id="L71" class="LineNr"> 71 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L72" class="LineNr"> 72 </span> <a href='browse.mu.html#L81'>render-page</a> in, toprow, leftcol, botrow, rightcol, r
<span id="L73" class="LineNr"> 73 </span> leftcol <span class="SpecialChar">&lt;-</span> copy rightcol
<span id="L74" class="LineNr"> 74 </span> leftcol <span class="SpecialChar">&lt;-</span> add <span class="Constant">5</span> <span class="Comment"># page-margin</span>
<span id="L75" class="LineNr"> 75 </span> rightcol <span class="SpecialChar">&lt;-</span> copy leftcol
<span id="L76" class="LineNr"> 76 </span> rightcol <span class="SpecialChar">&lt;-</span> add <span class="Constant">0x40</span> <span class="Comment"># page-width</span>
<span id="L77" class="LineNr"> 77 </span> <span class="PreProc">loop</span>
<span id="L78" class="LineNr"> 78 </span> <span class="Delimiter">}</span>
<span id="L79" class="LineNr"> 79 </span><span class="Delimiter">}</span>
<span id="L80" class="LineNr"> 80 </span>
<span id="L81" class="LineNr"> 81 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L81'>render-page</a></span> in: (addr buffered-file), toprow: int, leftcol: int, botrow: int, rightcol: int, r: (addr <a href='browse.mu.html#L46'>render-state</a>) <span class="Delimiter">{</span>
<span id="L82" class="LineNr"> 82 </span> <a href='browse.mu.html#L157'>clear</a> toprow, leftcol, botrow, rightcol
<span id="L83" class="LineNr"> 83 </span> <span class="Comment"># render screen rows</span>
<span id="L84" class="LineNr"> 84 </span> <span class="PreProc">var</span> row/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy toprow
<span id="L85" class="LineNr"> 85 </span>$line-loop: <span class="Delimiter">{</span>
<span id="L86" class="LineNr"> 86 </span> compare row, botrow
<span id="L87" class="LineNr"> 87 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L88" class="LineNr"> 88 </span> <span class="PreProc">var</span> col/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy leftcol
<span id="L89" class="LineNr"> 89 </span> <a href='../405screen.mu.html#L116'>move-cursor</a> <span class="Constant">0</span>, row, col
<span id="L90" class="LineNr"> 90 </span> <span class="Delimiter">{</span>
<span id="L91" class="LineNr"> 91 </span> compare col, rightcol
<span id="L92" class="LineNr"> 92 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L93" class="LineNr"> 93 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='../112read-byte.subx.html#L38'>read-byte-buffered</a> in
<span id="L94" class="LineNr"> 94 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L95" class="LineNr"> 95 </span> <span class="PreProc">break-if-=</span> $line-loop
<span id="L96" class="LineNr"> 96 </span> <a href='browse.mu.html#L109'>update-attributes</a> c, r
<span id="L97" class="LineNr"> 97 </span> compare c, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L98" class="LineNr"> 98 </span> <span class="PreProc">break-if-=</span> <span class="Comment"># no need to print newlines</span>
<span id="L99" class="LineNr"> 99 </span> <span class="PreProc">var</span> g/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> copy c
<span id="L100" class="LineNr">100 </span> <a href='../405screen.mu.html#L206'>print-grapheme</a> <span class="Constant">0</span>, g
<span id="L101" class="LineNr">101 </span> col <span class="SpecialChar">&lt;-</span> increment
<span id="L102" class="LineNr">102 </span> <span class="PreProc">loop</span>
<span id="L103" class="LineNr">103 </span> <span class="Delimiter">}</span>
<span id="L104" class="LineNr">104 </span> row <span class="SpecialChar">&lt;-</span> increment
<span id="L105" class="LineNr">105 </span> <span class="PreProc">loop</span>
<span id="L106" class="LineNr">106 </span> <span class="Delimiter">}</span>
<span id="L107" class="LineNr">107 </span><span class="Delimiter">}</span>
<span id="L108" class="LineNr">108 </span>
<span id="L109" class="LineNr">109 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L109'>update-attributes</a></span> c: byte, _r: (addr <a href='browse.mu.html#L46'>render-state</a>) <span class="Delimiter">{</span>
<span id="L110" class="LineNr">110 </span> <span class="PreProc">var</span> r/<span class="Constant">edi</span>: (addr <a href='browse.mu.html#L46'>render-state</a>) <span class="SpecialChar">&lt;-</span> copy _r
<span id="L111" class="LineNr">111 </span> <span class="PreProc">var</span> state/<span class="Constant">esi</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../131table.subx.html#L26'>get</a> r, current-state
<span id="L112" class="LineNr">112 </span>$update-attributes:check-state: <span class="Delimiter">{</span>
<span id="L113" class="LineNr">113 </span> compare *state, <span class="Constant">0</span> <span class="Comment"># normal</span>
<span id="L114" class="LineNr">114 </span> <span class="Delimiter">{</span>
<span id="L115" class="LineNr">115 </span> <span class="PreProc">break-if-!=</span>
<span id="L116" class="LineNr">116 </span> compare c, <span class="Constant">0x2a</span> <span class="Comment"># '*'</span>
<span id="L117" class="LineNr">117 </span> <span class="Delimiter">{</span>
<span id="L118" class="LineNr">118 </span> <span class="PreProc">break-if-!=</span>
<span id="L119" class="LineNr">119 </span> <span class="Comment"># r-&gt;current-state == 0 &amp;&amp; c == '*'</span>
<span id="L120" class="LineNr">120 </span> <a href='../405screen.mu.html#L487'>start-bold</a> <span class="Constant">0</span>
<span id="L121" class="LineNr">121 </span> copy-to *state, <span class="Constant">1</span>
<span id="L122" class="LineNr">122 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L123" class="LineNr">123 </span> <span class="Delimiter">}</span>
<span id="L124" class="LineNr">124 </span> compare c, <span class="Constant">0x5f</span> <span class="Comment"># '_'</span>
<span id="L125" class="LineNr">125 </span> <span class="Delimiter">{</span>
<span id="L126" class="LineNr">126 </span> <span class="PreProc">break-if-!=</span>
<span id="L127" class="LineNr">127 </span> <span class="Comment"># r-&gt;current-state == 0 &amp;&amp; c == '_'</span>
<span id="L128" class="LineNr">128 </span> <a href='../405screen.mu.html#L487'>start-bold</a> <span class="Constant">0</span>
<span id="L129" class="LineNr">129 </span> copy-to *state, <span class="Constant">1</span>
<span id="L130" class="LineNr">130 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L131" class="LineNr">131 </span> <span class="Delimiter">}</span>
<span id="L132" class="LineNr">132 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L133" class="LineNr">133 </span> <span class="Delimiter">}</span>
<span id="L134" class="LineNr">134 </span> <span class="Delimiter">{</span>
<span id="L135" class="LineNr">135 </span> <span class="PreProc">break-if-=</span>
<span id="L136" class="LineNr">136 </span> compare c, <span class="Constant">0x2a</span> <span class="Comment"># '*'</span>
<span id="L137" class="LineNr">137 </span> <span class="Delimiter">{</span>
<span id="L138" class="LineNr">138 </span> <span class="PreProc">break-if-!=</span>
<span id="L139" class="LineNr">139 </span> <span class="Comment"># r-&gt;current-state == 1 &amp;&amp; c == '*'</span>
<span id="L140" class="LineNr">140 </span> <a href='../405screen.mu.html#L442'>reset-formatting</a> <span class="Constant">0</span>
<span id="L141" class="LineNr">141 </span> copy-to *state, <span class="Constant">0</span>
<span id="L142" class="LineNr">142 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L143" class="LineNr">143 </span> <span class="Delimiter">}</span>
<span id="L144" class="LineNr">144 </span> compare c, <span class="Constant">0x5f</span> <span class="Comment"># '_'</span>
<span id="L145" class="LineNr">145 </span> <span class="Delimiter">{</span>
<span id="L146" class="LineNr">146 </span> <span class="PreProc">break-if-!=</span>
<span id="L147" class="LineNr">147 </span> <span class="Comment"># r-&gt;current-state == 1 &amp;&amp; c == '_'</span>
<span id="L148" class="LineNr">148 </span> <a href='../405screen.mu.html#L442'>reset-formatting</a> <span class="Constant">0</span>
<span id="L149" class="LineNr">149 </span> copy-to *state, <span class="Constant">0</span>
<span id="L150" class="LineNr">150 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L151" class="LineNr">151 </span> <span class="Delimiter">}</span>
<span id="L152" class="LineNr">152 </span> <span class="PreProc">break</span> $update-attributes:check-state
<span id="L153" class="LineNr">153 </span> <span class="Delimiter">}</span>
<span id="L154" class="LineNr">154 </span> <span class="Delimiter">}</span>
<span id="L155" class="LineNr">155 </span><span class="Delimiter">}</span>
<span id="L156" class="LineNr">156 </span>
<span id="L157" class="LineNr">157 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L157'>clear</a></span> toprow: int, leftcol: int, botrow: int, rightcol: int <span class="Delimiter">{</span>
<span id="L158" class="LineNr">158 </span> <span class="PreProc">var</span> row/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy toprow
<span id="L159" class="LineNr">159 </span> <span class="Delimiter">{</span>
<span id="L160" class="LineNr">160 </span> compare row, botrow
<span id="L161" class="LineNr">161 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L162" class="LineNr">162 </span> <span class="PreProc">var</span> col/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy leftcol
<span id="L163" class="LineNr">163 </span> <a href='../405screen.mu.html#L116'>move-cursor</a> <span class="Constant">0</span>, row, col
<span id="L164" class="LineNr">164 </span> <span class="Delimiter">{</span>
<span id="L165" class="LineNr">165 </span> compare col, rightcol
<span id="L166" class="LineNr">166 </span> <span class="PreProc">break-if-&gt;=</span>
<span id="L167" class="LineNr">167 </span> <a href='../405screen.mu.html#L179'>print-string</a> <span class="Constant">0</span>, <span class="Constant">&quot; &quot;</span>
<span id="L168" class="LineNr">168 </span> col <span class="SpecialChar">&lt;-</span> increment
<span id="L169" class="LineNr">169 </span> <span class="PreProc">loop</span>
<span id="L170" class="LineNr">170 </span> <span class="Delimiter">}</span>
<span id="L171" class="LineNr">171 </span> row <span class="SpecialChar">&lt;-</span> increment
<span id="L172" class="LineNr">172 </span> <span class="PreProc">loop</span>
<span id="L173" class="LineNr">173 </span> <span class="Delimiter">}</span>
<span id="L174" class="LineNr">174 </span><span class="Delimiter">}</span>
<span id="L175" class="LineNr">175 </span>
<span id="L176" class="LineNr">176 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='browse.mu.html#L176'>dump</a></span> in: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L177" class="LineNr">177 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='../112read-byte.subx.html#L38'>read-byte-buffered</a> in
<span id="L178" class="LineNr">178 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L179" class="LineNr">179 </span> <span class="PreProc">break-if-=</span>
<span id="L180" class="LineNr">180 </span> <span class="PreProc">var</span> g/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> copy c
<span id="L181" class="LineNr">181 </span> <a href='../405screen.mu.html#L206'>print-grapheme</a> <span class="Constant">0</span>, g
<span id="L182" class="LineNr">182 </span> <span class="PreProc">loop</span>
<span id="L183" class="LineNr">183 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->

461
html/apps/browse/main.mu.html generated Normal file
View File

@ -0,0 +1,461 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - apps/browse/main.mu</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.muTest { color: #5f8700; }
.LineNr { }
.muFunction { color: #af5f00; text-decoration: underline; }
.Comment { color: #005faf; }
.SpecialChar { color: #d70000; }
.Constant { color: #008787; }
.Delimiter { color: #c000c0; }
.PreProc { color: #c000c0; }
.SalientComment { color: #0000af; }
-->
</style>
<script type='text/javascript'>
<!--
/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
var lineNum;
lineNum = window.location.hash;
lineNum = lineNum.substr(1); /* strip off '#' */
if (lineNum.indexOf('L') == -1) {
lineNum = 'L'+lineNum;
}
var lineElem = document.getElementById(lineNum);
/* Always jump to new location even if the line was hidden inside a fold, or
* we corrected the raw number to a line ID.
*/
if (lineElem) {
lineElem.scrollIntoView(true);
}
return true;
}
if ('onhashchange' in window) {
window.onhashchange = JumpToLine;
}
-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/apps/browse/main.mu'>https://github.com/akkartik/mu/blob/master/apps/browse/main.mu</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L1'>main</a></span> args-on-stack: (addr array addr array byte)<span class="PreProc"> -&gt; </span>exit-status/<span class="Constant">ebx</span>: int <span class="Delimiter">{</span>
<span id="L2" class="LineNr"> 2 </span> <span class="PreProc">var</span> args/<span class="Constant">eax</span>: (addr array addr array byte) <span class="SpecialChar">&lt;-</span> copy args-on-stack
<span id="L3" class="LineNr"> 3 </span> <span class="PreProc">var</span> tmp/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> length args
<span id="L4" class="LineNr"> 4 </span> $main-body: <span class="Delimiter">{</span>
<span id="L5" class="LineNr"> 5 </span> <span class="Comment"># if (len(args) &lt;= 1) print usage and exit</span>
<span id="L6" class="LineNr"> 6 </span> compare tmp, <span class="Constant">1</span>
<span id="L7" class="LineNr"> 7 </span> <span class="Delimiter">{</span>
<span id="L8" class="LineNr"> 8 </span> <span class="PreProc">break-if-&gt;</span>
<span id="L9" class="LineNr"> 9 </span> <a href='../../304screen.subx.html#L122'>print-string-to-real-screen</a> <span class="Constant">&quot;usage: browse [filename]\n&quot;</span>
<span id="L10" class="LineNr"> 10 </span> <a href='../../304screen.subx.html#L122'>print-string-to-real-screen</a> <span class="Constant">&quot; or browse test\n&quot;</span>
<span id="L11" class="LineNr"> 11 </span> exit-status <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span>
<span id="L12" class="LineNr"> 12 </span> <span class="PreProc">break</span> $main-body
<span id="L13" class="LineNr"> 13 </span> <span class="Delimiter">}</span>
<span id="L14" class="LineNr"> 14 </span> <span class="Comment"># if (args[1] == &quot;test&quot;) run-tests()</span>
<span id="L15" class="LineNr"> 15 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">ecx</span>: (addr addr array byte) <span class="SpecialChar">&lt;-</span> index args, <span class="Constant">1</span>
<span id="L16" class="LineNr"> 16 </span> <span class="PreProc">var</span> tmp3/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='../../105string-equal.subx.html#L15'>string-equal?</a> *tmp2, <span class="Constant">&quot;test&quot;</span>
<span id="L17" class="LineNr"> 17 </span> compare tmp3, <span class="Constant">0</span>
<span id="L18" class="LineNr"> 18 </span> <span class="Delimiter">{</span>
<span id="L19" class="LineNr"> 19 </span> <span class="PreProc">break-if-=</span>
<span id="L20" class="LineNr"> 20 </span> run-tests
<span id="L21" class="LineNr"> 21 </span> exit-status <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># TODO: get at Num-test-failures somehow</span>
<span id="L22" class="LineNr"> 22 </span> <span class="PreProc">break</span> $main-body
<span id="L23" class="LineNr"> 23 </span> <span class="Delimiter">}</span>
<span id="L24" class="LineNr"> 24 </span> <span class="Comment"># otherwise interactive mode</span>
<span id="L25" class="LineNr"> 25 </span> exit-status <span class="SpecialChar">&lt;-</span> <a href='main.mu.html#L29'>interactive</a> args-on-stack
<span id="L26" class="LineNr"> 26 </span> <span class="Delimiter">}</span>
<span id="L27" class="LineNr"> 27 </span><span class="Delimiter">}</span>
<span id="L28" class="LineNr"> 28 </span>
<span id="L29" class="LineNr"> 29 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L29'>interactive</a></span> args: (addr array addr array byte)<span class="PreProc"> -&gt; </span>exit-status/<span class="Constant">ebx</span>: int <span class="Delimiter">{</span>
<span id="L30" class="LineNr"> 30 </span> <span class="Comment"># initialize fs from args[1]</span>
<span id="L31" class="LineNr"> 31 </span> <span class="PreProc">var</span> filename/<span class="Constant">eax</span>: (addr array byte) <span class="SpecialChar">&lt;-</span> <a href='main.mu.html#L388'>first-arg</a> args
<span id="L32" class="LineNr"> 32 </span> <span class="PreProc">var</span> file-storage: (handle buffered-file)
<span id="L33" class="LineNr"> 33 </span> <span class="PreProc">var</span> file-storage-addr/<span class="Constant">esi</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address file-storage
<span id="L34" class="LineNr"> 34 </span> <a href='../../306files.subx.html#L12'>open</a> filename, <span class="Constant">0</span>, file-storage-addr
<span id="L35" class="LineNr"> 35 </span> <span class="PreProc">var</span> _fs/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> file-storage
<span id="L36" class="LineNr"> 36 </span> <span class="PreProc">var</span> fs/<span class="Constant">esi</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> copy _fs
<span id="L37" class="LineNr"> 37 </span> <span class="Comment">#</span>
<span id="L38" class="LineNr"> 38 </span> <a href='../../304screen.subx.html#L6'>enable-screen-grid-mode</a>
<span id="L39" class="LineNr"> 39 </span> <a href='../../305keyboard.subx.html#L6'>enable-keyboard-immediate-mode</a>
<span id="L40" class="LineNr"> 40 </span> <span class="Comment"># initialize screen state</span>
<span id="L41" class="LineNr"> 41 </span> <span class="PreProc">var</span> paginated-screen-storage: paginated-screen
<span id="L42" class="LineNr"> 42 </span> <span class="PreProc">var</span> paginated-screen/<span class="Constant">eax</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address paginated-screen-storage
<span id="L43" class="LineNr"> 43 </span> initialize-paginated-screen paginated-screen, <span class="Constant">0x40</span>, <span class="Constant">2</span>, <span class="Constant">5</span>
<span id="L44" class="LineNr"> 44 </span> <a href='main.mu.html#L394'>normal-text</a> paginated-screen
<span id="L45" class="LineNr"> 45 </span> <span class="Comment">#</span>
<span id="L46" class="LineNr"> 46 </span> <span class="Delimiter">{</span>
<span id="L47" class="LineNr"> 47 </span> <a href='main.mu.html#L57'>render</a> paginated-screen, fs
<span id="L48" class="LineNr"> 48 </span> <span class="PreProc">var</span> key/<span class="Constant">eax</span>: byte <span class="SpecialChar">&lt;-</span> <a href='../../305keyboard.subx.html#L122'>read-key</a>
<span id="L49" class="LineNr"> 49 </span> compare key, <span class="Constant">0x71</span> <span class="Comment"># 'q'</span>
<span id="L50" class="LineNr"> 50 </span> <span class="PreProc">loop-if-!=</span>
<span id="L51" class="LineNr"> 51 </span> <span class="Delimiter">}</span>
<span id="L52" class="LineNr"> 52 </span> <a href='../../305keyboard.subx.html#L72'>enable-keyboard-type-mode</a>
<span id="L53" class="LineNr"> 53 </span> <a href='../../304screen.subx.html#L24'>enable-screen-type-mode</a>
<span id="L54" class="LineNr"> 54 </span> exit-status <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L55" class="LineNr"> 55 </span><span class="Delimiter">}</span>
<span id="L56" class="LineNr"> 56 </span>
<span id="L57" class="LineNr"> 57 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L57'>render</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), fs: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L58" class="LineNr"> 58 </span> start-drawing <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L59" class="LineNr"> 59 </span> <a href='main.mu.html#L157'>render-normal</a> <a href='../../405screen.mu.html#L9'>screen</a>, fs
<span id="L60" class="LineNr"> 60 </span><span class="Delimiter">}</span>
<span id="L61" class="LineNr"> 61 </span>
<span id="L62" class="LineNr"> 62 </span><span class="PreProc">fn</span> <span class="muTest"><a href='main.mu.html#L62'>test-render-multicolumn-text</a></span> <span class="Delimiter">{</span>
<span id="L63" class="LineNr"> 63 </span> <span class="Comment"># input text</span>
<span id="L64" class="LineNr"> 64 </span> <span class="PreProc">var</span> input-storage: (handle buffered-file)
<span id="L65" class="LineNr"> 65 </span> <span class="PreProc">var</span> input-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address input-storage
<span id="L66" class="LineNr"> 66 </span> <a href='../../306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;abcdefgh&quot;</span>, input-ah
<span id="L67" class="LineNr"> 67 </span> <span class="PreProc">var</span> in/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> input-storage
<span id="L68" class="LineNr"> 68 </span> <span class="Comment"># output screen</span>
<span id="L69" class="LineNr"> 69 </span> <span class="PreProc">var</span> pg: paginated-screen
<span id="L70" class="LineNr"> 70 </span> <span class="PreProc">var</span> pg-addr/<span class="Constant">ecx</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address pg
<span id="L71" class="LineNr"> 71 </span> initialize-fake-paginated-screen pg-addr, <span class="Constant">3</span>, <span class="Constant">6</span>, <span class="Constant">2</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 3 rows, 6 columns, 2 pages * 2 columns each</span>
<span id="L72" class="LineNr"> 72 </span> <span class="Comment">#</span>
<span id="L73" class="LineNr"> 73 </span> <a href='main.mu.html#L57'>render</a> pg-addr, in
<span id="L74" class="LineNr"> 74 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L75" class="LineNr"> 75 </span> <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L76" class="LineNr"> 76 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">1</span>, <span class="Constant">&quot; &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L62'>test-render-multicolumn-text</a>/row1&quot;</span>
<span id="L77" class="LineNr"> 77 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; ab ef&quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L62'>test-render-multicolumn-text</a>/row2&quot;</span>
<span id="L78" class="LineNr"> 78 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">3</span>, <span class="Constant">&quot; cd gh&quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L62'>test-render-multicolumn-text</a>/row3&quot;</span>
<span id="L79" class="LineNr"> 79 </span><span class="Delimiter">}</span>
<span id="L80" class="LineNr"> 80 </span>
<span id="L81" class="LineNr"> 81 </span><span class="PreProc">fn</span> <span class="muTest"><a href='main.mu.html#L81'>test-render-heading-text</a></span> <span class="Delimiter">{</span>
<span id="L82" class="LineNr"> 82 </span> <span class="Comment"># input text</span>
<span id="L83" class="LineNr"> 83 </span> <span class="PreProc">var</span> input-storage: (handle buffered-file)
<span id="L84" class="LineNr"> 84 </span> <span class="PreProc">var</span> input-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address input-storage
<span id="L85" class="LineNr"> 85 </span> <a href='../../306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;# abc\n\ndef&quot;</span>, input-ah
<span id="L86" class="LineNr"> 86 </span> <span class="PreProc">var</span> in/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> input-storage
<span id="L87" class="LineNr"> 87 </span> <span class="Comment"># output screen</span>
<span id="L88" class="LineNr"> 88 </span> <span class="PreProc">var</span> pg: paginated-screen
<span id="L89" class="LineNr"> 89 </span> <span class="PreProc">var</span> pg-addr/<span class="Constant">ecx</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address pg
<span id="L90" class="LineNr"> 90 </span> initialize-fake-paginated-screen pg-addr, <span class="Constant">8</span>, <span class="Constant">6</span>, <span class="Constant">5</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 6 columns, single page</span>
<span id="L91" class="LineNr"> 91 </span> <span class="Comment">#</span>
<span id="L92" class="LineNr"> 92 </span> <a href='main.mu.html#L57'>render</a> pg-addr, in
<span id="L93" class="LineNr"> 93 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L94" class="LineNr"> 94 </span> <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L95" class="LineNr"> 95 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">1</span>, <span class="Constant">&quot; &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L81'>test-render-heading-text</a>/row1&quot;</span>
<span id="L96" class="LineNr"> 96 </span> <a href='../../405screen.mu.html#L657'>check-screen-row-in-color</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xa0</span>, <span class="Constant">2</span>, <span class="Constant">&quot; abc &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L81'>test-render-heading-text</a>/heading&quot;</span>
<span id="L97" class="LineNr"> 97 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">3</span>, <span class="Constant">&quot; &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L81'>test-render-heading-text</a>/row3&quot;</span>
<span id="L98" class="LineNr"> 98 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">4</span>, <span class="Constant">&quot; def &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L81'>test-render-heading-text</a>/row4&quot;</span>
<span id="L99" class="LineNr"> 99 </span><span class="Delimiter">}</span>
<span id="L100" class="LineNr">100 </span>
<span id="L101" class="LineNr">101 </span><span class="PreProc">fn</span> <span class="muTest"><a href='main.mu.html#L101'>test-render-bold-text</a></span> <span class="Delimiter">{</span>
<span id="L102" class="LineNr">102 </span> <span class="Comment"># input text</span>
<span id="L103" class="LineNr">103 </span> <span class="PreProc">var</span> input-storage: (handle buffered-file)
<span id="L104" class="LineNr">104 </span> <span class="PreProc">var</span> input-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address input-storage
<span id="L105" class="LineNr">105 </span> <a href='../../306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;a *b* c&quot;</span>, input-ah
<span id="L106" class="LineNr">106 </span> <span class="PreProc">var</span> in/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> input-storage
<span id="L107" class="LineNr">107 </span> <span class="Comment"># output screen</span>
<span id="L108" class="LineNr">108 </span> <span class="PreProc">var</span> pg: paginated-screen
<span id="L109" class="LineNr">109 </span> <span class="PreProc">var</span> pg-addr/<span class="Constant">ecx</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address pg
<span id="L110" class="LineNr">110 </span> initialize-fake-paginated-screen pg-addr, <span class="Constant">8</span>, <span class="Constant">6</span>, <span class="Constant">5</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 6 columns, single page</span>
<span id="L111" class="LineNr">111 </span> <span class="Comment">#</span>
<span id="L112" class="LineNr">112 </span> <a href='main.mu.html#L57'>render</a> pg-addr, in
<span id="L113" class="LineNr">113 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L114" class="LineNr">114 </span> <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L115" class="LineNr">115 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; a b c&quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L101'>test-render-bold-text</a>/text&quot;</span>
<span id="L116" class="LineNr">116 </span> <a href='../../405screen.mu.html#L829'>check-screen-row-in-bold</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; b &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L101'>test-render-bold-text</a>/bold&quot;</span>
<span id="L117" class="LineNr">117 </span><span class="Delimiter">}</span>
<span id="L118" class="LineNr">118 </span>
<span id="L119" class="LineNr">119 </span><span class="Comment"># terminals don't always support italics, so we'll just always render italics</span>
<span id="L120" class="LineNr">120 </span><span class="Comment"># as bold.</span>
<span id="L121" class="LineNr">121 </span><span class="PreProc">fn</span> <span class="muTest"><a href='main.mu.html#L121'>test-render-pseudoitalic-text</a></span> <span class="Delimiter">{</span>
<span id="L122" class="LineNr">122 </span> <span class="Comment"># input text</span>
<span id="L123" class="LineNr">123 </span> <span class="PreProc">var</span> input-storage: (handle buffered-file)
<span id="L124" class="LineNr">124 </span> <span class="PreProc">var</span> input-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address input-storage
<span id="L125" class="LineNr">125 </span> <a href='../../306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;a _b_ c&quot;</span>, input-ah
<span id="L126" class="LineNr">126 </span> <span class="PreProc">var</span> in/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> input-storage
<span id="L127" class="LineNr">127 </span> <span class="Comment"># output screen</span>
<span id="L128" class="LineNr">128 </span> <span class="PreProc">var</span> pg: paginated-screen
<span id="L129" class="LineNr">129 </span> <span class="PreProc">var</span> pg-addr/<span class="Constant">ecx</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address pg
<span id="L130" class="LineNr">130 </span> initialize-fake-paginated-screen pg-addr, <span class="Constant">8</span>, <span class="Constant">6</span>, <span class="Constant">5</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 6 columns, single page</span>
<span id="L131" class="LineNr">131 </span> <span class="Comment">#</span>
<span id="L132" class="LineNr">132 </span> <a href='main.mu.html#L57'>render</a> pg-addr, in
<span id="L133" class="LineNr">133 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L134" class="LineNr">134 </span> <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L135" class="LineNr">135 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; a b c&quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L121'>test-render-pseudoitalic-text</a>/text&quot;</span>
<span id="L136" class="LineNr">136 </span> <a href='../../405screen.mu.html#L829'>check-screen-row-in-bold</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; b &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L121'>test-render-pseudoitalic-text</a>/bold&quot;</span>
<span id="L137" class="LineNr">137 </span><span class="Delimiter">}</span>
<span id="L138" class="LineNr">138 </span>
<span id="L139" class="LineNr">139 </span><span class="PreProc">fn</span> <span class="muTest"><a href='main.mu.html#L139'>test-render-asterisk-in-text</a></span> <span class="Delimiter">{</span>
<span id="L140" class="LineNr">140 </span> <span class="Comment"># input text</span>
<span id="L141" class="LineNr">141 </span> <span class="PreProc">var</span> input-storage: (handle buffered-file)
<span id="L142" class="LineNr">142 </span> <span class="PreProc">var</span> input-ah/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address input-storage
<span id="L143" class="LineNr">143 </span> <a href='../../306files.subx.html#L73'>populate-buffered-file-containing</a> <span class="Constant">&quot;a*b*c&quot;</span>, input-ah
<span id="L144" class="LineNr">144 </span> <span class="PreProc">var</span> in/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> input-storage
<span id="L145" class="LineNr">145 </span> <span class="Comment"># output screen</span>
<span id="L146" class="LineNr">146 </span> <span class="PreProc">var</span> pg: paginated-screen
<span id="L147" class="LineNr">147 </span> <span class="PreProc">var</span> pg-addr/<span class="Constant">ecx</span>: (addr paginated-screen) <span class="SpecialChar">&lt;-</span> address pg
<span id="L148" class="LineNr">148 </span> initialize-fake-paginated-screen pg-addr, <span class="Constant">8</span>, <span class="Constant">6</span>, <span class="Constant">5</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 6 columns, single page</span>
<span id="L149" class="LineNr">149 </span> <span class="Comment">#</span>
<span id="L150" class="LineNr">150 </span> <a href='main.mu.html#L57'>render</a> pg-addr, in
<span id="L151" class="LineNr">151 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L152" class="LineNr">152 </span> <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L153" class="LineNr">153 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; a*b*c&quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L101'>test-render-bold-text</a>/text&quot;</span>
<span id="L154" class="LineNr">154 </span> <a href='../../405screen.mu.html#L829'>check-screen-row-in-bold</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">2</span>, <span class="Constant">&quot; &quot;</span>, <span class="Constant">&quot;F - <a href='main.mu.html#L101'>test-render-bold-text</a>/bold&quot;</span>
<span id="L155" class="LineNr">155 </span><span class="Delimiter">}</span>
<span id="L156" class="LineNr">156 </span>
<span id="L157" class="LineNr">157 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L157'>render-normal</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), fs: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L158" class="LineNr">158 </span> <span class="PreProc">var</span> newline-seen?/<span class="Constant">esi</span>: boolean <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L159" class="LineNr">159 </span> <span class="PreProc">var</span> start-of-paragraph?/<span class="Constant">edi</span>: boolean <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># true</span>
<span id="L160" class="LineNr">160 </span> <span class="PreProc">var</span> previous-grapheme/<span class="Constant">ebx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L161" class="LineNr">161 </span>$render-normal:<span class="PreProc">loop</span>: <span class="Delimiter">{</span>
<span id="L162" class="LineNr">162 </span> <span class="Comment"># if done-drawing?(screen) break</span>
<span id="L163" class="LineNr">163 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> done-drawing? <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L164" class="LineNr">164 </span> compare done?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L165" class="LineNr">165 </span> <span class="PreProc">break-if-!=</span>
<span id="L166" class="LineNr">166 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> <a href='../../403unicode.mu.html#L256'>read-grapheme-buffered</a> fs
<span id="L167" class="LineNr">167 </span>$render-normal:loop-body: <span class="Delimiter">{</span>
<span id="L168" class="LineNr">168 </span> <span class="Comment"># if (c == EOF) break</span>
<span id="L169" class="LineNr">169 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L170" class="LineNr">170 </span> <span class="PreProc">break-if-=</span> $render-normal:<span class="PreProc">loop</span>
<span id="L171" class="LineNr">171 </span>
<span id="L172" class="LineNr">172 </span> <span class="SalientComment">## if (c == newline) perform some fairly sophisticated parsing for soft newlines</span>
<span id="L173" class="LineNr">173 </span> compare c, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L174" class="LineNr">174 </span> <span class="Delimiter">{</span>
<span id="L175" class="LineNr">175 </span> <span class="PreProc">break-if-!=</span>
<span id="L176" class="LineNr">176 </span> <span class="Comment"># if it's the first newline, buffer it</span>
<span id="L177" class="LineNr">177 </span> compare newline-seen?, <span class="Constant">0</span>
<span id="L178" class="LineNr">178 </span> <span class="Delimiter">{</span>
<span id="L179" class="LineNr">179 </span> <span class="PreProc">break-if-!=</span>
<span id="L180" class="LineNr">180 </span> newline-seen? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># true</span>
<span id="L181" class="LineNr">181 </span> <span class="PreProc">break</span> $render-normal:loop-body
<span id="L182" class="LineNr">182 </span> <span class="Delimiter">}</span>
<span id="L183" class="LineNr">183 </span> <span class="Comment"># otherwise render two newlines</span>
<span id="L184" class="LineNr">184 </span> <span class="Delimiter">{</span>
<span id="L185" class="LineNr">185 </span> <span class="PreProc">break-if-=</span>
<span id="L186" class="LineNr">186 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L187" class="LineNr">187 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L188" class="LineNr">188 </span> newline-seen? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L189" class="LineNr">189 </span> start-of-paragraph? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># true</span>
<span id="L190" class="LineNr">190 </span> <span class="PreProc">break</span> $render-normal:loop-body
<span id="L191" class="LineNr">191 </span> <span class="Delimiter">}</span>
<span id="L192" class="LineNr">192 </span> <span class="Delimiter">}</span>
<span id="L193" class="LineNr">193 </span> <span class="Comment"># if start of paragraph and c == '#', switch to header</span>
<span id="L194" class="LineNr">194 </span> compare start-of-paragraph?, <span class="Constant">0</span>
<span id="L195" class="LineNr">195 </span> <span class="Delimiter">{</span>
<span id="L196" class="LineNr">196 </span> <span class="PreProc">break-if-=</span>
<span id="L197" class="LineNr">197 </span> compare c, <span class="Constant">0x23</span> <span class="Comment"># '#'</span>
<span id="L198" class="LineNr">198 </span> <span class="Delimiter">{</span>
<span id="L199" class="LineNr">199 </span> <span class="PreProc">break-if-!=</span>
<span id="L200" class="LineNr">200 </span> <a href='main.mu.html#L267'>render-header-line</a> <a href='../../405screen.mu.html#L9'>screen</a>, fs
<span id="L201" class="LineNr">201 </span> newline-seen? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># true</span>
<span id="L202" class="LineNr">202 </span> <span class="PreProc">break</span> $render-normal:loop-body
<span id="L203" class="LineNr">203 </span> <span class="Delimiter">}</span>
<span id="L204" class="LineNr">204 </span> <span class="Delimiter">}</span>
<span id="L205" class="LineNr">205 </span> <span class="Comment"># c is not a newline</span>
<span id="L206" class="LineNr">206 </span> start-of-paragraph? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L207" class="LineNr">207 </span> <span class="Comment"># if c is unprintable (particularly a '\r' CR), skip it</span>
<span id="L208" class="LineNr">208 </span> compare c, <span class="Constant">0x20</span>
<span id="L209" class="LineNr">209 </span> <span class="PreProc">loop-if-&lt;</span> $render-normal:<span class="PreProc">loop</span>
<span id="L210" class="LineNr">210 </span> <span class="Comment"># If there's a newline buffered and c is a space, print the buffered</span>
<span id="L211" class="LineNr">211 </span> <span class="Comment"># newline (hard newline).</span>
<span id="L212" class="LineNr">212 </span> <span class="Comment"># If there's a newline buffered and c is not a newline or space, print a</span>
<span id="L213" class="LineNr">213 </span> <span class="Comment"># space (soft newline).</span>
<span id="L214" class="LineNr">214 </span> compare newline-seen?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L215" class="LineNr">215 </span>$render-normal:flush-buffered-newline: <span class="Delimiter">{</span>
<span id="L216" class="LineNr">216 </span> <span class="PreProc">break-if-=</span>
<span id="L217" class="LineNr">217 </span> newline-seen? <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L218" class="LineNr">218 </span> <span class="Delimiter">{</span>
<span id="L219" class="LineNr">219 </span> compare c, <span class="Constant">0x20</span>
<span id="L220" class="LineNr">220 </span> <span class="PreProc">break-if-!=</span>
<span id="L221" class="LineNr">221 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L222" class="LineNr">222 </span> <span class="PreProc">break</span> $render-normal:flush-buffered-newline
<span id="L223" class="LineNr">223 </span> <span class="Delimiter">}</span>
<span id="L224" class="LineNr">224 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0x20</span> <span class="Comment"># space</span>
<span id="L225" class="LineNr">225 </span> <span class="Comment"># fall through to print c</span>
<span id="L226" class="LineNr">226 </span> <span class="Delimiter">}</span>
<span id="L227" class="LineNr">227 </span> <span class="SalientComment">## end soft newline support</span>
<span id="L228" class="LineNr">228 </span>
<span id="L229" class="LineNr">229 </span>$render-normal:whitespace-separated-regions: <span class="Delimiter">{</span>
<span id="L230" class="LineNr">230 </span> <span class="Comment"># if previous-grapheme wasn't whitespace, skip this block</span>
<span id="L231" class="LineNr">231 </span> <span class="Delimiter">{</span>
<span id="L232" class="LineNr">232 </span> compare previous-grapheme, <span class="Constant">0x20</span> <span class="Comment"># space</span>
<span id="L233" class="LineNr">233 </span> <span class="PreProc">break-if-=</span>
<span id="L234" class="LineNr">234 </span> compare previous-grapheme, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L235" class="LineNr">235 </span> <span class="PreProc">break-if-=</span>
<span id="L236" class="LineNr">236 </span> <span class="PreProc">break</span> $render-normal:whitespace-separated-regions
<span id="L237" class="LineNr">237 </span> <span class="Delimiter">}</span>
<span id="L238" class="LineNr">238 </span> <span class="Comment"># if (c == '*') switch to bold</span>
<span id="L239" class="LineNr">239 </span> compare c, <span class="Constant">0x2a</span> <span class="Comment"># '*'</span>
<span id="L240" class="LineNr">240 </span> <span class="Delimiter">{</span>
<span id="L241" class="LineNr">241 </span> <span class="PreProc">break-if-!=</span>
<span id="L242" class="LineNr">242 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xec</span>, <span class="Constant">7</span> <span class="Comment"># 236 = darkish gray</span>
<span id="L243" class="LineNr">243 </span> start-bold-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L244" class="LineNr">244 </span> <a href='main.mu.html#L346'>render-until-asterisk</a> <a href='../../405screen.mu.html#L9'>screen</a>, fs
<span id="L245" class="LineNr">245 </span> <a href='main.mu.html#L394'>normal-text</a> <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L246" class="LineNr">246 </span> <span class="PreProc">break</span> $render-normal:loop-body
<span id="L247" class="LineNr">247 </span> <span class="Delimiter">}</span>
<span id="L248" class="LineNr">248 </span> <span class="Comment"># if (c == '_') switch to bold</span>
<span id="L249" class="LineNr">249 </span> compare c, <span class="Constant">0x5f</span> <span class="Comment"># '_'</span>
<span id="L250" class="LineNr">250 </span> <span class="Delimiter">{</span>
<span id="L251" class="LineNr">251 </span> <span class="PreProc">break-if-!=</span>
<span id="L252" class="LineNr">252 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xec</span>, <span class="Constant">7</span> <span class="Comment"># 236 = darkish gray</span>
<span id="L253" class="LineNr">253 </span> start-bold-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L254" class="LineNr">254 </span> <a href='main.mu.html#L367'>render-until-underscore</a> <a href='../../405screen.mu.html#L9'>screen</a>, fs
<span id="L255" class="LineNr">255 </span> <a href='main.mu.html#L394'>normal-text</a> <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L256" class="LineNr">256 </span> <span class="PreProc">break</span> $render-normal:loop-body
<span id="L257" class="LineNr">257 </span> <span class="Delimiter">}</span>
<span id="L258" class="LineNr">258 </span> <span class="Delimiter">}</span>
<span id="L259" class="LineNr">259 </span> <span class="Comment">#</span>
<span id="L260" class="LineNr">260 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, c
<span id="L261" class="LineNr">261 </span> <span class="Delimiter">}</span> <span class="Comment"># $render-normal:loop-body</span>
<span id="L262" class="LineNr">262 </span> previous-grapheme <span class="SpecialChar">&lt;-</span> copy c
<span id="L263" class="LineNr">263 </span> <span class="PreProc">loop</span>
<span id="L264" class="LineNr">264 </span> <span class="Delimiter">}</span> <span class="Comment"># $render-normal:loop</span>
<span id="L265" class="LineNr">265 </span><span class="Delimiter">}</span>
<span id="L266" class="LineNr">266 </span>
<span id="L267" class="LineNr">267 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L267'>render-header-line</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), fs: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L268" class="LineNr">268 </span>$render-header-line:body: <span class="Delimiter">{</span>
<span id="L269" class="LineNr">269 </span> <span class="Comment"># compute color based on number of '#'s</span>
<span id="L270" class="LineNr">270 </span> <span class="PreProc">var</span> header-level/<span class="Constant">esi</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># caller already grabbed one</span>
<span id="L271" class="LineNr">271 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L272" class="LineNr">272 </span> <span class="Delimiter">{</span>
<span id="L273" class="LineNr">273 </span> <span class="Comment"># if done-drawing?(screen) return</span>
<span id="L274" class="LineNr">274 </span> <span class="Delimiter">{</span>
<span id="L275" class="LineNr">275 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> done-drawing? <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L276" class="LineNr">276 </span> compare done?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L277" class="LineNr">277 </span> <span class="PreProc">break-if-!=</span> $render-header-line:body
<span id="L278" class="LineNr">278 </span> <span class="Delimiter">}</span>
<span id="L279" class="LineNr">279 </span> <span class="Comment">#</span>
<span id="L280" class="LineNr">280 </span> c <span class="SpecialChar">&lt;-</span> <a href='../../403unicode.mu.html#L256'>read-grapheme-buffered</a> fs
<span id="L281" class="LineNr">281 </span> <span class="Comment"># if (c != '#') break</span>
<span id="L282" class="LineNr">282 </span> compare c, <span class="Constant">0x23</span> <span class="Comment"># '#'</span>
<span id="L283" class="LineNr">283 </span> <span class="PreProc">break-if-!=</span>
<span id="L284" class="LineNr">284 </span> <span class="Comment">#</span>
<span id="L285" class="LineNr">285 </span> header-level <span class="SpecialChar">&lt;-</span> increment
<span id="L286" class="LineNr">286 </span> <span class="Comment">#</span>
<span id="L287" class="LineNr">287 </span> <span class="PreProc">loop</span>
<span id="L288" class="LineNr">288 </span> <span class="Delimiter">}</span>
<span id="L289" class="LineNr">289 </span> <a href='main.mu.html#L315'>start-heading</a> <a href='../../405screen.mu.html#L9'>screen</a>, header-level
<span id="L290" class="LineNr">290 </span> <span class="Delimiter">{</span>
<span id="L291" class="LineNr">291 </span> <span class="Comment"># if done-drawing?(screen) break</span>
<span id="L292" class="LineNr">292 </span> <span class="Delimiter">{</span>
<span id="L293" class="LineNr">293 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> done-drawing? <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L294" class="LineNr">294 </span> compare done?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L295" class="LineNr">295 </span> <span class="PreProc">break-if-!=</span>
<span id="L296" class="LineNr">296 </span> <span class="Delimiter">}</span>
<span id="L297" class="LineNr">297 </span> <span class="Comment">#</span>
<span id="L298" class="LineNr">298 </span> c <span class="SpecialChar">&lt;-</span> <a href='../../403unicode.mu.html#L256'>read-grapheme-buffered</a> fs
<span id="L299" class="LineNr">299 </span> <span class="Comment"># if (c == EOF) break</span>
<span id="L300" class="LineNr">300 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L301" class="LineNr">301 </span> <span class="PreProc">break-if-=</span>
<span id="L302" class="LineNr">302 </span> <span class="Comment"># if (c == newline) break</span>
<span id="L303" class="LineNr">303 </span> compare c, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L304" class="LineNr">304 </span> <span class="PreProc">break-if-=</span>
<span id="L305" class="LineNr">305 </span> <span class="Comment">#</span>
<span id="L306" class="LineNr">306 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, c
<span id="L307" class="LineNr">307 </span> <span class="Comment">#</span>
<span id="L308" class="LineNr">308 </span> <span class="PreProc">loop</span>
<span id="L309" class="LineNr">309 </span> <span class="Delimiter">}</span>
<span id="L310" class="LineNr">310 </span> <a href='main.mu.html#L394'>normal-text</a> <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L311" class="LineNr">311 </span><span class="Delimiter">}</span>
<span id="L312" class="LineNr">312 </span><span class="Delimiter">}</span>
<span id="L313" class="LineNr">313 </span>
<span id="L314" class="LineNr">314 </span><span class="Comment"># colors for a light background, going from bright to dark (meeting up with bold-text)</span>
<span id="L315" class="LineNr">315 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L315'>start-heading</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), header-level: int <span class="Delimiter">{</span>
<span id="L316" class="LineNr">316 </span>$start-heading:body: <span class="Delimiter">{</span>
<span id="L317" class="LineNr">317 </span> start-bold-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L318" class="LineNr">318 </span> compare header-level, <span class="Constant">1</span>
<span id="L319" class="LineNr">319 </span> <span class="Delimiter">{</span>
<span id="L320" class="LineNr">320 </span> <span class="PreProc">break-if-!=</span>
<span id="L321" class="LineNr">321 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xa0</span>, <span class="Constant">7</span>
<span id="L322" class="LineNr">322 </span> <span class="PreProc">break</span> $start-heading:body
<span id="L323" class="LineNr">323 </span> <span class="Delimiter">}</span>
<span id="L324" class="LineNr">324 </span> compare header-level, <span class="Constant">2</span>
<span id="L325" class="LineNr">325 </span> <span class="Delimiter">{</span>
<span id="L326" class="LineNr">326 </span> <span class="PreProc">break-if-!=</span>
<span id="L327" class="LineNr">327 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0x7c</span>, <span class="Constant">7</span>
<span id="L328" class="LineNr">328 </span> <span class="PreProc">break</span> $start-heading:body
<span id="L329" class="LineNr">329 </span> <span class="Delimiter">}</span>
<span id="L330" class="LineNr">330 </span> compare header-level, <span class="Constant">3</span>
<span id="L331" class="LineNr">331 </span> <span class="Delimiter">{</span>
<span id="L332" class="LineNr">332 </span> <span class="PreProc">break-if-!=</span>
<span id="L333" class="LineNr">333 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0x58</span>, <span class="Constant">7</span>
<span id="L334" class="LineNr">334 </span> <span class="PreProc">break</span> $start-heading:body
<span id="L335" class="LineNr">335 </span> <span class="Delimiter">}</span>
<span id="L336" class="LineNr">336 </span> compare header-level, <span class="Constant">4</span>
<span id="L337" class="LineNr">337 </span> <span class="Delimiter">{</span>
<span id="L338" class="LineNr">338 </span> <span class="PreProc">break-if-!=</span>
<span id="L339" class="LineNr">339 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0x34</span>, <span class="Constant">7</span>
<span id="L340" class="LineNr">340 </span> <span class="PreProc">break</span> $start-heading:body
<span id="L341" class="LineNr">341 </span> <span class="Delimiter">}</span>
<span id="L342" class="LineNr">342 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xe8</span>, <span class="Constant">7</span>
<span id="L343" class="LineNr">343 </span><span class="Delimiter">}</span>
<span id="L344" class="LineNr">344 </span><span class="Delimiter">}</span>
<span id="L345" class="LineNr">345 </span>
<span id="L346" class="LineNr">346 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L346'>render-until-asterisk</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), fs: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L347" class="LineNr">347 </span> <span class="Delimiter">{</span>
<span id="L348" class="LineNr">348 </span> <span class="Comment"># if done-drawing?(screen) break</span>
<span id="L349" class="LineNr">349 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> done-drawing? <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L350" class="LineNr">350 </span> compare done?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L351" class="LineNr">351 </span> <span class="PreProc">break-if-!=</span>
<span id="L352" class="LineNr">352 </span> <span class="Comment">#</span>
<span id="L353" class="LineNr">353 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> <a href='../../403unicode.mu.html#L256'>read-grapheme-buffered</a> fs
<span id="L354" class="LineNr">354 </span> <span class="Comment"># if (c == EOF) break</span>
<span id="L355" class="LineNr">355 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L356" class="LineNr">356 </span> <span class="PreProc">break-if-=</span>
<span id="L357" class="LineNr">357 </span> <span class="Comment"># if (c == '*') break</span>
<span id="L358" class="LineNr">358 </span> compare c, <span class="Constant">0x2a</span> <span class="Comment"># '*'</span>
<span id="L359" class="LineNr">359 </span> <span class="PreProc">break-if-=</span>
<span id="L360" class="LineNr">360 </span> <span class="Comment">#</span>
<span id="L361" class="LineNr">361 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, c
<span id="L362" class="LineNr">362 </span> <span class="Comment">#</span>
<span id="L363" class="LineNr">363 </span> <span class="PreProc">loop</span>
<span id="L364" class="LineNr">364 </span> <span class="Delimiter">}</span>
<span id="L365" class="LineNr">365 </span><span class="Delimiter">}</span>
<span id="L366" class="LineNr">366 </span>
<span id="L367" class="LineNr">367 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L367'>render-until-underscore</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen), fs: (addr buffered-file) <span class="Delimiter">{</span>
<span id="L368" class="LineNr">368 </span> <span class="Delimiter">{</span>
<span id="L369" class="LineNr">369 </span> <span class="Comment"># if done-drawing?(screen) break</span>
<span id="L370" class="LineNr">370 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> done-drawing? <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L371" class="LineNr">371 </span> compare done?, <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L372" class="LineNr">372 </span> <span class="PreProc">break-if-!=</span>
<span id="L373" class="LineNr">373 </span> <span class="Comment">#</span>
<span id="L374" class="LineNr">374 </span> <span class="PreProc">var</span> c/<span class="Constant">eax</span>: grapheme <span class="SpecialChar">&lt;-</span> <a href='../../403unicode.mu.html#L256'>read-grapheme-buffered</a> fs
<span id="L375" class="LineNr">375 </span> <span class="Comment"># if (c == EOF) break</span>
<span id="L376" class="LineNr">376 </span> compare c, <span class="Constant">0xffffffff</span> <span class="Comment"># EOF marker</span>
<span id="L377" class="LineNr">377 </span> <span class="PreProc">break-if-=</span>
<span id="L378" class="LineNr">378 </span> <span class="Comment"># if (c == '_') break</span>
<span id="L379" class="LineNr">379 </span> compare c, <span class="Constant">0x5f</span> <span class="Comment"># '_'</span>
<span id="L380" class="LineNr">380 </span> <span class="PreProc">break-if-=</span>
<span id="L381" class="LineNr">381 </span> <span class="Comment">#</span>
<span id="L382" class="LineNr">382 </span> add-grapheme <a href='../../405screen.mu.html#L9'>screen</a>, c
<span id="L383" class="LineNr">383 </span> <span class="Comment">#</span>
<span id="L384" class="LineNr">384 </span> <span class="PreProc">loop</span>
<span id="L385" class="LineNr">385 </span> <span class="Delimiter">}</span>
<span id="L386" class="LineNr">386 </span><span class="Delimiter">}</span>
<span id="L387" class="LineNr">387 </span>
<span id="L388" class="LineNr">388 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L388'>first-arg</a></span> args-on-stack: (addr array addr array byte)<span class="PreProc"> -&gt; </span>out/<span class="Constant">eax</span>: (addr array byte) <span class="Delimiter">{</span>
<span id="L389" class="LineNr">389 </span> <span class="PreProc">var</span> args/<span class="Constant">eax</span>: (addr array addr array byte) <span class="SpecialChar">&lt;-</span> copy args-on-stack
<span id="L390" class="LineNr">390 </span> <span class="PreProc">var</span> result/<span class="Constant">eax</span>: (addr addr array byte) <span class="SpecialChar">&lt;-</span> index args, <span class="Constant">1</span>
<span id="L391" class="LineNr">391 </span> out <span class="SpecialChar">&lt;-</span> copy *result
<span id="L392" class="LineNr">392 </span><span class="Delimiter">}</span>
<span id="L393" class="LineNr">393 </span>
<span id="L394" class="LineNr">394 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='main.mu.html#L394'>normal-text</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr paginated-screen) <span class="Delimiter">{</span>
<span id="L395" class="LineNr">395 </span> reset-formatting-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L396" class="LineNr">396 </span> start-color-on-paginated-screen <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0xec</span>, <span class="Constant">7</span> <span class="Comment"># 236 = darkish gray</span>
<span id="L397" class="LineNr">397 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->

733
html/apps/browse/paginated-screen.mu.html generated Normal file
View File

@ -0,0 +1,733 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - apps/browse/paginated-screen.mu</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.CommentedCode { color: #8a8a8a; }
.muTest { color: #5f8700; }
.LineNr { }
.muFunction { color: #af5f00; text-decoration: underline; }
.SpecialChar { color: #d70000; }
.Comment { color: #005faf; }
.Delimiter { color: #c000c0; }
.Constant { color: #008787; }
.PreProc { color: #c000c0; }
.SalientComment { color: #0000af; }
-->
</style>
<script type='text/javascript'>
<!--
/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
var lineNum;
lineNum = window.location.hash;
lineNum = lineNum.substr(1); /* strip off '#' */
if (lineNum.indexOf('L') == -1) {
lineNum = 'L'+lineNum;
}
var lineElem = document.getElementById(lineNum);
/* Always jump to new location even if the line was hidden inside a fold, or
* we corrected the raw number to a line ID.
*/
if (lineElem) {
lineElem.scrollIntoView(true);
}
return true;
}
if ('onhashchange' in window) {
window.onhashchange = JumpToLine;
}
-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/apps/browse/paginated-screen.mu'>https://github.com/akkartik/mu/blob/master/apps/browse/paginated-screen.mu</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span><span class="Comment"># If a screen is too wide, split it up into a fixed size of pages.</span>
<span id="L2" class="LineNr"> 2 </span><span class="Comment"># We take control of drawing and moving the cursor, and delegate everything else.</span>
<span id="L3" class="LineNr"> 3 </span><span class="Comment"># Never scroll; use the 'done-drawing?' method instead.</span>
<span id="L4" class="LineNr"> 4 </span><span class="Comment">#</span>
<span id="L5" class="LineNr"> 5 </span><span class="Comment"># Example usage:</span>
<span id="L6" class="LineNr"> 6 </span><span class="Comment"># initialize-paginated-screen</span>
<span id="L7" class="LineNr"> 7 </span><span class="Comment"># on each frame</span>
<span id="L8" class="LineNr"> 8 </span><span class="Comment"># start-drawing</span>
<span id="L9" class="LineNr"> 9 </span><span class="Comment"># while !done-drawing</span>
<span id="L10" class="LineNr"> 10 </span><span class="Comment"># add-grapheme ...</span>
<span id="L11" class="LineNr"> 11 </span>
<span id="L12" class="LineNr"> 12 </span><span class="PreProc">type</span> <a href='paginated-screen.mu.html#L12'>paginated-screen</a> <span class="Delimiter">{</span>
<span id="L13" class="LineNr"> 13 </span> <a href='../../405screen.mu.html#L9'>screen</a>: (handle <a href='../../405screen.mu.html#L9'>screen</a>)
<span id="L14" class="LineNr"> 14 </span> nrows: int <span class="Comment"># const</span>
<span id="L15" class="LineNr"> 15 </span> ncols: int <span class="Comment"># const</span>
<span id="L16" class="LineNr"> 16 </span> page-width: int
<span id="L17" class="LineNr"> 17 </span> top-margin: int
<span id="L18" class="LineNr"> 18 </span> left-margin: int
<span id="L19" class="LineNr"> 19 </span> <span class="Comment"># page bounds</span>
<span id="L20" class="LineNr"> 20 </span> toprow: int
<span id="L21" class="LineNr"> 21 </span> botrow: int <span class="Comment"># (inclusive)</span>
<span id="L22" class="LineNr"> 22 </span> leftcol: int
<span id="L23" class="LineNr"> 23 </span> rightcol: int <span class="Comment"># (exclusive)</span>
<span id="L24" class="LineNr"> 24 </span> <span class="Comment"># current cursor position</span>
<span id="L25" class="LineNr"> 25 </span> row: int
<span id="L26" class="LineNr"> 26 </span> col: int
<span id="L27" class="LineNr"> 27 </span><span class="Delimiter">}</span>
<span id="L28" class="LineNr"> 28 </span>
<span id="L29" class="LineNr"> 29 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L29'>initialize-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>), page-width: int, top-margin: int, left-margin: int <span class="Delimiter">{</span>
<span id="L30" class="LineNr"> 30 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L31" class="LineNr"> 31 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L32" class="LineNr"> 32 </span> <span class="PreProc">var</span> _screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L33" class="LineNr"> 33 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">edi</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> copy _screen-addr
<span id="L34" class="LineNr"> 34 </span> <span class="PreProc">var</span> nrows/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L35" class="LineNr"> 35 </span> <span class="PreProc">var</span> ncols/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L36" class="LineNr"> 36 </span> nrows, ncols <span class="SpecialChar">&lt;-</span> <a href='../../405screen.mu.html#L60'>screen-size</a> screen-addr
<span id="L37" class="LineNr"> 37 </span> <span class="PreProc">var</span> dest/<span class="Constant">edx</span>: (addr int) <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L38" class="LineNr"> 38 </span> <span class="Comment"># self-&gt;nrows = nrows</span>
<span id="L39" class="LineNr"> 39 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, nrows
<span id="L40" class="LineNr"> 40 </span> copy-to *dest, nrows
<span id="L41" class="LineNr"> 41 </span> <span class="Comment"># self-&gt;ncols = ncols</span>
<span id="L42" class="LineNr"> 42 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, ncols
<span id="L43" class="LineNr"> 43 </span> copy-to *dest, ncols
<span id="L44" class="LineNr"> 44 </span> <span class="Comment"># self-&gt;page-width = page-width</span>
<span id="L45" class="LineNr"> 45 </span> <span class="Delimiter">{</span>
<span id="L46" class="LineNr"> 46 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy page-width
<span id="L47" class="LineNr"> 47 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, page-width
<span id="L48" class="LineNr"> 48 </span> copy-to *dest, tmp
<span id="L49" class="LineNr"> 49 </span> <span class="Delimiter">}</span>
<span id="L50" class="LineNr"> 50 </span> <span class="Comment"># self-&gt;top-margin = top-margin</span>
<span id="L51" class="LineNr"> 51 </span> <span class="Delimiter">{</span>
<span id="L52" class="LineNr"> 52 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy top-margin
<span id="L53" class="LineNr"> 53 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, top-margin
<span id="L54" class="LineNr"> 54 </span> copy-to *dest, tmp
<span id="L55" class="LineNr"> 55 </span> <span class="Delimiter">}</span>
<span id="L56" class="LineNr"> 56 </span> <span class="Comment"># self-&gt;left-margin = left-margin</span>
<span id="L57" class="LineNr"> 57 </span> <span class="Delimiter">{</span>
<span id="L58" class="LineNr"> 58 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy left-margin
<span id="L59" class="LineNr"> 59 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, left-margin
<span id="L60" class="LineNr"> 60 </span> copy-to *dest, tmp
<span id="L61" class="LineNr"> 61 </span> <span class="Delimiter">}</span>
<span id="L62" class="LineNr"> 62 </span> <span class="Comment"># self-&gt;toprow = 1 + top-margin</span>
<span id="L63" class="LineNr"> 63 </span> <span class="Delimiter">{</span>
<span id="L64" class="LineNr"> 64 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy top-margin
<span id="L65" class="LineNr"> 65 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, toprow
<span id="L66" class="LineNr"> 66 </span> copy-to *dest, <span class="Constant">1</span>
<span id="L67" class="LineNr"> 67 </span> add-to *dest, tmp
<span id="L68" class="LineNr"> 68 </span> <span class="Delimiter">}</span>
<span id="L69" class="LineNr"> 69 </span> <span class="Comment"># self-&gt;botrow = nrows</span>
<span id="L70" class="LineNr"> 70 </span> <span class="Delimiter">{</span>
<span id="L71" class="LineNr"> 71 </span> dest <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, botrow
<span id="L72" class="LineNr"> 72 </span> copy-to *dest, nrows
<span id="L73" class="LineNr"> 73 </span> <span class="Delimiter">}</span>
<span id="L74" class="LineNr"> 74 </span> <span class="Comment">#</span>
<span id="L75" class="LineNr"> 75 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> self
<span id="L76" class="LineNr"> 76 </span><span class="Delimiter">}</span>
<span id="L77" class="LineNr"> 77 </span>
<span id="L78" class="LineNr"> 78 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L78'>start-drawing</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L79" class="LineNr"> 79 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L80" class="LineNr"> 80 </span> <a href='paginated-screen.mu.html#L550'>clear-paginated-screen</a> self
<span id="L81" class="LineNr"> 81 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L82" class="LineNr"> 82 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L83" class="LineNr"> 83 </span> <span class="Comment"># self-&gt;leftcol = 1 + left-margin</span>
<span id="L84" class="LineNr"> 84 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, left-margin
<span id="L85" class="LineNr"> 85 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L86" class="LineNr"> 86 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L87" class="LineNr"> 87 </span> copy-to *tmp, <span class="Constant">1</span>
<span id="L88" class="LineNr"> 88 </span> add-to *tmp, tmp2
<span id="L89" class="LineNr"> 89 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;start: left column: &quot;</span>
<span id="L90" class="LineNr"> 90 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *tmp</span>
<span id="L91" class="LineNr"> 91 </span> <span class="Comment"># self-&gt;rightcol = min(ncols+1, self-&gt;leftcol + page-width)</span>
<span id="L92" class="LineNr"> 92 </span> <span class="Comment"># . tmp2 = self-&gt;leftcol + page-width</span>
<span id="L93" class="LineNr"> 93 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, page-width
<span id="L94" class="LineNr"> 94 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L95" class="LineNr"> 95 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L96" class="LineNr"> 96 </span> tmp2 <span class="SpecialChar">&lt;-</span> add *tmp
<span id="L97" class="LineNr"> 97 </span> <span class="Comment"># . if (tmp2 &gt; ncols+1) tmp2 = ncols+1</span>
<span id="L98" class="LineNr"> 98 </span> <span class="Delimiter">{</span>
<span id="L99" class="LineNr"> 99 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, ncols
<span id="L100" class="LineNr">100 </span> compare tmp2, *tmp
<span id="L101" class="LineNr">101 </span> <span class="PreProc">break-if-&lt;=</span>
<span id="L102" class="LineNr">102 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L103" class="LineNr">103 </span> tmp2 <span class="SpecialChar">&lt;-</span> increment
<span id="L104" class="LineNr">104 </span> <span class="Delimiter">}</span>
<span id="L105" class="LineNr">105 </span> <span class="Comment"># . self-&gt;rightcol = tmp2</span>
<span id="L106" class="LineNr">106 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, rightcol
<span id="L107" class="LineNr">107 </span> copy-to *tmp, tmp2
<span id="L108" class="LineNr">108 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;; right column: &quot;</span>
<span id="L109" class="LineNr">109 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *tmp</span>
<span id="L110" class="LineNr">110 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L111" class="LineNr">111 </span> <span class="Comment"># self-&gt;row = self-&gt;toprow</span>
<span id="L112" class="LineNr">112 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, toprow
<span id="L113" class="LineNr">113 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L114" class="LineNr">114 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, row
<span id="L115" class="LineNr">115 </span> copy-to *tmp, tmp2
<span id="L116" class="LineNr">116 </span> <span class="Comment"># self-&gt;col = self-&gt;leftcol</span>
<span id="L117" class="LineNr">117 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L118" class="LineNr">118 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L119" class="LineNr">119 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, col
<span id="L120" class="LineNr">120 </span> copy-to *tmp, tmp2
<span id="L121" class="LineNr">121 </span> <span class="Comment">#</span>
<span id="L122" class="LineNr">122 </span> <a href='paginated-screen.mu.html#L536'>reposition-cursor</a> self
<span id="L123" class="LineNr">123 </span><span class="Delimiter">}</span>
<span id="L124" class="LineNr">124 </span>
<span id="L125" class="LineNr">125 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L125'>done-drawing?</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>)<span class="PreProc"> -&gt; </span>result/<span class="Constant">eax</span>: boolean <span class="Delimiter">{</span>
<span id="L126" class="LineNr">126 </span>$done-drawing?:body: <span class="Delimiter">{</span>
<span id="L127" class="LineNr">127 </span> <span class="Comment"># if (self-&gt;leftcol == left-margin + 1) return false</span>
<span id="L128" class="LineNr">128 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L129" class="LineNr">129 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, left-margin
<span id="L130" class="LineNr">130 </span> <span class="PreProc">var</span> first-col/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L131" class="LineNr">131 </span> first-col <span class="SpecialChar">&lt;-</span> increment
<span id="L132" class="LineNr">132 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L133" class="LineNr">133 </span> $done-drawing:first-page?: <span class="Delimiter">{</span>
<span id="L134" class="LineNr">134 </span> compare first-col, *tmp
<span id="L135" class="LineNr">135 </span> <span class="PreProc">break-if-!=</span>
<span id="L136" class="LineNr">136 </span> result <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L137" class="LineNr">137 </span> <span class="PreProc">break</span> $done-drawing?:body
<span id="L138" class="LineNr">138 </span> <span class="Delimiter">}</span>
<span id="L139" class="LineNr">139 </span> <span class="Comment"># return self-&gt;rightcol &gt; self-&gt;ncols + 1</span>
<span id="L140" class="LineNr">140 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, ncols
<span id="L141" class="LineNr">141 </span> <span class="PreProc">var</span> max/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L142" class="LineNr">142 </span> max <span class="SpecialChar">&lt;-</span> increment
<span id="L143" class="LineNr">143 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, rightcol
<span id="L144" class="LineNr">144 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;done-drawing? &quot;</span>
<span id="L145" class="LineNr">145 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *tmp</span>
<span id="L146" class="LineNr">146 </span><span class="CommentedCode">#? print-string-to-real-screen &quot; vs &quot;</span>
<span id="L147" class="LineNr">147 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen max</span>
<span id="L148" class="LineNr">148 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L149" class="LineNr">149 </span> compare *tmp, max
<span id="L150" class="LineNr">150 </span> <span class="Delimiter">{</span>
<span id="L151" class="LineNr">151 </span> <span class="PreProc">break-if-&gt;</span>
<span id="L152" class="LineNr">152 </span> result <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span> <span class="Comment"># false</span>
<span id="L153" class="LineNr">153 </span> <span class="PreProc">break</span> $done-drawing?:body
<span id="L154" class="LineNr">154 </span> <span class="Delimiter">}</span>
<span id="L155" class="LineNr">155 </span> <span class="Delimiter">{</span>
<span id="L156" class="LineNr">156 </span> <span class="PreProc">break-if-&lt;=</span>
<span id="L157" class="LineNr">157 </span> result <span class="SpecialChar">&lt;-</span> copy <span class="Constant">1</span> <span class="Comment"># true</span>
<span id="L158" class="LineNr">158 </span> <span class="Delimiter">}</span>
<span id="L159" class="LineNr">159 </span><span class="Delimiter">}</span>
<span id="L160" class="LineNr">160 </span><span class="Delimiter">}</span>
<span id="L161" class="LineNr">161 </span>
<span id="L162" class="LineNr">162 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L162'>add-grapheme</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>), c: grapheme <span class="Delimiter">{</span>
<span id="L163" class="LineNr">163 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;add-grapheme: &quot;</span>
<span id="L164" class="LineNr">164 </span><span class="CommentedCode">#? print-grapheme-to-real-screen c</span>
<span id="L165" class="LineNr">165 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L166" class="LineNr">166 </span>$add-grapheme:body: <span class="Delimiter">{</span>
<span id="L167" class="LineNr">167 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L168" class="LineNr">168 </span> <span class="Delimiter">{</span>
<span id="L169" class="LineNr">169 </span> compare c, <span class="Constant">0xa</span> <span class="Comment"># newline</span>
<span id="L170" class="LineNr">170 </span> <span class="PreProc">break-if-!=</span>
<span id="L171" class="LineNr">171 </span> <a href='paginated-screen.mu.html#L601'>next-line</a> self
<span id="L172" class="LineNr">172 </span> <a href='paginated-screen.mu.html#L536'>reposition-cursor</a> self
<span id="L173" class="LineNr">173 </span> <span class="PreProc">break</span> $add-grapheme:body
<span id="L174" class="LineNr">174 </span> <span class="Delimiter">}</span>
<span id="L175" class="LineNr">175 </span> <span class="Comment"># print c</span>
<span id="L176" class="LineNr">176 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L177" class="LineNr">177 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L178" class="LineNr">178 </span> <a href='../../405screen.mu.html#L206'>print-grapheme</a> screen-addr, c
<span id="L179" class="LineNr">179 </span> <span class="Comment"># self-&gt;col++</span>
<span id="L180" class="LineNr">180 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, col
<span id="L181" class="LineNr">181 </span> increment *tmp
<span id="L182" class="LineNr">182 </span> <span class="Comment"># if (self-&gt;col &gt; self-&gt;rightcol) next-line(self)</span>
<span id="L183" class="LineNr">183 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L184" class="LineNr">184 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, rightcol
<span id="L185" class="LineNr">185 </span> compare tmp2, *tmp
<span id="L186" class="LineNr">186 </span> <span class="Delimiter">{</span>
<span id="L187" class="LineNr">187 </span> <span class="PreProc">break-if-&lt;</span>
<span id="L188" class="LineNr">188 </span> <a href='paginated-screen.mu.html#L601'>next-line</a> self
<span id="L189" class="LineNr">189 </span> <a href='paginated-screen.mu.html#L536'>reposition-cursor</a> self
<span id="L190" class="LineNr">190 </span> <span class="Delimiter">}</span>
<span id="L191" class="LineNr">191 </span><span class="Delimiter">}</span>
<span id="L192" class="LineNr">192 </span><span class="Delimiter">}</span>
<span id="L193" class="LineNr">193 </span>
<span id="L194" class="LineNr">194 </span><span class="SalientComment">## tests</span>
<span id="L195" class="LineNr">195 </span>
<span id="L196" class="LineNr">196 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L196'>test-print-grapheme-on-paginated-screen</a></span> <span class="Delimiter">{</span>
<span id="L197" class="LineNr">197 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L198" class="LineNr">198 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L199" class="LineNr">199 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">3</span>, <span class="Constant">0xa</span>, <span class="Constant">0xa</span>, <span class="Constant">0</span>, <span class="Constant">0</span>
<span id="L200" class="LineNr">200 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L201" class="LineNr">201 </span> <span class="Delimiter">{</span>
<span id="L202" class="LineNr">202 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L203" class="LineNr">203 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L204" class="LineNr">204 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L205" class="LineNr">205 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L206" class="LineNr">206 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L196'>test-print-grapheme-on-paginated-screen</a>/done&quot;</span>
<span id="L207" class="LineNr">207 </span> <span class="Delimiter">}</span>
<span id="L208" class="LineNr">208 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L209" class="LineNr">209 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L210" class="LineNr">210 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot;a&quot;</span>, <span class="Constant">&quot;F - test-print-grapheme-on-paginated-screen&quot;</span>
<span id="L211" class="LineNr">211 </span><span class="Delimiter">}</span>
<span id="L212" class="LineNr">212 </span>
<span id="L213" class="LineNr">213 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L213'>test-print-single-page</a></span> <span class="Delimiter">{</span>
<span id="L214" class="LineNr">214 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L215" class="LineNr">215 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L216" class="LineNr">216 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">2</span>, <span class="Constant">4</span>, <span class="Constant">2</span>, <span class="Constant">0</span>, <span class="Constant">0</span> <span class="Comment"># 2 rows, 4 columns, 2 pages * 2 columns each</span>
<span id="L217" class="LineNr">217 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L218" class="LineNr">218 </span> <span class="Comment"># pages at columns [1, 3), [3, 5)</span>
<span id="L219" class="LineNr">219 </span> <span class="Delimiter">{</span>
<span id="L220" class="LineNr">220 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L221" class="LineNr">221 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L222" class="LineNr">222 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L223" class="LineNr">223 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L224" class="LineNr">224 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/done-1&quot;</span>
<span id="L225" class="LineNr">225 </span> <span class="Delimiter">}</span>
<span id="L226" class="LineNr">226 </span> <span class="Delimiter">{</span>
<span id="L227" class="LineNr">227 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L228" class="LineNr">228 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L229" class="LineNr">229 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L230" class="LineNr">230 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L231" class="LineNr">231 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/done-2&quot;</span>
<span id="L232" class="LineNr">232 </span> <span class="Delimiter">}</span>
<span id="L233" class="LineNr">233 </span> <span class="Delimiter">{</span>
<span id="L234" class="LineNr">234 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L235" class="LineNr">235 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L236" class="LineNr">236 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L237" class="LineNr">237 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L238" class="LineNr">238 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/done-3&quot;</span>
<span id="L239" class="LineNr">239 </span> <span class="Delimiter">}</span>
<span id="L240" class="LineNr">240 </span> <span class="Delimiter">{</span>
<span id="L241" class="LineNr">241 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L242" class="LineNr">242 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L243" class="LineNr">243 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L244" class="LineNr">244 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L245" class="LineNr">245 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/done-4&quot;</span>
<span id="L246" class="LineNr">246 </span> <span class="Delimiter">}</span>
<span id="L247" class="LineNr">247 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L248" class="LineNr">248 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L249" class="LineNr">249 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot;ab &quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/row1&quot;</span>
<span id="L250" class="LineNr">250 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot;cd &quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L213'>test-print-single-page</a>/row2&quot;</span>
<span id="L251" class="LineNr">251 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L252" class="LineNr">252 </span><span class="Delimiter">}</span>
<span id="L253" class="LineNr">253 </span>
<span id="L254" class="LineNr">254 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a></span> <span class="Delimiter">{</span>
<span id="L255" class="LineNr">255 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L256" class="LineNr">256 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L257" class="LineNr">257 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">2</span>, <span class="Constant">4</span>, <span class="Constant">5</span>, <span class="Constant">0</span>, <span class="Constant">0</span> <span class="Comment"># 2 rows, 4 columns, 5-column pages</span>
<span id="L258" class="LineNr">258 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L259" class="LineNr">259 </span> <span class="Delimiter">{</span>
<span id="L260" class="LineNr">260 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L261" class="LineNr">261 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L262" class="LineNr">262 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L263" class="LineNr">263 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L264" class="LineNr">264 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/done-1&quot;</span>
<span id="L265" class="LineNr">265 </span> <span class="Delimiter">}</span>
<span id="L266" class="LineNr">266 </span> <span class="Delimiter">{</span>
<span id="L267" class="LineNr">267 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L268" class="LineNr">268 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L269" class="LineNr">269 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L270" class="LineNr">270 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L271" class="LineNr">271 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/done-2&quot;</span>
<span id="L272" class="LineNr">272 </span> <span class="Delimiter">}</span>
<span id="L273" class="LineNr">273 </span> <span class="Delimiter">{</span>
<span id="L274" class="LineNr">274 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L275" class="LineNr">275 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L276" class="LineNr">276 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L277" class="LineNr">277 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L278" class="LineNr">278 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/done-3&quot;</span>
<span id="L279" class="LineNr">279 </span> <span class="Delimiter">}</span>
<span id="L280" class="LineNr">280 </span> <span class="Delimiter">{</span>
<span id="L281" class="LineNr">281 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L282" class="LineNr">282 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L283" class="LineNr">283 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L284" class="LineNr">284 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L285" class="LineNr">285 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/done-4&quot;</span>
<span id="L286" class="LineNr">286 </span> <span class="Delimiter">}</span>
<span id="L287" class="LineNr">287 </span> <span class="Delimiter">{</span>
<span id="L288" class="LineNr">288 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x65</span> <span class="Comment"># 'e'</span>
<span id="L289" class="LineNr">289 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L290" class="LineNr">290 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L291" class="LineNr">291 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L292" class="LineNr">292 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/done-5&quot;</span>
<span id="L293" class="LineNr">293 </span> <span class="Delimiter">}</span>
<span id="L294" class="LineNr">294 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L295" class="LineNr">295 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L296" class="LineNr">296 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot;abcd&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/row1&quot;</span>
<span id="L297" class="LineNr">297 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot;e &quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L254'>test-print-single-page-narrower-than-page-width</a>/row2&quot;</span>
<span id="L298" class="LineNr">298 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L299" class="LineNr">299 </span><span class="Delimiter">}</span>
<span id="L300" class="LineNr">300 </span>
<span id="L301" class="LineNr">301 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a></span> <span class="Delimiter">{</span>
<span id="L302" class="LineNr">302 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L303" class="LineNr">303 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L304" class="LineNr">304 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">2</span>, <span class="Constant">4</span>, <span class="Constant">5</span>, <span class="Constant">0</span>, <span class="Constant">1</span> <span class="Comment"># 2 rows, 4 columns, 5-column pages, left margin</span>
<span id="L305" class="LineNr">305 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L306" class="LineNr">306 </span> <span class="Delimiter">{</span>
<span id="L307" class="LineNr">307 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L308" class="LineNr">308 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L309" class="LineNr">309 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L310" class="LineNr">310 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L311" class="LineNr">311 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/done-1&quot;</span>
<span id="L312" class="LineNr">312 </span> <span class="Delimiter">}</span>
<span id="L313" class="LineNr">313 </span> <span class="Delimiter">{</span>
<span id="L314" class="LineNr">314 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L315" class="LineNr">315 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L316" class="LineNr">316 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L317" class="LineNr">317 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L318" class="LineNr">318 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/done-2&quot;</span>
<span id="L319" class="LineNr">319 </span> <span class="Delimiter">}</span>
<span id="L320" class="LineNr">320 </span> <span class="Delimiter">{</span>
<span id="L321" class="LineNr">321 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L322" class="LineNr">322 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L323" class="LineNr">323 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L324" class="LineNr">324 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L325" class="LineNr">325 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/done-3&quot;</span>
<span id="L326" class="LineNr">326 </span> <span class="Delimiter">}</span>
<span id="L327" class="LineNr">327 </span> <span class="Delimiter">{</span>
<span id="L328" class="LineNr">328 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L329" class="LineNr">329 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L330" class="LineNr">330 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L331" class="LineNr">331 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L332" class="LineNr">332 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/done-4&quot;</span>
<span id="L333" class="LineNr">333 </span> <span class="Delimiter">}</span>
<span id="L334" class="LineNr">334 </span> <span class="Delimiter">{</span>
<span id="L335" class="LineNr">335 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x65</span> <span class="Comment"># 'e'</span>
<span id="L336" class="LineNr">336 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L337" class="LineNr">337 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L338" class="LineNr">338 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L339" class="LineNr">339 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/done-5&quot;</span>
<span id="L340" class="LineNr">340 </span> <span class="Delimiter">}</span>
<span id="L341" class="LineNr">341 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L342" class="LineNr">342 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L343" class="LineNr">343 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot; abc&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/row1&quot;</span>
<span id="L344" class="LineNr">344 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot; de &quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L301'>test-print-single-page-narrower-than-page-width-with-margin</a>/row2&quot;</span>
<span id="L345" class="LineNr">345 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L346" class="LineNr">346 </span><span class="Delimiter">}</span>
<span id="L347" class="LineNr">347 </span>
<span id="L348" class="LineNr">348 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a></span> <span class="Delimiter">{</span>
<span id="L349" class="LineNr">349 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L350" class="LineNr">350 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L351" class="LineNr">351 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">2</span>, <span class="Constant">2</span>, <span class="Constant">1</span>, <span class="Constant">0</span>, <span class="Constant">0</span> <span class="Comment"># 2 rows, 2 columns, 2 pages * 1 column each</span>
<span id="L352" class="LineNr">352 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L353" class="LineNr">353 </span> <span class="Delimiter">{</span>
<span id="L354" class="LineNr">354 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L355" class="LineNr">355 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L356" class="LineNr">356 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L357" class="LineNr">357 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L358" class="LineNr">358 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/done-1&quot;</span>
<span id="L359" class="LineNr">359 </span> <span class="Delimiter">}</span>
<span id="L360" class="LineNr">360 </span> <span class="Delimiter">{</span>
<span id="L361" class="LineNr">361 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L362" class="LineNr">362 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L363" class="LineNr">363 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L364" class="LineNr">364 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L365" class="LineNr">365 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/done-2&quot;</span>
<span id="L366" class="LineNr">366 </span> <span class="Delimiter">}</span>
<span id="L367" class="LineNr">367 </span> <span class="Delimiter">{</span>
<span id="L368" class="LineNr">368 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L369" class="LineNr">369 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L370" class="LineNr">370 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L371" class="LineNr">371 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L372" class="LineNr">372 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/done-3&quot;</span>
<span id="L373" class="LineNr">373 </span> <span class="Delimiter">}</span>
<span id="L374" class="LineNr">374 </span> <span class="Delimiter">{</span>
<span id="L375" class="LineNr">375 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L376" class="LineNr">376 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L377" class="LineNr">377 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L378" class="LineNr">378 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L379" class="LineNr">379 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/done-4&quot;</span>
<span id="L380" class="LineNr">380 </span> <span class="Delimiter">}</span>
<span id="L381" class="LineNr">381 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L382" class="LineNr">382 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L383" class="LineNr">383 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot;ac&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/row1&quot;</span>
<span id="L384" class="LineNr">384 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot;bd&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L348'>test-print-multiple-pages</a>/row2&quot;</span>
<span id="L385" class="LineNr">385 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L386" class="LineNr">386 </span><span class="Delimiter">}</span>
<span id="L387" class="LineNr">387 </span>
<span id="L388" class="LineNr">388 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a></span> <span class="Delimiter">{</span>
<span id="L389" class="LineNr">389 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L390" class="LineNr">390 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L391" class="LineNr">391 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">2</span>, <span class="Constant">4</span>, <span class="Constant">2</span>, <span class="Constant">0</span>, <span class="Constant">0</span> <span class="Comment"># 2 rows, 4 columns, 2 pages * 2 columns each</span>
<span id="L392" class="LineNr">392 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L393" class="LineNr">393 </span> <span class="Delimiter">{</span>
<span id="L394" class="LineNr">394 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L395" class="LineNr">395 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L396" class="LineNr">396 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L397" class="LineNr">397 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L398" class="LineNr">398 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-1&quot;</span>
<span id="L399" class="LineNr">399 </span> <span class="Delimiter">}</span>
<span id="L400" class="LineNr">400 </span> <span class="Delimiter">{</span>
<span id="L401" class="LineNr">401 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L402" class="LineNr">402 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L403" class="LineNr">403 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L404" class="LineNr">404 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L405" class="LineNr">405 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-2&quot;</span>
<span id="L406" class="LineNr">406 </span> <span class="Delimiter">}</span>
<span id="L407" class="LineNr">407 </span> <span class="Delimiter">{</span>
<span id="L408" class="LineNr">408 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L409" class="LineNr">409 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L410" class="LineNr">410 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L411" class="LineNr">411 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L412" class="LineNr">412 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-3&quot;</span>
<span id="L413" class="LineNr">413 </span> <span class="Delimiter">}</span>
<span id="L414" class="LineNr">414 </span> <span class="Delimiter">{</span>
<span id="L415" class="LineNr">415 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L416" class="LineNr">416 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L417" class="LineNr">417 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L418" class="LineNr">418 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L419" class="LineNr">419 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-4&quot;</span>
<span id="L420" class="LineNr">420 </span> <span class="Delimiter">}</span>
<span id="L421" class="LineNr">421 </span> <span class="Delimiter">{</span>
<span id="L422" class="LineNr">422 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x65</span> <span class="Comment"># 'e'</span>
<span id="L423" class="LineNr">423 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L424" class="LineNr">424 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L425" class="LineNr">425 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L426" class="LineNr">426 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-5&quot;</span>
<span id="L427" class="LineNr">427 </span> <span class="Delimiter">}</span>
<span id="L428" class="LineNr">428 </span> <span class="Delimiter">{</span>
<span id="L429" class="LineNr">429 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x66</span> <span class="Comment"># 'f'</span>
<span id="L430" class="LineNr">430 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L431" class="LineNr">431 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L432" class="LineNr">432 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L433" class="LineNr">433 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-6&quot;</span>
<span id="L434" class="LineNr">434 </span> <span class="Delimiter">}</span>
<span id="L435" class="LineNr">435 </span> <span class="Delimiter">{</span>
<span id="L436" class="LineNr">436 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x67</span> <span class="Comment"># 'g'</span>
<span id="L437" class="LineNr">437 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L438" class="LineNr">438 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L439" class="LineNr">439 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L440" class="LineNr">440 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-7&quot;</span>
<span id="L441" class="LineNr">441 </span> <span class="Delimiter">}</span>
<span id="L442" class="LineNr">442 </span> <span class="Delimiter">{</span>
<span id="L443" class="LineNr">443 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x68</span> <span class="Comment"># 'h'</span>
<span id="L444" class="LineNr">444 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L445" class="LineNr">445 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L446" class="LineNr">446 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L447" class="LineNr">447 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/done-8&quot;</span>
<span id="L448" class="LineNr">448 </span> <span class="Delimiter">}</span>
<span id="L449" class="LineNr">449 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L450" class="LineNr">450 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L451" class="LineNr">451 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot;abef&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/row1&quot;</span>
<span id="L452" class="LineNr">452 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot;cdgh&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L388'>test-print-multiple-pages-2</a>/row2&quot;</span>
<span id="L453" class="LineNr">453 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L454" class="LineNr">454 </span><span class="Delimiter">}</span>
<span id="L455" class="LineNr">455 </span>
<span id="L456" class="LineNr">456 </span><span class="PreProc">fn</span> <span class="muTest"><a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a></span> <span class="Delimiter">{</span>
<span id="L457" class="LineNr">457 </span> <span class="PreProc">var</span> pg-on-stack: <a href='paginated-screen.mu.html#L12'>paginated-screen</a>
<span id="L458" class="LineNr">458 </span> <span class="PreProc">var</span> pg/<span class="Constant">eax</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> address pg-on-stack
<span id="L459" class="LineNr">459 </span> <a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a> pg, <span class="Constant">3</span>, <span class="Constant">6</span>, <span class="Constant">2</span>, <span class="Constant">1</span>, <span class="Constant">1</span> <span class="Comment"># 3 rows, 5 columns, 2 pages * 2 columns each</span>
<span id="L460" class="LineNr">460 </span> <a href='paginated-screen.mu.html#L78'>start-drawing</a> pg
<span id="L461" class="LineNr">461 </span> <span class="Delimiter">{</span>
<span id="L462" class="LineNr">462 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x61</span> <span class="Comment"># 'a'</span>
<span id="L463" class="LineNr">463 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L464" class="LineNr">464 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L465" class="LineNr">465 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L466" class="LineNr">466 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-1&quot;</span>
<span id="L467" class="LineNr">467 </span> <span class="Delimiter">}</span>
<span id="L468" class="LineNr">468 </span> <span class="Delimiter">{</span>
<span id="L469" class="LineNr">469 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x62</span> <span class="Comment"># 'b'</span>
<span id="L470" class="LineNr">470 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L471" class="LineNr">471 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L472" class="LineNr">472 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L473" class="LineNr">473 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-2&quot;</span>
<span id="L474" class="LineNr">474 </span> <span class="Delimiter">}</span>
<span id="L475" class="LineNr">475 </span> <span class="Delimiter">{</span>
<span id="L476" class="LineNr">476 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x63</span> <span class="Comment"># 'c'</span>
<span id="L477" class="LineNr">477 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L478" class="LineNr">478 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L479" class="LineNr">479 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L480" class="LineNr">480 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-3&quot;</span>
<span id="L481" class="LineNr">481 </span> <span class="Delimiter">}</span>
<span id="L482" class="LineNr">482 </span> <span class="Delimiter">{</span>
<span id="L483" class="LineNr">483 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x64</span> <span class="Comment"># 'd'</span>
<span id="L484" class="LineNr">484 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L485" class="LineNr">485 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L486" class="LineNr">486 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L487" class="LineNr">487 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-4&quot;</span>
<span id="L488" class="LineNr">488 </span> <span class="Delimiter">}</span>
<span id="L489" class="LineNr">489 </span> <span class="Delimiter">{</span>
<span id="L490" class="LineNr">490 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x65</span> <span class="Comment"># 'e'</span>
<span id="L491" class="LineNr">491 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L492" class="LineNr">492 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L493" class="LineNr">493 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L494" class="LineNr">494 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-5&quot;</span>
<span id="L495" class="LineNr">495 </span> <span class="Delimiter">}</span>
<span id="L496" class="LineNr">496 </span> <span class="Delimiter">{</span>
<span id="L497" class="LineNr">497 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x66</span> <span class="Comment"># 'f'</span>
<span id="L498" class="LineNr">498 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L499" class="LineNr">499 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L500" class="LineNr">500 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L501" class="LineNr">501 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-6&quot;</span>
<span id="L502" class="LineNr">502 </span> <span class="Delimiter">}</span>
<span id="L503" class="LineNr">503 </span> <span class="Delimiter">{</span>
<span id="L504" class="LineNr">504 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x67</span> <span class="Comment"># 'g'</span>
<span id="L505" class="LineNr">505 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L506" class="LineNr">506 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L507" class="LineNr">507 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L508" class="LineNr">508 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">0</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-7&quot;</span>
<span id="L509" class="LineNr">509 </span> <span class="Delimiter">}</span>
<span id="L510" class="LineNr">510 </span> <span class="Delimiter">{</span>
<span id="L511" class="LineNr">511 </span> <span class="PreProc">var</span> c/<span class="Constant">ecx</span>: grapheme <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0x68</span> <span class="Comment"># 'h'</span>
<span id="L512" class="LineNr">512 </span> <a href='paginated-screen.mu.html#L162'>add-grapheme</a> pg, c
<span id="L513" class="LineNr">513 </span> <span class="PreProc">var</span> done?/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='paginated-screen.mu.html#L125'>done-drawing?</a> pg
<span id="L514" class="LineNr">514 </span> <span class="PreProc">var</span> done/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy done?
<span id="L515" class="LineNr">515 </span> <a href='../../102test.subx.html#L23'>check-ints-equal</a> done, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/grapheme-8&quot;</span>
<span id="L516" class="LineNr">516 </span> <span class="Delimiter">}</span>
<span id="L517" class="LineNr">517 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> pg, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L518" class="LineNr">518 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L519" class="LineNr">519 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">1</span>, <span class="Constant">&quot; &quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/row1&quot;</span>
<span id="L520" class="LineNr">520 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">2</span>, <span class="Constant">&quot; ab ef&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/row2&quot;</span>
<span id="L521" class="LineNr">521 </span> <a href='../../405screen.mu.html#L603'>check-screen-row</a> screen-addr, <span class="Constant">3</span>, <span class="Constant">&quot; cd gh&quot;</span>, <span class="Constant">&quot;F - <a href='paginated-screen.mu.html#L456'>test-print-multiple-pages-with-margins</a>/row3&quot;</span>
<span id="L522" class="LineNr">522 </span> <span class="Comment"># currently it's hard-coded that we avoid printing to the bottom-most row of the screen</span>
<span id="L523" class="LineNr">523 </span><span class="Delimiter">}</span>
<span id="L524" class="LineNr">524 </span>
<span id="L525" class="LineNr">525 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L525'>initialize-fake-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>), nrows: int, ncols: int, page-width: int, top-margin: int, left-margin: int <span class="Delimiter">{</span>
<span id="L526" class="LineNr">526 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L527" class="LineNr">527 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L528" class="LineNr">528 </span> <a href='../../120allocate.subx.html#L66'>allocate</a> screen-ah
<span id="L529" class="LineNr">529 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L530" class="LineNr">530 </span> <a href='../../405screen.mu.html#L30'>initialize-screen</a> screen-addr, nrows, ncols
<span id="L531" class="LineNr">531 </span> <a href='paginated-screen.mu.html#L29'>initialize-paginated-screen</a> self, page-width, top-margin, left-margin
<span id="L532" class="LineNr">532 </span><span class="Delimiter">}</span>
<span id="L533" class="LineNr">533 </span>
<span id="L534" class="LineNr">534 </span><span class="SalientComment">## simple delegates</span>
<span id="L535" class="LineNr">535 </span>
<span id="L536" class="LineNr">536 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L536'>reposition-cursor</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L537" class="LineNr">537 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L538" class="LineNr">538 </span> <span class="PreProc">var</span> r/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, row
<span id="L539" class="LineNr">539 </span> <span class="PreProc">var</span> c/<span class="Constant">edx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, col
<span id="L540" class="LineNr">540 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;reposition cursor: &quot;</span>
<span id="L541" class="LineNr">541 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *r</span>
<span id="L542" class="LineNr">542 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;, &quot;</span>
<span id="L543" class="LineNr">543 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *c</span>
<span id="L544" class="LineNr">544 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L545" class="LineNr">545 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L546" class="LineNr">546 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L547" class="LineNr">547 </span> <a href='../../405screen.mu.html#L116'>move-cursor</a> screen-addr, *r *c
<span id="L548" class="LineNr">548 </span><span class="Delimiter">}</span>
<span id="L549" class="LineNr">549 </span>
<span id="L550" class="LineNr">550 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L550'>clear-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L551" class="LineNr">551 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L552" class="LineNr">552 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L553" class="LineNr">553 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L554" class="LineNr">554 </span> <a href='../../405screen.mu.html#L80'>clear-screen</a> screen-addr
<span id="L555" class="LineNr">555 </span><span class="Delimiter">}</span>
<span id="L556" class="LineNr">556 </span>
<span id="L557" class="LineNr">557 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L557'>start-color-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>), fg: int, bg: int <span class="Delimiter">{</span>
<span id="L558" class="LineNr">558 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L559" class="LineNr">559 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L560" class="LineNr">560 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L561" class="LineNr">561 </span> <a href='../../405screen.mu.html#L464'>start-color</a> screen-addr, fg, bg
<span id="L562" class="LineNr">562 </span><span class="Delimiter">}</span>
<span id="L563" class="LineNr">563 </span>
<span id="L564" class="LineNr">564 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L564'>start-bold-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L565" class="LineNr">565 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L566" class="LineNr">566 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L567" class="LineNr">567 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L568" class="LineNr">568 </span> <a href='../../405screen.mu.html#L487'>start-bold</a> screen-addr
<span id="L569" class="LineNr">569 </span><span class="Delimiter">}</span>
<span id="L570" class="LineNr">570 </span>
<span id="L571" class="LineNr">571 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L571'>start-underline-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L572" class="LineNr">572 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L573" class="LineNr">573 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L574" class="LineNr">574 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L575" class="LineNr">575 </span> <a href='../../405screen.mu.html#L506'>start-underline</a> screen-addr
<span id="L576" class="LineNr">576 </span><span class="Delimiter">}</span>
<span id="L577" class="LineNr">577 </span>
<span id="L578" class="LineNr">578 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L578'>start-reverse-video-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L579" class="LineNr">579 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L580" class="LineNr">580 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L581" class="LineNr">581 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L582" class="LineNr">582 </span> <a href='../../405screen.mu.html#L525'>start-reverse-video</a> screen-addr
<span id="L583" class="LineNr">583 </span><span class="Delimiter">}</span>
<span id="L584" class="LineNr">584 </span>
<span id="L585" class="LineNr">585 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L585'>start-blinking-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L586" class="LineNr">586 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L587" class="LineNr">587 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L588" class="LineNr">588 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L589" class="LineNr">589 </span> <a href='../../405screen.mu.html#L544'>start-blinking</a> screen-addr
<span id="L590" class="LineNr">590 </span><span class="Delimiter">}</span>
<span id="L591" class="LineNr">591 </span>
<span id="L592" class="LineNr">592 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L592'>reset-formatting-on-paginated-screen</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L593" class="LineNr">593 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L594" class="LineNr">594 </span> <span class="PreProc">var</span> screen-ah/<span class="Constant">eax</span>: (addr handle <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L595" class="LineNr">595 </span> <span class="PreProc">var</span> screen-addr/<span class="Constant">eax</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L256'>lookup</a> *screen-ah
<span id="L596" class="LineNr">596 </span> <a href='../../405screen.mu.html#L442'>reset-formatting</a> screen-addr
<span id="L597" class="LineNr">597 </span><span class="Delimiter">}</span>
<span id="L598" class="LineNr">598 </span>
<span id="L599" class="LineNr">599 </span><span class="SalientComment">## helpers</span>
<span id="L600" class="LineNr">600 </span>
<span id="L601" class="LineNr">601 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L601'>next-line</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L602" class="LineNr">602 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;next-line\n&quot;</span>
<span id="L603" class="LineNr">603 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L604" class="LineNr">604 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L605" class="LineNr">605 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L606" class="LineNr">606 </span> <span class="Comment"># self-&gt;col = self-&gt;leftcol</span>
<span id="L607" class="LineNr">607 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L608" class="LineNr">608 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L609" class="LineNr">609 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, col
<span id="L610" class="LineNr">610 </span> copy-to *tmp, tmp2
<span id="L611" class="LineNr">611 </span> <span class="Comment"># self-&gt;row++</span>
<span id="L612" class="LineNr">612 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, row
<span id="L613" class="LineNr">613 </span> increment *tmp
<span id="L614" class="LineNr">614 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;next-line: row: &quot;</span>
<span id="L615" class="LineNr">615 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen *tmp</span>
<span id="L616" class="LineNr">616 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L617" class="LineNr">617 </span> <span class="Comment"># if (self-&gt;row &gt; self-&gt;botrow) next-page(self)</span>
<span id="L618" class="LineNr">618 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L619" class="LineNr">619 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, botrow
<span id="L620" class="LineNr">620 </span> compare tmp2, *tmp
<span id="L621" class="LineNr">621 </span> <span class="Delimiter">{</span>
<span id="L622" class="LineNr">622 </span> <span class="PreProc">break-if-&lt;=</span>
<span id="L623" class="LineNr">623 </span> <a href='paginated-screen.mu.html#L627'>next-page</a> self
<span id="L624" class="LineNr">624 </span> <span class="Delimiter">}</span>
<span id="L625" class="LineNr">625 </span><span class="Delimiter">}</span>
<span id="L626" class="LineNr">626 </span>
<span id="L627" class="LineNr">627 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='paginated-screen.mu.html#L627'>next-page</a></span> _self: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="Delimiter">{</span>
<span id="L628" class="LineNr">628 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;next-page\n&quot;</span>
<span id="L629" class="LineNr">629 </span> <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='paginated-screen.mu.html#L12'>paginated-screen</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L630" class="LineNr">630 </span> <span class="PreProc">var</span> tmp/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L631" class="LineNr">631 </span> <span class="PreProc">var</span> tmp2/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L632" class="LineNr">632 </span><span class="CommentedCode">#? # temporary: stop</span>
<span id="L633" class="LineNr">633 </span><span class="CommentedCode">#? tmp &lt;- get self, ncols</span>
<span id="L634" class="LineNr">634 </span><span class="CommentedCode">#? tmp2 &lt;- copy *tmp</span>
<span id="L635" class="LineNr">635 </span><span class="CommentedCode">#? tmp &lt;- get self, rightcol</span>
<span id="L636" class="LineNr">636 </span><span class="CommentedCode">#? copy-to *tmp, tmp2</span>
<span id="L637" class="LineNr">637 </span> <span class="Comment"># real: multiple pages</span>
<span id="L638" class="LineNr">638 </span> <span class="Comment"># self-&gt;leftcol = self-&gt;rightcol + left-margin</span>
<span id="L639" class="LineNr">639 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, rightcol
<span id="L640" class="LineNr">640 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L641" class="LineNr">641 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, left-margin
<span id="L642" class="LineNr">642 </span> tmp2 <span class="SpecialChar">&lt;-</span> add *tmp
<span id="L643" class="LineNr">643 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L644" class="LineNr">644 </span> copy-to *tmp, tmp2
<span id="L645" class="LineNr">645 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;left: &quot;</span>
<span id="L646" class="LineNr">646 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen tmp2</span>
<span id="L647" class="LineNr">647 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L648" class="LineNr">648 </span> <span class="Comment"># self-&gt;rightcol = self-&gt;leftcol + page-width</span>
<span id="L649" class="LineNr">649 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, page-width
<span id="L650" class="LineNr">650 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L651" class="LineNr">651 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L652" class="LineNr">652 </span> tmp2 <span class="SpecialChar">&lt;-</span> add *tmp
<span id="L653" class="LineNr">653 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, rightcol
<span id="L654" class="LineNr">654 </span> copy-to *tmp, tmp2
<span id="L655" class="LineNr">655 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;right: &quot;</span>
<span id="L656" class="LineNr">656 </span><span class="CommentedCode">#? print-int32-hex-to-real-screen tmp2</span>
<span id="L657" class="LineNr">657 </span><span class="CommentedCode">#? print-string-to-real-screen &quot;\n&quot;</span>
<span id="L658" class="LineNr">658 </span> <span class="Comment"># self-&gt;row = self-&gt;toprow</span>
<span id="L659" class="LineNr">659 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, toprow
<span id="L660" class="LineNr">660 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L661" class="LineNr">661 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, row
<span id="L662" class="LineNr">662 </span> copy-to *tmp, tmp2
<span id="L663" class="LineNr">663 </span> <span class="Comment"># self-&gt;col = self-&gt;leftcol</span>
<span id="L664" class="LineNr">664 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, leftcol
<span id="L665" class="LineNr">665 </span> tmp2 <span class="SpecialChar">&lt;-</span> copy *tmp
<span id="L666" class="LineNr">666 </span> tmp <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, col
<span id="L667" class="LineNr">667 </span> copy-to *tmp, tmp2
<span id="L668" class="LineNr">668 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->

4
html/apps/calls.subx.html generated
View File

@ -332,7 +332,7 @@ if ('onhashchange' in window) {
<span id="L271" class="LineNr"> 271 </span> <span class="subxS1Comment"># . if (eax != false) break</span>
<span id="L272" class="LineNr"> 272 </span> 3d/compare-eax-and 0/imm32/false
<span id="L273" class="LineNr"> 273 </span> 0f 85/jump-if-!= $parse-line:end/disp32
<span id="L274" class="Folded"> 274 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L274" class="Folded"> 274 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L314" class="LineNr"> 314 </span><span class="Constant">$parse-line:write-word</span>:
<span id="L315" class="LineNr"> 315 </span> <span class="subxComment"># write-int(words, word-slice-&gt;start)</span>
<span id="L316" class="LineNr"> 316 </span> <span class="subxS2Comment"># . . push args</span>
@ -688,7 +688,7 @@ if ('onhashchange' in window) {
<span id="L666" class="LineNr"> 666 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L667" class="LineNr"> 667 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L668" class="LineNr"> 668 </span> 81 0/subop/add %esp 4/imm32
<span id="L669" class="Folded"> 669 </span><span class="Folded">+-- 33 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L669" class="Folded"> 669 </span><span class="Folded">+-- 33 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L702" class="LineNr"> 702 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;# . (foo %eax)&quot;, msg)</span>
<span id="L703" class="LineNr"> 703 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L704" class="LineNr"> 704 </span> 68/push <span class="Constant">&quot;F - <a href='calls.subx.html#L612'>test-subx-calls-processes-calls</a>: comment&quot;</span>/imm32

16
html/apps/dquotes.subx.html generated
View File

@ -610,7 +610,7 @@ if ('onhashchange' in window) {
<span id="L547" class="LineNr"> 547 </span> <span class="subxComment"># == data 0x2</span>
<span id="L548" class="LineNr"> 548 </span> <span class="subxComment"># 4 5/imm32</span>
<span id="L549" class="LineNr"> 549 </span> <span class="subxComment"># We don't care right now what exactly happens to comments. Trailing spaces are also minor details.</span>
<span id="L550" class="Folded"> 550 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L550" class="Folded"> 550 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L576" class="LineNr"> 576 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;&quot;, msg)</span>
<span id="L577" class="LineNr"> 577 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L578" class="LineNr"> 578 </span> 68/push <span class="Constant">&quot;F - <a href='dquotes.subx.html#L409'>test-subx-dquotes-is-idempotent-by-default</a>/0&quot;</span>/imm32
@ -787,7 +787,7 @@ if ('onhashchange' in window) {
<span id="L749" class="LineNr"> 749 </span> <span class="subxComment"># called. We just want to make sure instructions using string literals</span>
<span id="L750" class="LineNr"> 750 </span> <span class="subxComment"># switch to a string variable with the right value.</span>
<span id="L751" class="LineNr"> 751 </span> <span class="subxComment"># (Modifying string literals completely off the radar for now.)</span>
<span id="L752" class="Folded"> 752 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L752" class="Folded"> 752 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L785" class="LineNr"> 785 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;== code 0x1 &quot;, msg)</span>
<span id="L786" class="LineNr"> 786 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L787" class="LineNr"> 787 </span> 68/push <span class="Constant">&quot;F - <a href='dquotes.subx.html#L662'>test-subx-dquotes-processes-string-literals</a>/0&quot;</span>/imm32
@ -1101,7 +1101,7 @@ if ('onhashchange' in window) {
<span id="L1095" class="LineNr">1095 </span> e8/call <a href='dquotes.subx.html#L863'>emit-string-literal-data</a>/disp32
<span id="L1096" class="LineNr">1096 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1097" class="LineNr">1097 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1098" class="Folded">1098 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1098" class="Folded">1098 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1124" class="LineNr">1124 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;3/imm32 61/a 62/b 63/c &quot;, msg)</span>
<span id="L1125" class="LineNr">1125 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1126" class="LineNr">1126 </span> 68/push <span class="Constant">&quot;F - test-emit-string-literal-data&quot;</span>/imm32
@ -1140,7 +1140,7 @@ if ('onhashchange' in window) {
<span id="L1159" class="LineNr">1159 </span> e8/call <a href='dquotes.subx.html#L863'>emit-string-literal-data</a>/disp32
<span id="L1160" class="LineNr">1160 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1161" class="LineNr">1161 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1162" class="Folded">1162 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1162" class="Folded">1162 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1188" class="LineNr">1188 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;0/imm32 &quot;, msg)</span>
<span id="L1189" class="LineNr">1189 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1190" class="LineNr">1190 </span> 68/push <span class="Constant">&quot;F - test-emit-string-literal-data-empty&quot;</span>/imm32
@ -1180,7 +1180,7 @@ if ('onhashchange' in window) {
<span id="L1224" class="LineNr">1224 </span> e8/call <a href='dquotes.subx.html#L863'>emit-string-literal-data</a>/disp32
<span id="L1225" class="LineNr">1225 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1226" class="LineNr">1226 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1227" class="Folded">1227 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1227" class="Folded">1227 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1253" class="LineNr">1253 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;3/imm32 61/a 20 62/b &quot;, msg) # ideally we'd like to say '20/space' but that requires managing names for codepoints</span>
<span id="L1254" class="LineNr">1254 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1255" class="LineNr">1255 </span> 68/push <span class="Constant">&quot;F - test-emit-string-literal-data-no-metadata-for-non-alphanumerics&quot;</span>/imm32
@ -1219,7 +1219,7 @@ if ('onhashchange' in window) {
<span id="L1288" class="LineNr">1288 </span> e8/call <a href='dquotes.subx.html#L863'>emit-string-literal-data</a>/disp32
<span id="L1289" class="LineNr">1289 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1290" class="LineNr">1290 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1291" class="Folded">1291 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1291" class="Folded">1291 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1317" class="LineNr">1317 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;3/imm32 61/a 22 62/b &quot;, msg)</span>
<span id="L1318" class="LineNr">1318 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1319" class="LineNr">1319 </span> 68/push <span class="Constant">&quot;F - test-emit-string-literal-data-handles-escape-sequences&quot;</span>/imm32
@ -1258,7 +1258,7 @@ if ('onhashchange' in window) {
<span id="L1352" class="LineNr">1352 </span> e8/call <a href='dquotes.subx.html#L863'>emit-string-literal-data</a>/disp32
<span id="L1353" class="LineNr">1353 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1354" class="LineNr">1354 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1355" class="Folded">1355 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1355" class="Folded">1355 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1381" class="LineNr">1381 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;3/imm32 61/a 0a 62/b &quot;, msg)</span>
<span id="L1382" class="LineNr">1382 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1383" class="LineNr">1383 </span> 68/push <span class="Constant">&quot;F - test-emit-string-literal-data-handles-newline-escape&quot;</span>/imm32
@ -1633,7 +1633,7 @@ if ('onhashchange' in window) {
<span id="L1752" class="LineNr">1752 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1753" class="LineNr">1753 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1754" class="LineNr">1754 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1755" class="Folded">1755 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1755" class="Folded">1755 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1781" class="LineNr">1781 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;/ghi&quot;, msg) # important that there's no leading space</span>
<span id="L1782" class="LineNr">1782 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1783" class="LineNr">1783 </span> 68/push <span class="Constant">&quot;F - test-emit-metadata-in-string-literal&quot;</span>/imm32

336
html/apps/mu.subx.html generated
View File

File diff suppressed because it is too large Load Diff

90
html/apps/pack.subx.html generated
View File

@ -213,7 +213,7 @@ if ('onhashchange' in window) {
<span id="L151" class="LineNr"> 151 </span> <span class="subxComment"># if (line-&gt;write == 0) break</span>
<span id="L152" class="LineNr"> 152 </span> 81 7/subop/compare 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/imm32 <span class="subxComment"># compare *ecx</span>
<span id="L153" class="LineNr"> 153 </span> 0f 84/jump-if-= $subx-pack:<span class="Constant">break</span>/disp32
<span id="L154" class="Folded"> 154 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L154" class="Folded"> 154 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L180" class="LineNr"> 180 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L181" class="LineNr"> 181 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L182" class="LineNr"> 182 </span> 52/push-edx
@ -235,7 +235,7 @@ if ('onhashchange' in window) {
<span id="L198" class="LineNr"> 198 </span> 3d/compare-eax-and 0/imm32/false
<span id="L199" class="LineNr"> 199 </span> 0f 85/jump-if-!= $subx-pack:pass-through/disp32
<span id="L200" class="LineNr"> 200 </span><span class="Constant">$subx-pack:check2</span>:
<span id="L201" class="Folded"> 201 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L201" class="Folded"> 201 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L241" class="LineNr"> 241 </span> <span class="subxComment"># if (!slice-equal?(word-slice, &quot;==&quot;)) goto next check</span>
<span id="L242" class="LineNr"> 242 </span> <span class="subxS1Comment"># . eax = slice-equal?(word-slice, &quot;==&quot;)</span>
<span id="L243" class="LineNr"> 243 </span> <span class="subxS2Comment"># . . push args</span>
@ -256,7 +256,7 @@ if ('onhashchange' in window) {
<span id="L258" class="LineNr"> 258 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L259" class="LineNr"> 259 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L260" class="LineNr"> 260 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L261" class="Folded"> 261 </span><span class="Folded">+-- 40 lines: #? # dump segment name ------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L261" class="Folded"> 261 </span><span class="Folded">+-- 40 lines: #? # dump segment name ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L301" class="LineNr"> 301 </span> <span class="subxComment"># in-code? = slice-equal?(word-slice, &quot;code&quot;)</span>
<span id="L302" class="LineNr"> 302 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L303" class="LineNr"> 303 </span> 68/push <span class="Constant">&quot;code&quot;</span>/imm32
@ -617,7 +617,7 @@ if ('onhashchange' in window) {
<span id="L658" class="LineNr"> 658 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L659" class="LineNr"> 659 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L660" class="LineNr"> 660 </span> <span class="subxComment"># check output</span>
<span id="L661" class="Folded"> 661 </span><span class="Folded">+-- 26 lines: #? # debug print ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L661" class="Folded"> 661 </span><span class="Folded">+-- 26 lines: #? # debug print ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L687" class="LineNr"> 687 </span> <span class="subxS1Comment"># . flush(_test-output-buffered-file)</span>
<span id="L688" class="LineNr"> 688 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L689" class="LineNr"> 689 </span> 68/push <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>/imm32
@ -751,7 +751,7 @@ if ('onhashchange' in window) {
<span id="L817" class="LineNr"> 817 </span> <span class="subxComment"># 68 20 # 68/push 0x20/imm8</span>
<span id="L818" class="LineNr"> 818 </span> <span class="subxComment"># == data 0x2</span>
<span id="L819" class="LineNr"> 819 </span> <span class="subxComment"># 03 04 00 00 00</span>
<span id="L820" class="Folded"> 820 </span><span class="Folded">+-- 26 lines: #? # debug print ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L820" class="Folded"> 820 </span><span class="Folded">+-- 26 lines: #? # debug print ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L846" class="LineNr"> 846 </span> <span class="subxS1Comment"># . flush(_test-output-buffered-file)</span>
<span id="L847" class="LineNr"> 847 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L848" class="LineNr"> 848 </span> 68/push <a href='../115write-byte.subx.html#L359'>_test-output-buffered-file</a>/imm32
@ -840,7 +840,7 @@ if ('onhashchange' in window) {
<span id="L931" class="LineNr"> 931 </span> 68/push 0/imm32/end
<span id="L932" class="LineNr"> 932 </span> 68/push 0/imm32/start
<span id="L933" class="LineNr"> 933 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ecx</span>
<span id="L934" class="Folded"> 934 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L934" class="Folded"> 934 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L960" class="LineNr"> 960 </span><span class="Constant">$convert-data:loop</span>:
<span id="L961" class="LineNr"> 961 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L962" class="LineNr"> 962 </span> <span class="subxS2Comment"># . . push args</span>
@ -850,7 +850,7 @@ if ('onhashchange' in window) {
<span id="L966" class="LineNr"> 966 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L967" class="LineNr"> 967 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L968" class="LineNr"> 968 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L969" class="Folded"> 969 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L969" class="Folded"> 969 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1009" class="LineNr">1009 </span><span class="Constant">$convert-data:check0</span>:
<span id="L1010" class="LineNr">1010 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L1011" class="LineNr">1011 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -1013,7 +1013,7 @@ if ('onhashchange' in window) {
<span id="L1168" class="LineNr">1168 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1169" class="LineNr">1169 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1170" class="LineNr">1170 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1171" class="Folded">1171 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1171" class="Folded">1171 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1197" class="LineNr">1197 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;# abcd&quot;, msg)</span>
<span id="L1198" class="LineNr">1198 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1199" class="LineNr">1199 </span> 68/push <span class="Constant">&quot;F - test-convert-data-passes-comments-through&quot;</span>/imm32
@ -1478,7 +1478,7 @@ if ('onhashchange' in window) {
<span id="L1658" class="LineNr">1658 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1659" class="LineNr">1659 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1660" class="LineNr">1660 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1661" class="Folded">1661 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1661" class="Folded">1661 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1687" class="LineNr">1687 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;30 abcd/o 42 e1 00 00 \n&quot;, msg)</span>
<span id="L1688" class="LineNr">1688 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1689" class="LineNr">1689 </span> 68/push <span class="Constant">&quot;F - test-convert-data-multiple-words&quot;</span>/imm32
@ -1545,7 +1545,7 @@ if ('onhashchange' in window) {
<span id="L1750" class="LineNr">1750 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1751" class="LineNr">1751 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1752" class="LineNr">1752 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1753" class="Folded">1753 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1753" class="Folded">1753 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1779" class="LineNr">1779 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;30 00 00 00 # comment&quot;, msg)</span>
<span id="L1780" class="LineNr">1780 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1781" class="LineNr">1781 </span> 68/push <span class="Constant">&quot;F - test-convert-data-trailing-comment&quot;</span>/imm32
@ -2065,7 +2065,7 @@ if ('onhashchange' in window) {
<span id="L2295" class="LineNr">2295 </span> e8/call <a href='../106stream.subx.html#L56'>rewind-stream</a>/disp32
<span id="L2296" class="LineNr">2296 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2297" class="LineNr">2297 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2298" class="Folded">2298 </span><span class="Folded">+-- 33 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2298" class="Folded">2298 </span><span class="Folded">+-- 33 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2331" class="LineNr">2331 </span><span class="Constant">$emit-modrm:loop</span>:
<span id="L2332" class="LineNr">2332 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L2333" class="LineNr">2333 </span> <span class="subxS2Comment"># . . push args</span>
@ -2075,7 +2075,7 @@ if ('onhashchange' in window) {
<span id="L2337" class="LineNr">2337 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L2338" class="LineNr">2338 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2339" class="LineNr">2339 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L2340" class="Folded">2340 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2340" class="Folded">2340 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2380" class="LineNr">2380 </span><span class="Constant">$emit-modrm:check0</span>:
<span id="L2381" class="LineNr">2381 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L2382" class="LineNr">2382 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -2311,7 +2311,7 @@ if ('onhashchange' in window) {
<span id="L2612" class="LineNr">2612 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2613" class="LineNr">2613 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2614" class="LineNr">2614 </span><span class="Constant">$emit-sib:loop</span>:
<span id="L2615" class="Folded">2615 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2615" class="Folded">2615 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2641" class="LineNr">2641 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L2642" class="LineNr">2642 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L2643" class="LineNr">2643 </span> 51/push-ecx
@ -2320,7 +2320,7 @@ if ('onhashchange' in window) {
<span id="L2646" class="LineNr">2646 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L2647" class="LineNr">2647 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2648" class="LineNr">2648 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L2649" class="Folded">2649 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2649" class="Folded">2649 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2689" class="LineNr">2689 </span><span class="Constant">$emit-sib:check0</span>:
<span id="L2690" class="LineNr">2690 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L2691" class="LineNr">2691 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -2509,7 +2509,7 @@ if ('onhashchange' in window) {
<span id="L2874" class="LineNr">2874 </span> e8/call <a href='../106stream.subx.html#L56'>rewind-stream</a>/disp32
<span id="L2875" class="LineNr">2875 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2876" class="LineNr">2876 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2877" class="Folded">2877 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2877" class="Folded">2877 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2903" class="LineNr">2903 </span><span class="Constant">$emit-disp:loop</span>:
<span id="L2904" class="LineNr">2904 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L2905" class="LineNr">2905 </span> <span class="subxS2Comment"># . . push args</span>
@ -2519,7 +2519,7 @@ if ('onhashchange' in window) {
<span id="L2909" class="LineNr">2909 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L2910" class="LineNr">2910 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2911" class="LineNr">2911 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L2912" class="Folded">2912 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2912" class="Folded">2912 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2952" class="LineNr">2952 </span><span class="Constant">$emit-disp:check0</span>:
<span id="L2953" class="LineNr">2953 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L2954" class="LineNr">2954 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -2664,7 +2664,7 @@ if ('onhashchange' in window) {
<span id="L3093" class="LineNr">3093 </span> e8/call <a href='../106stream.subx.html#L56'>rewind-stream</a>/disp32
<span id="L3094" class="LineNr">3094 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3095" class="LineNr">3095 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3096" class="Folded">3096 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3096" class="Folded">3096 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3122" class="LineNr">3122 </span><span class="Constant">$emit-imm:loop</span>:
<span id="L3123" class="LineNr">3123 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L3124" class="LineNr">3124 </span> <span class="subxS2Comment"># . . push args</span>
@ -2674,7 +2674,7 @@ if ('onhashchange' in window) {
<span id="L3128" class="LineNr">3128 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L3129" class="LineNr">3129 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3130" class="LineNr">3130 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L3131" class="Folded">3131 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3131" class="Folded">3131 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3171" class="LineNr">3171 </span><span class="Constant">$emit-imm:check0</span>:
<span id="L3172" class="LineNr">3172 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L3173" class="LineNr">3173 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -2993,7 +2993,7 @@ if ('onhashchange' in window) {
<span id="L3486" class="LineNr">3486 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3487" class="LineNr">3487 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3488" class="LineNr">3488 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3489" class="Folded">3489 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3489" class="Folded">3489 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3515" class="LineNr">3515 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab # ab/cd # comment&quot;, msg)</span>
<span id="L3516" class="LineNr">3516 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3517" class="LineNr">3517 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-single-opcode&quot;</span>/imm32
@ -3060,7 +3060,7 @@ if ('onhashchange' in window) {
<span id="L3578" class="LineNr">3578 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3579" class="LineNr">3579 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3580" class="LineNr">3580 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3581" class="Folded">3581 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3581" class="Folded">3581 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3607" class="LineNr">3607 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;0f ab # 0f/m1 ab/m2 # comment&quot;, msg)</span>
<span id="L3608" class="LineNr">3608 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3609" class="LineNr">3609 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-0f-opcode&quot;</span>/imm32
@ -3127,7 +3127,7 @@ if ('onhashchange' in window) {
<span id="L3670" class="LineNr">3670 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3671" class="LineNr">3671 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3672" class="LineNr">3672 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3673" class="Folded">3673 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3673" class="Folded">3673 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3699" class="LineNr">3699 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f2 ab # f2/m1 ab/m2 # comment&quot;, msg)</span>
<span id="L3700" class="LineNr">3700 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3701" class="LineNr">3701 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-f2-opcode&quot;</span>/imm32
@ -3194,7 +3194,7 @@ if ('onhashchange' in window) {
<span id="L3762" class="LineNr">3762 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3763" class="LineNr">3763 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3764" class="LineNr">3764 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3765" class="Folded">3765 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3765" class="Folded">3765 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3791" class="LineNr">3791 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f3 ab # f3/m1 ab/m2 # comment&quot;, msg)</span>
<span id="L3792" class="LineNr">3792 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3793" class="LineNr">3793 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-f3-opcode&quot;</span>/imm32
@ -3261,7 +3261,7 @@ if ('onhashchange' in window) {
<span id="L3854" class="LineNr">3854 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3855" class="LineNr">3855 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3856" class="LineNr">3856 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3857" class="Folded">3857 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3857" class="Folded">3857 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3883" class="LineNr">3883 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f2 0f ab # f2/m1 0f/m2 ab/m3 # comment&quot;, msg)</span>
<span id="L3884" class="LineNr">3884 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3885" class="LineNr">3885 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-f2-0f-opcode&quot;</span>/imm32
@ -3328,7 +3328,7 @@ if ('onhashchange' in window) {
<span id="L3946" class="LineNr">3946 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3947" class="LineNr">3947 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3948" class="LineNr">3948 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3949" class="Folded">3949 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3949" class="Folded">3949 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3975" class="LineNr">3975 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f3 0f ab # f3/m1 0f/m2 ab/m3 # comment&quot;, msg)</span>
<span id="L3976" class="LineNr">3976 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3977" class="LineNr">3977 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-f3-0f-opcode&quot;</span>/imm32
@ -3395,7 +3395,7 @@ if ('onhashchange' in window) {
<span id="L4038" class="LineNr">4038 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4039" class="LineNr">4039 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4040" class="LineNr">4040 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4041" class="Folded">4041 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4041" class="Folded">4041 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4067" class="LineNr">4067 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab # f3/m1 0f/m2 ab/m3 # comment&quot;, msg)</span>
<span id="L4068" class="LineNr">4068 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4069" class="LineNr">4069 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-unused-opcodes&quot;</span>/imm32
@ -3462,7 +3462,7 @@ if ('onhashchange' in window) {
<span id="L4130" class="LineNr">4130 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4131" class="LineNr">4131 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4132" class="LineNr">4132 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4133" class="Folded">4133 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4133" class="Folded">4133 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4159" class="LineNr">4159 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f2 ab # f2/m1 ab/m2 cd/m3 # comment&quot;, msg)</span>
<span id="L4160" class="LineNr">4160 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4161" class="LineNr">4161 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-unused-second-opcodes&quot;</span>/imm32
@ -3529,7 +3529,7 @@ if ('onhashchange' in window) {
<span id="L4222" class="LineNr">4222 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4223" class="LineNr">4223 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4224" class="LineNr">4224 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4225" class="Folded">4225 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4225" class="Folded">4225 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4251" class="LineNr">4251 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;f3 ab # f3/m1 ab/m2 cd/m3 # comment&quot;, msg)</span>
<span id="L4252" class="LineNr">4252 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4253" class="LineNr">4253 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-unused-second-opcodes&quot;</span>/imm32
@ -3596,7 +3596,7 @@ if ('onhashchange' in window) {
<span id="L4314" class="LineNr">4314 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4315" class="LineNr">4315 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4316" class="LineNr">4316 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4317" class="Folded">4317 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4317" class="Folded">4317 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4343" class="LineNr">4343 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 08 # 8b/copy 0/mod 0/rm32 1/r32&quot;, msg)</span>
<span id="L4344" class="LineNr">4344 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4345" class="LineNr">4345 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-modrm-byte&quot;</span>/imm32
@ -3661,7 +3661,7 @@ if ('onhashchange' in window) {
<span id="L4404" class="LineNr">4404 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4405" class="LineNr">4405 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4406" class="LineNr">4406 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4407" class="Folded">4407 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4407" class="Folded">4407 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4433" class="LineNr">4433 </span> <span class="subxComment"># check output</span>
<span id="L4434" class="LineNr">4434 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;# abcd&quot;, msg)</span>
<span id="L4435" class="LineNr">4435 </span> <span class="subxS2Comment"># . . push args</span>
@ -3729,7 +3729,7 @@ if ('onhashchange' in window) {
<span id="L4497" class="LineNr">4497 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4498" class="LineNr">4498 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4499" class="LineNr">4499 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4500" class="Folded">4500 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4500" class="Folded">4500 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4526" class="LineNr">4526 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ff 30 # ff 6/subop/push 0/mod 0/rm32&quot;, msg)</span>
<span id="L4527" class="LineNr">4527 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4528" class="LineNr">4528 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-modrm-byte-from-subop&quot;</span>/imm32
@ -3796,7 +3796,7 @@ if ('onhashchange' in window) {
<span id="L4589" class="LineNr">4589 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4590" class="LineNr">4590 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4591" class="LineNr">4591 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4592" class="Folded">4592 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4592" class="Folded">4592 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4618" class="LineNr">4618 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 08 # 8b/copy 0/rm32 1/r32&quot;, msg)</span>
<span id="L4619" class="LineNr">4619 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4620" class="LineNr">4620 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-modrm-byte-with-missing-mod&quot;</span>/imm32
@ -3863,7 +3863,7 @@ if ('onhashchange' in window) {
<span id="L4681" class="LineNr">4681 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4682" class="LineNr">4682 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4683" class="LineNr">4683 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4684" class="Folded">4684 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4684" class="Folded">4684 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4710" class="LineNr">4710 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 08 # 8b/copy 0/mod 1/r32&quot;, msg)</span>
<span id="L4711" class="LineNr">4711 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4712" class="LineNr">4712 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-modrm-byte-with-missing-rm32&quot;</span>/imm32
@ -3930,7 +3930,7 @@ if ('onhashchange' in window) {
<span id="L4773" class="LineNr">4773 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4774" class="LineNr">4774 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4775" class="LineNr">4775 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4776" class="Folded">4776 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4776" class="Folded">4776 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4802" class="LineNr">4802 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 00 # 8b/copy 0/mod 0/rm32&quot;, msg)</span>
<span id="L4803" class="LineNr">4803 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4804" class="LineNr">4804 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-modrm-byte-with-missing-r32&quot;</span>/imm32
@ -3997,7 +3997,7 @@ if ('onhashchange' in window) {
<span id="L4865" class="LineNr">4865 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4866" class="LineNr">4866 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4867" class="LineNr">4867 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4868" class="Folded">4868 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4868" class="Folded">4868 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4894" class="LineNr">4894 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 08 # 8b/copy 0/mod 4/rm32 1/r32 0/base 1/index 0/scale&quot;, msg)</span>
<span id="L4895" class="LineNr">4895 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4896" class="LineNr">4896 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-sib-byte&quot;</span>/imm32
@ -4064,7 +4064,7 @@ if ('onhashchange' in window) {
<span id="L4957" class="LineNr">4957 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L4958" class="LineNr">4958 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4959" class="LineNr">4959 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L4960" class="Folded">4960 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4960" class="Folded">4960 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4986" class="LineNr">4986 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 04 40 # 8b/copy 0/mod 4/rm32 1/scale&quot;, msg)</span>
<span id="L4987" class="LineNr">4987 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4988" class="LineNr">4988 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-scale&quot;</span>/imm32
@ -4131,7 +4131,7 @@ if ('onhashchange' in window) {
<span id="L5049" class="LineNr">5049 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5050" class="LineNr">5050 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5051" class="LineNr">5051 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5052" class="Folded">5052 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5052" class="Folded">5052 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5078" class="LineNr">5078 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 0c 08 # 8b/copy 0/mod 4/rm32 1/r32 1/index 0/scale&quot;, msg)</span>
<span id="L5079" class="LineNr">5079 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5080" class="LineNr">5080 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-sib-byte-with-missing-base&quot;</span>/imm32
@ -4198,7 +4198,7 @@ if ('onhashchange' in window) {
<span id="L5141" class="LineNr">5141 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5142" class="LineNr">5142 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5143" class="LineNr">5143 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5144" class="Folded">5144 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5144" class="Folded">5144 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5170" class="LineNr">5170 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 0c 08 # 8b/copy 0/mod 4/rm32 1/r32 0/base 0/scale&quot;, msg)</span>
<span id="L5171" class="LineNr">5171 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5172" class="LineNr">5172 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-sib-byte-with-missing-index&quot;</span>/imm32
@ -4265,7 +4265,7 @@ if ('onhashchange' in window) {
<span id="L5233" class="LineNr">5233 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5234" class="LineNr">5234 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5235" class="LineNr">5235 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5236" class="Folded">5236 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5236" class="Folded">5236 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5262" class="LineNr">5262 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;8b 0c 08 # 8b/copy 0/mod 4/rm32 1/r32 0/base 1/index&quot;, msg)</span>
<span id="L5263" class="LineNr">5263 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5264" class="LineNr">5264 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-emits-sib-byte-with-missing-scale&quot;</span>/imm32
@ -4332,7 +4332,7 @@ if ('onhashchange' in window) {
<span id="L5325" class="LineNr">5325 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5326" class="LineNr">5326 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5327" class="LineNr">5327 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5328" class="Folded">5328 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5328" class="Folded">5328 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5354" class="LineNr">5354 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;e8 20 00 00 00 # e8/call 20/disp32&quot;, msg)</span>
<span id="L5355" class="LineNr">5355 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5356" class="LineNr">5356 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-disp32-operand&quot;</span>/imm32
@ -4399,7 +4399,7 @@ if ('onhashchange' in window) {
<span id="L5417" class="LineNr">5417 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5418" class="LineNr">5418 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5419" class="LineNr">5419 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5420" class="Folded">5420 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5420" class="Folded">5420 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5446" class="LineNr">5446 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;e8 20 00 # e8/call 20/disp16&quot;, msg)</span>
<span id="L5447" class="LineNr">5447 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5448" class="LineNr">5448 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-disp16-operand&quot;</span>/imm32
@ -4466,7 +4466,7 @@ if ('onhashchange' in window) {
<span id="L5509" class="LineNr">5509 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5510" class="LineNr">5510 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5511" class="LineNr">5511 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5512" class="Folded">5512 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5512" class="Folded">5512 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5538" class="LineNr">5538 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;eb 20 # eb/jump 20/disp8&quot;, msg)</span>
<span id="L5539" class="LineNr">5539 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5540" class="LineNr">5540 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-disp8-operand&quot;</span>/imm32
@ -4533,7 +4533,7 @@ if ('onhashchange' in window) {
<span id="L5601" class="LineNr">5601 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5602" class="LineNr">5602 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5603" class="LineNr">5603 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5604" class="Folded">5604 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5604" class="Folded">5604 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5630" class="LineNr">5630 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;eb xyz/disp8 # eb/jump xyz/disp8&quot;, msg)</span>
<span id="L5631" class="LineNr">5631 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5632" class="LineNr">5632 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-disp8-name&quot;</span>/imm32
@ -4600,7 +4600,7 @@ if ('onhashchange' in window) {
<span id="L5693" class="LineNr">5693 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5694" class="LineNr">5694 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5695" class="LineNr">5695 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5696" class="Folded">5696 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5696" class="Folded">5696 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5722" class="LineNr">5722 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;68 20 00 00 00 # 68/push 0x20/imm32&quot;, msg)</span>
<span id="L5723" class="LineNr">5723 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5724" class="LineNr">5724 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-imm32-operand&quot;</span>/imm32
@ -4668,7 +4668,7 @@ if ('onhashchange' in window) {
<span id="L5786" class="LineNr">5786 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5787" class="LineNr">5787 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5788" class="LineNr">5788 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5789" class="Folded">5789 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5789" class="Folded">5789 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5815" class="LineNr">5815 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;68 20 00 # 68/push 0x20/imm16&quot;, msg)</span>
<span id="L5816" class="LineNr">5816 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5817" class="LineNr">5817 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-imm16-operand&quot;</span>/imm32
@ -4736,7 +4736,7 @@ if ('onhashchange' in window) {
<span id="L5879" class="LineNr">5879 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L5880" class="LineNr">5880 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L5881" class="LineNr">5881 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L5882" class="Folded">5882 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5882" class="Folded">5882 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L5908" class="LineNr">5908 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;68 20 # 68/push 0x20/imm8&quot;, msg)</span>
<span id="L5909" class="LineNr">5909 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L5910" class="LineNr">5910 </span> 68/push <span class="Constant">&quot;F - test-convert-instruction-handles-imm8-operand&quot;</span>/imm32

2
html/apps/print-file.mu.html generated
View File

@ -81,7 +81,7 @@ if ('onhashchange' in window) {
<span id="L23" class="LineNr">23 </span> <span class="PreProc">var</span> in: (handle buffered-file)
<span id="L24" class="LineNr">24 </span> <span class="Delimiter">{</span>
<span id="L25" class="LineNr">25 </span> <span class="PreProc">var</span> addr-in/<span class="Constant">eax</span>: (addr handle buffered-file) <span class="SpecialChar">&lt;-</span> address in
<span id="L26" class="LineNr">26 </span> <a href='../306files.subx.html#L3'>open</a> *filename, <span class="Constant">0</span>, addr-in
<span id="L26" class="LineNr">26 </span> <a href='../306files.subx.html#L12'>open</a> *filename, <span class="Constant">0</span>, addr-in
<span id="L27" class="LineNr">27 </span> <span class="Delimiter">}</span>
<span id="L28" class="LineNr">28 </span> <span class="PreProc">var</span> _in-addr/<span class="Constant">eax</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> <a href='../120allocate.subx.html#L256'>lookup</a> in
<span id="L29" class="LineNr">29 </span> <span class="PreProc">var</span> in-addr/<span class="Constant">ecx</span>: (addr buffered-file) <span class="SpecialChar">&lt;-</span> copy _in-addr

38
html/apps/sigils.subx.html generated
View File

@ -268,7 +268,7 @@ if ('onhashchange' in window) {
<span id="L206" class="LineNr"> 206 </span> 3d/compare-eax-and 0x25/imm32/percent
<span id="L207" class="LineNr"> 207 </span> 75/jump-if-!= $subx-sigils:check-for-indirect-mode/disp8
<span id="L208" class="LineNr"> 208 </span><span class="Constant">$subx-sigils:direct-mode</span>:
<span id="L209" class="Folded"> 209 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L209" class="Folded"> 209 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L249" class="LineNr"> 249 </span> <span class="subxComment"># emit-direct-mode(out, word-slice)</span>
<span id="L250" class="LineNr"> 250 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L251" class="LineNr"> 251 </span> 52/push-edx
@ -509,7 +509,7 @@ if ('onhashchange' in window) {
<span id="L486" class="LineNr"> 486 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L487" class="LineNr"> 487 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L488" class="LineNr"> 488 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L489" class="Folded"> 489 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L489" class="Folded"> 489 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L515" class="LineNr"> 515 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;== abcd 0x1 \n&quot;, msg)</span>
<span id="L516" class="LineNr"> 516 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L517" class="LineNr"> 517 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-passes-most-words-through&quot;</span>/imm32
@ -582,7 +582,7 @@ if ('onhashchange' in window) {
<span id="L584" class="LineNr"> 584 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L585" class="LineNr"> 585 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L586" class="LineNr"> 586 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L587" class="Folded"> 587 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L587" class="Folded"> 587 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L613" class="LineNr"> 613 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 3/mod/direct 0x00000001/rm32 \n&quot;, msg)</span>
<span id="L614" class="LineNr"> 614 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L615" class="LineNr"> 615 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-direct-mode&quot;</span>/imm32
@ -727,7 +727,7 @@ if ('onhashchange' in window) {
<span id="L754" class="LineNr"> 754 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L755" class="LineNr"> 755 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L756" class="LineNr"> 756 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L757" class="Folded"> 757 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L757" class="Folded"> 757 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L783" class="LineNr"> 783 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 0/mod/indirect 0x00000001/rm32 \n&quot;, msg)</span>
<span id="L784" class="LineNr"> 784 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L785" class="LineNr"> 785 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-register-indirect-mode&quot;</span>/imm32
@ -872,7 +872,7 @@ if ('onhashchange' in window) {
<span id="L924" class="LineNr"> 924 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L925" class="LineNr"> 925 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L926" class="LineNr"> 926 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L927" class="Folded"> 927 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L927" class="Folded"> 927 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L953" class="LineNr"> 953 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 0/mod/indirect 1/rm32 \n&quot;, msg)</span>
<span id="L954" class="LineNr"> 954 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L955" class="LineNr"> 955 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-register-indirect-mode-without-displacement&quot;</span>/imm32
@ -945,7 +945,7 @@ if ('onhashchange' in window) {
<span id="L1022" class="LineNr">1022 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1023" class="LineNr">1023 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1024" class="LineNr">1024 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1025" class="Folded">1025 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1025" class="Folded">1025 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1051" class="LineNr">1051 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 2/mod/*+disp32 1/rm32 4/disp32 \n&quot;, msg)</span>
<span id="L1052" class="LineNr">1052 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1053" class="LineNr">1053 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-register-indirect-mode-with-displacement&quot;</span>/imm32
@ -1019,7 +1019,7 @@ if ('onhashchange' in window) {
<span id="L1121" class="LineNr">1121 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1122" class="LineNr">1122 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1123" class="LineNr">1123 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1124" class="Folded">1124 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1124" class="Folded">1124 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1150" class="LineNr">1150 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 2/mod/*+disp32 4/rm32/sib 1/base 2/index 3/scale 4/disp32 \n&quot;, msg)</span>
<span id="L1151" class="LineNr">1151 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1152" class="LineNr">1152 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-register-indirect-mode-with-sib-byte&quot;</span>/imm32
@ -1092,7 +1092,7 @@ if ('onhashchange' in window) {
<span id="L1219" class="LineNr">1219 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1220" class="LineNr">1220 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1221" class="LineNr">1221 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1222" class="Folded">1222 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1222" class="Folded">1222 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1248" class="LineNr">1248 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 2/mod/*+disp32 4/rm32/sib 1/base 2/index 3/scale -4/disp32 \n&quot;, msg)</span>
<span id="L1249" class="LineNr">1249 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1250" class="LineNr">1250 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-register-indirect-mode-with-sib-byte-negative-displacement&quot;</span>/imm32
@ -1165,7 +1165,7 @@ if ('onhashchange' in window) {
<span id="L1317" class="LineNr">1317 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1318" class="LineNr">1318 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1319" class="LineNr">1319 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1320" class="Folded">1320 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream -----------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1320" class="Folded">1320 </span><span class="Folded">+-- 26 lines: #? # dump _test-output-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1346" class="LineNr">1346 </span> <span class="subxS1Comment"># . check-stream-equal(_test-output-stream, &quot;ab 0/mod/indirect 5/rm32/.disp32 Foo/disp32 \n&quot;, msg)</span>
<span id="L1347" class="LineNr">1347 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1348" class="LineNr">1348 </span> 68/push <span class="Constant">&quot;F - test-subx-sigils-indirect-mode-without-register&quot;</span>/imm32
@ -1194,7 +1194,7 @@ if ('onhashchange' in window) {
<span id="L1371" class="LineNr">1371 </span> <span class="subxComment"># ++local-slice-&gt;start to skip '%'</span>
<span id="L1372" class="LineNr">1372 </span> <span class="subxS1Comment"># . ++(*eax)</span>
<span id="L1373" class="LineNr">1373 </span> ff 0/subop/increment 0/mod/indirect 0/rm32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># increment *eax</span>
<span id="L1374" class="Folded">1374 </span><span class="Folded">+-- 24 lines: #? # write-slice-buffered(Stderr, word-slice) -------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1374" class="Folded">1374 </span><span class="Folded">+-- 24 lines: #? # write-slice-buffered(Stderr, word-slice) ----------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1398" class="LineNr">1398 </span> <span class="subxComment"># local-slice = next-token-from-slice(local-slice-&gt;start, local-slice-&gt;end, &quot;/&quot;)</span>
<span id="L1399" class="LineNr">1399 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1400" class="LineNr">1400 </span> 50/push-eax
@ -1292,7 +1292,7 @@ if ('onhashchange' in window) {
<span id="L1492" class="LineNr">1492 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1493" class="LineNr">1493 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1494" class="LineNr">1494 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1495" class="Folded">1495 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1495" class="Folded">1495 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1521" class="LineNr">1521 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;3/mod/direct 0/rm32&quot;, msg)</span>
<span id="L1522" class="LineNr">1522 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1523" class="LineNr">1523 </span> 68/push <span class="Constant">&quot;F - <a href='sigils.subx.html#L1452'>test-emit-direct-mode</a>/0&quot;</span>/imm32
@ -1350,7 +1350,7 @@ if ('onhashchange' in window) {
<span id="L1575" class="LineNr">1575 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L1576" class="LineNr">1576 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1577" class="LineNr">1577 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L1578" class="Folded">1578 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1578" class="Folded">1578 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1604" class="LineNr">1604 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;3/mod/direct 7/rm32&quot;, msg)</span>
<span id="L1605" class="LineNr">1605 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1606" class="LineNr">1606 </span> 68/push <span class="Constant">&quot;F - <a href='sigils.subx.html#L1452'>test-emit-direct-mode</a>/1&quot;</span>/imm32
@ -3122,7 +3122,7 @@ if ('onhashchange' in window) {
<span id="L3372" class="LineNr">3372 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3373" class="LineNr">3373 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3374" class="LineNr">3374 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3375" class="Folded">3375 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3375" class="Folded">3375 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3401" class="LineNr">3401 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;0/mod/indirect 0/rm32&quot;, msg)</span>
<span id="L3402" class="LineNr">3402 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3403" class="LineNr">3403 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode&quot;</span>/imm32
@ -3174,7 +3174,7 @@ if ('onhashchange' in window) {
<span id="L3449" class="LineNr">3449 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3450" class="LineNr">3450 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3451" class="LineNr">3451 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3452" class="Folded">3452 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3452" class="Folded">3452 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3478" class="LineNr">3478 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;0/mod/indirect 7/rm32&quot;, msg)</span>
<span id="L3479" class="LineNr">3479 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3480" class="LineNr">3480 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-2&quot;</span>/imm32
@ -3226,7 +3226,7 @@ if ('onhashchange' in window) {
<span id="L3526" class="LineNr">3526 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3527" class="LineNr">3527 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3528" class="LineNr">3528 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3529" class="Folded">3529 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3529" class="Folded">3529 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3555" class="LineNr">3555 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;2/mod/*+disp32 6/rm32 4/disp32&quot;, msg)</span>
<span id="L3556" class="LineNr">3556 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3557" class="LineNr">3557 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-with-disp&quot;</span>/imm32
@ -3278,7 +3278,7 @@ if ('onhashchange' in window) {
<span id="L3603" class="LineNr">3603 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3604" class="LineNr">3604 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3605" class="LineNr">3605 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3606" class="Folded">3606 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3606" class="Folded">3606 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3632" class="LineNr">3632 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;2/mod/*+disp32 6/rm32 -4/disp32&quot;, msg)</span>
<span id="L3633" class="LineNr">3633 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3634" class="LineNr">3634 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-with-disp&quot;</span>/imm32
@ -3330,7 +3330,7 @@ if ('onhashchange' in window) {
<span id="L3680" class="LineNr">3680 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3681" class="LineNr">3681 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3682" class="LineNr">3682 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3683" class="Folded">3683 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3683" class="Folded">3683 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3709" class="LineNr">3709 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;2/mod/indirect 4/rm32/sib 6/base 1/index 2/scale 4/disp&quot;, msg)</span>
<span id="L3710" class="LineNr">3710 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3711" class="LineNr">3711 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-with-sib&quot;</span>/imm32
@ -3382,7 +3382,7 @@ if ('onhashchange' in window) {
<span id="L3757" class="LineNr">3757 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3758" class="LineNr">3758 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3759" class="LineNr">3759 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3760" class="Folded">3760 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3760" class="Folded">3760 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3786" class="LineNr">3786 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;2/mod/*+disp32 4/rm32/sib 5/base/ebp 0/index 0/scale 0/disp32&quot;, msg)</span>
<span id="L3787" class="LineNr">3787 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3788" class="LineNr">3788 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-ebp&quot;</span>/imm32
@ -3434,7 +3434,7 @@ if ('onhashchange' in window) {
<span id="L3834" class="LineNr">3834 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L3835" class="LineNr">3835 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3836" class="LineNr">3836 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L3837" class="Folded">3837 </span><span class="Folded">+-- 26 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3837" class="Folded">3837 </span><span class="Folded">+-- 26 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3863" class="LineNr">3863 </span> <span class="subxComment"># check-stream-equal(_test-output-stream, &quot;2/mod/*+disp32 4/rm32/sib 4/base/ebp 0/index 0/scale 0/disp32&quot;, msg)</span>
<span id="L3864" class="LineNr">3864 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3865" class="LineNr">3865 </span> 68/push <span class="Constant">&quot;F - test-emit-indirect-mode-esp&quot;</span>/imm32

54
html/apps/survey.subx.html generated
View File

@ -387,7 +387,7 @@ if ('onhashchange' in window) {
<span id="L324" class="LineNr"> 324 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L325" class="LineNr"> 325 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L326" class="LineNr"> 326 </span> <span class="subxComment"># check trace</span>
<span id="L327" class="Folded"> 327 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L327" class="Folded"> 327 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L353" class="LineNr"> 353 </span> <span class="subxS1Comment"># . check-trace-contains(&quot;label 'x' is at address 0x00001079.&quot;, msg)</span>
<span id="L354" class="LineNr"> 354 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L355" class="LineNr"> 355 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L222'>test-subx-survey-computes-addresses</a>/0&quot;</span>/imm32
@ -546,7 +546,7 @@ if ('onhashchange' in window) {
<span id="L508" class="LineNr"> 508 </span> 8b/copy 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy *ecx to eax</span>
<span id="L509" class="LineNr"> 509 </span> 3d/compare-eax-and 0/imm32
<span id="L510" class="LineNr"> 510 </span> 0f 84/jump-if-= $compute-offsets:break-line-loop/disp32
<span id="L511" class="Folded"> 511 </span><span class="Folded">+-- 33 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L511" class="Folded"> 511 </span><span class="Folded">+-- 33 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L544" class="LineNr"> 544 </span><span class="Constant">$compute-offsets:word-loop</span>:
<span id="L545" class="LineNr"> 545 </span> <span class="subxComment"># next-word(line, word-slice)</span>
<span id="L546" class="LineNr"> 546 </span> 52/push-edx
@ -812,7 +812,7 @@ if ('onhashchange' in window) {
<span id="L806" class="LineNr"> 806 </span> 01/add 0/mod/indirect 5/rm32/.disp32 <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <a href='survey.subx.html#L407'>compute-offsets</a>:segment-offset/disp32 <span class="subxComment"># add eax to *segment-offset</span>
<span id="L807" class="LineNr"> 807 </span> <span class="subxComment"># file-offset += width</span>
<span id="L808" class="LineNr"> 808 </span> 01/add 0/mod/indirect 5/rm32/.disp32 <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <a href='survey.subx.html#L407'>compute-offsets</a>:file-offset/disp32 <span class="subxComment"># add eax to *file-offset</span>
<span id="L809" class="Folded"> 809 </span><span class="Folded">+-- 41 lines: #? # dump segment-offset ----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L809" class="Folded"> 809 </span><span class="Folded">+-- 41 lines: #? # dump segment-offset -------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L850" class="LineNr"> 850 </span> e9/jump $compute-offsets:word-loop/disp32
<span id="L851" class="LineNr"> 851 </span><span class="Constant">$compute-offsets:break-line-loop</span>:
<span id="L852" class="LineNr"> 852 </span> <span class="subxComment"># sinfo/edi = get-or-insert-handle(segments, curr-segment-name, row-size=16)</span>
@ -988,7 +988,7 @@ if ('onhashchange' in window) {
<span id="L1022" class="LineNr">1022 </span> e8/call <a href='survey.subx.html#L407'>compute-offsets</a>/disp32
<span id="L1023" class="LineNr">1023 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1024" class="LineNr">1024 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L1025" class="Folded">1025 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1025" class="Folded">1025 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1051" class="LineNr">1051 </span> <span class="subxComment"># check trace</span>
<span id="L1052" class="LineNr">1052 </span> <span class="subxS1Comment"># . check-trace-contains(&quot;segment 'code' is at file offset 0x00000000.&quot;, msg)</span>
<span id="L1053" class="LineNr">1053 </span> <span class="subxS2Comment"># . . push args</span>
@ -1152,7 +1152,7 @@ if ('onhashchange' in window) {
<span id="L1211" class="LineNr">1211 </span> 81 0/subop/add 3/mod/direct 6/rm32/esi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esi</span>
<span id="L1212" class="LineNr">1212 </span> eb/jump $compute-addresses:segment-loop/disp8
<span id="L1213" class="LineNr">1213 </span><span class="Constant">$compute-addresses:segment-break</span>:
<span id="L1214" class="Folded">1214 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1214" class="Folded">1214 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1240" class="LineNr">1240 </span> <span class="subxComment"># esi = labels</span>
<span id="L1241" class="LineNr">1241 </span> 8b/copy 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 6/r32/esi 0xc/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ebp+12) to esi</span>
<span id="L1242" class="LineNr">1242 </span> <span class="subxComment"># var max/ecx: (addr byte) = &amp;labels-&gt;data[labels-&gt;write]</span>
@ -1164,7 +1164,7 @@ if ('onhashchange' in window) {
<span id="L1248" class="LineNr">1248 </span> <span class="subxComment"># if (lrow &gt;= max) break</span>
<span id="L1249" class="LineNr">1249 </span> 39/compare 3/mod/direct 6/rm32/esi <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># compare esi with ecx</span>
<span id="L1250" class="LineNr">1250 </span> 0f 83/jump-if-addr&gt;= $compute-addresses:end/disp32
<span id="L1251" class="Folded">1251 </span><span class="Folded">+-- 26 lines: #? # dump lrow-&gt;key ---------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1251" class="Folded">1251 </span><span class="Folded">+-- 26 lines: #? # dump lrow-&gt;key ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1277" class="LineNr">1277 </span> <span class="subxComment"># var seg-name/edx: (addr array byte) = lookup(lrow-&gt;segment-name)</span>
<span id="L1278" class="LineNr">1278 </span> <span class="subxS1Comment"># . eax = lookup(lrow-&gt;segment-name)</span>
<span id="L1279" class="LineNr">1279 </span> <span class="subxS2Comment"># . . push args</span>
@ -1176,7 +1176,7 @@ if ('onhashchange' in window) {
<span id="L1285" class="LineNr">1285 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1286" class="LineNr">1286 </span> <span class="subxS1Comment"># . edx = eax</span>
<span id="L1287" class="LineNr">1287 </span> 89/copy 3/mod/direct 2/rm32/edx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/r32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy eax to edx</span>
<span id="L1288" class="Folded">1288 </span><span class="Folded">+-- 26 lines: #? # dump seg-name ----------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1288" class="Folded">1288 </span><span class="Folded">+-- 26 lines: #? # dump seg-name -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1314" class="LineNr">1314 </span> <span class="subxComment"># var label-seg/edx: (addr segment-info) = get(segments, seg-name, row-size=20, &quot;segment table&quot;)</span>
<span id="L1315" class="LineNr">1315 </span> <span class="subxS1Comment"># . eax = get(segments, seg-name, row-size=20)</span>
<span id="L1316" class="LineNr">1316 </span> <span class="subxS2Comment"># . . push args</span>
@ -1393,7 +1393,7 @@ if ('onhashchange' in window) {
<span id="L1527" class="LineNr">1527 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1528" class="LineNr">1528 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1529" class="LineNr">1529 </span> <span class="subxComment"># checks</span>
<span id="L1530" class="Folded">1530 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1530" class="Folded">1530 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1556" class="LineNr">1556 </span> <span class="subxS1Comment"># . check-trace-contains(&quot;segment 'a' starts at address 0x00001094.&quot;, msg)</span>
<span id="L1557" class="LineNr">1557 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1558" class="LineNr">1558 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L1369'>test-compute-addresses</a>/0&quot;</span>/imm32
@ -1556,7 +1556,7 @@ if ('onhashchange' in window) {
<span id="L1715" class="LineNr">1715 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1716" class="LineNr">1716 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1717" class="LineNr">1717 </span> <span class="subxComment"># checks</span>
<span id="L1718" class="Folded">1718 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1718" class="Folded">1718 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1744" class="LineNr">1744 </span> <span class="subxS1Comment"># . check-trace-contains(&quot;segment 'a' starts at address 0x00001074.&quot;, msg)</span>
<span id="L1745" class="LineNr">1745 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1746" class="LineNr">1746 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L1610'>test-compute-addresses-large-segments</a>/0&quot;</span>/imm32
@ -1594,7 +1594,7 @@ if ('onhashchange' in window) {
<span id="L1778" class="LineNr">1778 </span> <span class="subxS1Comment"># . prologue</span>
<span id="L1779" class="LineNr">1779 </span> 55/push-ebp
<span id="L1780" class="LineNr">1780 </span> 89/copy 3/mod/direct 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ebp</span>
<span id="L1781" class="Folded">1781 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-headers\n&quot;) --------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1781" class="Folded">1781 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-headers\n&quot;) -----------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1790" class="LineNr">1790 </span> <span class="subxComment"># emit-headers(out, segments, labels)</span>
<span id="L1791" class="LineNr">1791 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1792" class="LineNr">1792 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+20)</span>
@ -1604,7 +1604,7 @@ if ('onhashchange' in window) {
<span id="L1796" class="LineNr">1796 </span> e8/call <a href='survey.subx.html#L3043'>emit-headers</a>/disp32
<span id="L1797" class="LineNr">1797 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1798" class="LineNr">1798 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0xc/imm32 <span class="subxComment"># add to esp</span>
<span id="L1799" class="Folded">1799 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-segments\n&quot;) -------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1799" class="Folded">1799 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-segments\n&quot;) ----------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1808" class="LineNr">1808 </span> <span class="subxComment"># emit-segments(in, out, labels)</span>
<span id="L1809" class="LineNr">1809 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1810" class="LineNr">1810 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+20)</span>
@ -1718,7 +1718,7 @@ if ('onhashchange' in window) {
<span id="L1918" class="LineNr">1918 </span> e8/call <a href='../122read-line.subx.html#L218'>read-line</a>/disp32
<span id="L1919" class="LineNr">1919 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1920" class="LineNr">1920 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1921" class="Folded">1921 </span><span class="Folded">+-- 33 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1921" class="Folded">1921 </span><span class="Folded">+-- 33 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1954" class="LineNr">1954 </span><span class="Constant">$emit-segments:check-for-end-of-input</span>:
<span id="L1955" class="LineNr">1955 </span> <span class="subxComment"># if (line-&gt;write == 0) break</span>
<span id="L1956" class="LineNr">1956 </span> 81 7/subop/compare 0/mod/indirect 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0/imm32 <span class="subxComment"># compare *ecx</span>
@ -1742,7 +1742,7 @@ if ('onhashchange' in window) {
<span id="L1974" class="LineNr">1974 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L1975" class="LineNr">1975 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L1976" class="LineNr">1976 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L1977" class="Folded">1977 </span><span class="Folded">+-- 33 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L1977" class="Folded">1977 </span><span class="Folded">+-- 33 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2010" class="LineNr">2010 </span><span class="Constant">$emit-segments:check-for-end-of-line</span>:
<span id="L2011" class="LineNr">2011 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L2012" class="LineNr">2012 </span> <span class="subxS1Comment"># . eax = slice-empty?(word-slice)</span>
@ -1828,7 +1828,7 @@ if ('onhashchange' in window) {
<span id="L2092" class="LineNr">2092 </span> e8/call <a href='../124next-token.subx.html#L163'>next-token-from-slice</a>/disp32
<span id="L2093" class="LineNr">2093 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2094" class="LineNr">2094 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x10/imm32 <span class="subxComment"># add to esp</span>
<span id="L2095" class="Folded">2095 </span><span class="Folded">+-- 33 lines: #? # dump datum -------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2095" class="Folded">2095 </span><span class="Folded">+-- 33 lines: #? # dump datum ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2128" class="LineNr">2128 </span> <span class="subxComment"># info/esi = get-slice(labels, datum, row-size=24, &quot;label table&quot;)</span>
<span id="L2129" class="LineNr">2129 </span> <span class="subxS1Comment"># . eax = get-slice(labels, datum, row-size=24, &quot;label table&quot;)</span>
<span id="L2130" class="LineNr">2130 </span> <span class="subxS2Comment"># . . push args</span>
@ -1927,7 +1927,7 @@ if ('onhashchange' in window) {
<span id="L2223" class="LineNr">2223 </span> <span class="subxS1Comment"># . if (eax == false) goto next check</span>
<span id="L2224" class="LineNr">2224 </span> 3d/compare-eax-and 0/imm32/false
<span id="L2225" class="LineNr">2225 </span> 74/jump-if-= $emit-segments:check-code-label-for-disp8/disp8
<span id="L2226" class="Folded">2226 </span><span class="Folded">+-- 33 lines: #? # dump info-&gt;address -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2226" class="Folded">2226 </span><span class="Folded">+-- 33 lines: #? # dump info-&gt;address --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2259" class="LineNr">2259 </span><span class="Constant">$emit-segments:emit-code-label-imm32</span>:
<span id="L2260" class="LineNr">2260 </span> <span class="subxComment"># emit-hex(out, info-&gt;address, 4)</span>
<span id="L2261" class="LineNr">2261 </span> <span class="subxS2Comment"># . . push args</span>
@ -2234,7 +2234,7 @@ if ('onhashchange' in window) {
<span id="L2562" class="LineNr">2562 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L2563" class="LineNr">2563 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2564" class="LineNr">2564 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2565" class="Folded">2565 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2565" class="Folded">2565 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2598" class="LineNr">2598 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;ab cd ef gh &quot;, msg)</span>
<span id="L2599" class="LineNr">2599 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L2600" class="LineNr">2600 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L2409'>test-emit-segments-global-variable</a>/0&quot;</span>/imm32
@ -2413,7 +2413,7 @@ if ('onhashchange' in window) {
<span id="L2773" class="LineNr">2773 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L2774" class="LineNr">2774 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2775" class="LineNr">2775 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2776" class="Folded">2776 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2776" class="Folded">2776 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2809" class="LineNr">2809 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;ab cd &quot;, msg)</span>
<span id="L2810" class="LineNr">2810 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L2811" class="LineNr">2811 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L2639'>test-emit-segments-code-label</a>/0&quot;</span>/imm32
@ -2583,7 +2583,7 @@ if ('onhashchange' in window) {
<span id="L2975" class="LineNr">2975 </span> e8/call <a href='../115write-byte.subx.html#L81'>flush</a>/disp32
<span id="L2976" class="LineNr">2976 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L2977" class="LineNr">2977 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/imm32 <span class="subxComment"># add to esp</span>
<span id="L2978" class="Folded">2978 </span><span class="Folded">+-- 33 lines: #? # dump output ------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L2978" class="Folded">2978 </span><span class="Folded">+-- 33 lines: #? # dump output ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3011" class="LineNr">3011 </span> <span class="subxS1Comment"># . check-next-stream-line-equal(_test-output-stream, &quot;ab cd &quot;, msg)</span>
<span id="L3012" class="LineNr">3012 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3013" class="LineNr">3013 </span> 68/push <span class="Constant">&quot;F - <a href='survey.subx.html#L2841'>test-emit-segments-code-label-absolute</a>/0&quot;</span>/imm32
@ -2653,8 +2653,8 @@ if ('onhashchange' in window) {
<span id="L3077" class="LineNr">3077 </span> <span class="subxComment"># if (curr-segment &gt;= max) break</span>
<span id="L3078" class="LineNr">3078 </span> 39/compare 3/mod/direct 0/rm32/eax <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 1/r32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># compare eax with ecx</span>
<span id="L3079" class="LineNr">3079 </span> 0f 83/jump-if-addr&gt;= $emit-headers:end/disp32
<span id="L3080" class="Folded">3080 </span><span class="Folded">+-- 63 lines: #? # dump curr-segment-&gt;name ------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3143" class="Folded">3143 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-segment-header\n&quot;) -------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3080" class="Folded">3080 </span><span class="Folded">+-- 63 lines: #? # dump curr-segment-&gt;name ---------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3143" class="Folded">3143 </span><span class="Folded">+-- 9 lines: #? # write(2/stderr, &quot;emit-segment-header\n&quot;) ----------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3152" class="LineNr">3152 </span> <span class="subxComment"># emit-elf-program-header-entry(out, curr-segment)</span>
<span id="L3153" class="LineNr">3153 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3154" class="LineNr">3154 </span> 50/push-eax
@ -3174,7 +3174,7 @@ if ('onhashchange' in window) {
<span id="L3668" class="LineNr">3668 </span> e8/call <a href='survey.subx.html#L3603'>trace-sssns</a>/disp32
<span id="L3669" class="LineNr">3669 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3670" class="LineNr">3670 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esp</span>
<span id="L3671" class="Folded">3671 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3671" class="Folded">3671 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3697" class="LineNr">3697 </span> <span class="subxComment"># check-trace-contains(&quot;Abc 0x00000003 e&quot;)</span>
<span id="L3698" class="LineNr">3698 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3699" class="LineNr">3699 </span> 68/push <span class="Constant">&quot;F - test-trace-sssns&quot;</span>/imm32
@ -3256,7 +3256,7 @@ if ('onhashchange' in window) {
<span id="L3775" class="LineNr">3775 </span> e8/call <a href='survey.subx.html#L3710'>trace-snsns</a>/disp32
<span id="L3776" class="LineNr">3776 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3777" class="LineNr">3777 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esp</span>
<span id="L3778" class="Folded">3778 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3778" class="Folded">3778 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3804" class="LineNr">3804 </span> <span class="subxComment"># check-trace-contains(&quot;Abc 0x00000003 e&quot;)</span>
<span id="L3805" class="LineNr">3805 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3806" class="LineNr">3806 </span> 68/push <span class="Constant">&quot;F - test-trace-snsns&quot;</span>/imm32
@ -3356,7 +3356,7 @@ if ('onhashchange' in window) {
<span id="L3900" class="LineNr">3900 </span> e8/call <a href='survey.subx.html#L3817'>trace-slsls</a>/disp32
<span id="L3901" class="LineNr">3901 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L3902" class="LineNr">3902 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esp</span>
<span id="L3903" class="Folded">3903 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3903" class="Folded">3903 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L3929" class="LineNr">3929 </span> <span class="subxComment"># check-trace-contains(&quot;Abcde&quot;)</span>
<span id="L3930" class="LineNr">3930 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L3931" class="LineNr">3931 </span> 68/push <span class="Constant">&quot;F - test-trace-slsls&quot;</span>/imm32
@ -3447,7 +3447,7 @@ if ('onhashchange' in window) {
<span id="L4016" class="LineNr">4016 </span> e8/call <a href='survey.subx.html#L3942'>trace-slsns</a>/disp32
<span id="L4017" class="LineNr">4017 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4018" class="LineNr">4018 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esp</span>
<span id="L4019" class="Folded">4019 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4019" class="Folded">4019 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4045" class="LineNr">4045 </span> <span class="subxComment"># check-trace-contains(&quot;Abc 0x00000003 e&quot;)</span>
<span id="L4046" class="LineNr">4046 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4047" class="LineNr">4047 </span> 68/push <span class="Constant">&quot;F - test-trace-slsls&quot;</span>/imm32
@ -3538,7 +3538,7 @@ if ('onhashchange' in window) {
<span id="L4132" class="LineNr">4132 </span> e8/call <a href='survey.subx.html#L4058'>trace-slsss</a>/disp32
<span id="L4133" class="LineNr">4133 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4134" class="LineNr">4134 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 0x14/imm32 <span class="subxComment"># add to esp</span>
<span id="L4135" class="Folded">4135 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream -----------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4135" class="Folded">4135 </span><span class="Folded">+-- 26 lines: #? # dump *Trace-stream --------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4161" class="LineNr">4161 </span> <span class="subxComment"># check-trace-contains(&quot;Abcde&quot;)</span>
<span id="L4162" class="LineNr">4162 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4163" class="LineNr">4163 </span> 68/push <span class="Constant">&quot;F - test-trace-slsss&quot;</span>/imm32
@ -3581,7 +3581,7 @@ if ('onhashchange' in window) {
<span id="L4200" class="LineNr">4200 </span> 68/push 0/imm32/end
<span id="L4201" class="LineNr">4201 </span> 68/push 0/imm32/start
<span id="L4202" class="LineNr">4202 </span> 89/copy 3/mod/direct 1/rm32/ecx <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 4/r32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="subxComment"># copy esp to ecx</span>
<span id="L4203" class="Folded">4203 </span><span class="Folded">+-- 26 lines: #? # dump line --------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4203" class="Folded">4203 </span><span class="Folded">+-- 26 lines: #? # dump line -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4229" class="LineNr">4229 </span> <span class="subxS1Comment"># . rewind-stream(line)</span>
<span id="L4230" class="LineNr">4230 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L4231" class="LineNr">4231 </span> ff 6/subop/push 1/mod/*+disp8 5/rm32/ebp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/disp8 <span class="Normal"> . </span> <span class="subxComment"># push *(ebp+8)</span>
@ -3598,7 +3598,7 @@ if ('onhashchange' in window) {
<span id="L4242" class="LineNr">4242 </span> e8/call <a href='../127next-word.subx.html#L10'>next-word</a>/disp32
<span id="L4243" class="LineNr">4243 </span> <span class="subxS2Comment"># . . discard args</span>
<span id="L4244" class="LineNr">4244 </span> 81 0/subop/add 3/mod/direct 4/rm32/esp <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> <span class="Normal"> . </span> 8/imm32 <span class="subxComment"># add to esp</span>
<span id="L4245" class="Folded">4245 </span><span class="Folded">+-- 40 lines: #? # dump word-slice --------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4245" class="Folded">4245 </span><span class="Folded">+-- 40 lines: #? # dump word-slice -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------</span>
<span id="L4285" class="LineNr">4285 </span><span class="Constant">$num-bytes:check0</span>:
<span id="L4286" class="LineNr">4286 </span> <span class="subxComment"># if (slice-empty?(word-slice)) break</span>
<span id="L4287" class="LineNr">4287 </span> <span class="subxS1Comment"># . save result</span>

11
tools/update_html
View File

@ -8,6 +8,7 @@ set -e
# generate html/$1.html using /tmp/tags
process() {
mkdir -p html/`dirname $1`
rm -f html/$1.html
convert_html $1
tools/linkify /tmp/tags html/$1.html
@ -70,4 +71,14 @@ do
process $f
done
for f in apps/*/*.mu
do
test $# -gt 0 && test $1 != $f && continue
echo $f
( cd `dirname $f`
ctags -x ../../[0-9]*.subx ../../[0-9]*.mu `basename $f` > /tmp/tags
)
process $f
done
rm /tmp/tags