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

4899 

Bug in my linkify tool introduced in commit 4891.
This commit is contained in:
Kartik Agaram 2018-12-30 20:24:37 -08:00
parent 0474ec865a
commit 901ae47430
31 changed files with 160 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
html/subx/050_write.subx.html
View File

@ -69,7 +69,7 @@ if ('onhashchange' in window) {
<span id="L11" class="LineNr">11 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L12" class="LineNr">12 </span> cd/syscall 0x80/imm8
<span id="L13" class="LineNr">13 </span>
<span id="L14" class="LineNr">14 </span><span class="subxMinorFunction"><a href='050_write.subx.html#L14'>_write</a></span>: <span class="subxComment"># fd : int, s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L14" class="LineNr">14 </span><span class="subxMinorFunction">_write</span>: <span class="subxComment"># fd : int, s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L15" class="LineNr">15 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L16" class="LineNr">16 </span> 55/push-EBP
<span id="L17" class="LineNr">17 </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>

6
html/subx/051test.subx.html
View File

@ -80,7 +80,7 @@ if ('onhashchange' in window) {
<span id="L21" class="LineNr">21 </span> cd/syscall 0x80/imm8
<span id="L22" class="LineNr">22 </span>
<span id="L23" class="LineNr">23 </span><span class="subxComment"># print msg to stderr if a != b, otherwise print &quot;.&quot;</span>
<span id="L24" class="LineNr">24 </span><span class="subxFunction"><a href='051test.subx.html#L24'>check-ints-equal</a></span>: <span class="subxComment"># (a : int, b : int, msg : (address array byte)) -&gt; &lt;void&gt;</span>
<span id="L24" class="LineNr">24 </span><span class="subxFunction">check-ints-equal</span>: <span class="subxComment"># (a : int, b : int, msg : (address array byte)) -&gt; &lt;void&gt;</span>
<span id="L25" class="LineNr">25 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L26" class="LineNr">26 </span> 55/push-EBP
<span id="L27" class="LineNr">27 </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>
@ -139,14 +139,14 @@ if ('onhashchange' in window) {
<span id="L80" class="LineNr">80 </span>
<span id="L81" class="LineNr">81 </span><span class="subxComment"># length-prefixed string containing just a single newline</span>
<span id="L82" class="LineNr">82 </span><span class="subxComment"># convenient to have when printing messages and so on</span>
<span id="L83" class="LineNr">83 </span><span class="SpecialChar"><a href='051test.subx.html#L83'>Newline</a></span>:
<span id="L83" class="LineNr">83 </span><span class="SpecialChar">Newline</span>:
<span id="L84" class="LineNr">84 </span> <span class="subxComment"># size</span>
<span id="L85" class="LineNr">85 </span> 01 00 00 00
<span id="L86" class="LineNr">86 </span> <span class="subxComment"># data</span>
<span id="L87" class="LineNr">87 </span> 0a/newline
<span id="L88" class="LineNr">88 </span>
<span id="L89" class="LineNr">89 </span><span class="subxComment"># every test failure increments this counter</span>
<span id="L90" class="LineNr">90 </span><span class="SpecialChar"><a href='051test.subx.html#L90'>Num-test-failures</a></span>:
<span id="L90" class="LineNr">90 </span><span class="SpecialChar">Num-test-failures</span>:
<span id="L91" class="LineNr">91 </span> 00 00 00 00
<span id="L92" class="LineNr">92 </span>
<span id="L93" class="LineNr">93 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

20
html/subx/052kernel_string_equal.subx.html
View File

@ -89,7 +89,7 @@ if ('onhashchange' in window) {
<span id="L28" class="LineNr"> 28 </span>
<span id="L29" class="LineNr"> 29 </span><span class="subxComment"># compare a null-terminated ascii string with a more idiomatic length-prefixed byte array</span>
<span id="L30" class="LineNr"> 30 </span><span class="subxComment"># reason for the name: the only place we should have null-terminated ascii strings is from commandline args</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction"><a href='052kernel_string_equal.subx.html#L31'>kernel-string-equal</a></span>: <span class="subxComment"># s : null-terminated ascii string, benchmark : length-prefixed ascii string -&gt; EAX : boolean</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction">kernel-string-equal</span>: <span class="subxComment"># s : null-terminated ascii string, benchmark : length-prefixed ascii string -&gt; EAX : boolean</span>
<span id="L32" class="LineNr"> 32 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L33" class="LineNr"> 33 </span> 55/push-EBP
<span id="L34" class="LineNr"> 34 </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>
@ -171,7 +171,7 @@ if ('onhashchange' in window) {
<span id="L110" class="LineNr">110 </span>
<span id="L111" class="LineNr">111 </span><span class="subxH1Comment"># - tests</span>
<span id="L112" class="LineNr">112 </span>
<span id="L113" class="LineNr">113 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L113'>test-compare-null-kernel-string-with-empty-array</a></span>:
<span id="L113" class="LineNr">113 </span><span class="subxTest">test-compare-null-kernel-string-with-empty-array</span>:
<span id="L114" class="LineNr">114 </span> <span class="subxComment"># EAX = kernel-string-equal(Null-kernel-string, &quot;&quot;)</span>
<span id="L115" class="LineNr">115 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L116" class="LineNr">116 </span> 68/push <span class="Constant">&quot;&quot;</span>/imm32
@ -191,7 +191,7 @@ if ('onhashchange' in window) {
<span id="L130" class="LineNr">130 </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="L131" class="LineNr">131 </span> c3/return
<span id="L132" class="LineNr">132 </span>
<span id="L133" class="LineNr">133 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L133'>test-compare-null-kernel-string-with-non-empty-array</a></span>:
<span id="L133" class="LineNr">133 </span><span class="subxTest">test-compare-null-kernel-string-with-non-empty-array</span>:
<span id="L134" class="LineNr">134 </span> <span class="subxComment"># EAX = kernel-string-equal(Null-kernel-string, &quot;Abc&quot;)</span>
<span id="L135" class="LineNr">135 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L136" class="LineNr">136 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -211,7 +211,7 @@ if ('onhashchange' in window) {
<span id="L150" class="LineNr">150 </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="L151" class="LineNr">151 </span> c3/return
<span id="L152" class="LineNr">152 </span>
<span id="L153" class="LineNr">153 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L153'>test-compare-kernel-string-with-equal-array</a></span>:
<span id="L153" class="LineNr">153 </span><span class="subxTest">test-compare-kernel-string-with-equal-array</span>:
<span id="L154" class="LineNr">154 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Abc&quot;)</span>
<span id="L155" class="LineNr">155 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L156" class="LineNr">156 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -231,7 +231,7 @@ if ('onhashchange' in window) {
<span id="L170" class="LineNr">170 </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="L171" class="LineNr">171 </span> c3/return
<span id="L172" class="LineNr">172 </span>
<span id="L173" class="LineNr">173 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L173'>test-compare-kernel-string-with-inequal-array</a></span>:
<span id="L173" class="LineNr">173 </span><span class="subxTest">test-compare-kernel-string-with-inequal-array</span>:
<span id="L174" class="LineNr">174 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Adc&quot;)</span>
<span id="L175" class="LineNr">175 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L176" class="LineNr">176 </span> 68/push <span class="Constant">&quot;Adc&quot;</span>/imm32
@ -251,7 +251,7 @@ if ('onhashchange' in window) {
<span id="L190" class="LineNr">190 </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="L191" class="LineNr">191 </span> c3/return
<span id="L192" class="LineNr">192 </span>
<span id="L193" class="LineNr">193 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L193'>test-compare-kernel-string-with-empty-array</a></span>:
<span id="L193" class="LineNr">193 </span><span class="subxTest">test-compare-kernel-string-with-empty-array</span>:
<span id="L194" class="LineNr">194 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;&quot;)</span>
<span id="L195" class="LineNr">195 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L196" class="LineNr">196 </span> 68/push <span class="Constant">&quot;&quot;</span>/imm32
@ -271,7 +271,7 @@ if ('onhashchange' in window) {
<span id="L210" class="LineNr">210 </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="L211" class="LineNr">211 </span> c3/return
<span id="L212" class="LineNr">212 </span>
<span id="L213" class="LineNr">213 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L213'>test-compare-kernel-string-with-shorter-array</a></span>:
<span id="L213" class="LineNr">213 </span><span class="subxTest">test-compare-kernel-string-with-shorter-array</span>:
<span id="L214" class="LineNr">214 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Ab&quot;)</span>
<span id="L215" class="LineNr">215 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L216" class="LineNr">216 </span> 68/push <span class="Constant">&quot;Ab&quot;</span>/imm32
@ -291,7 +291,7 @@ if ('onhashchange' in window) {
<span id="L230" class="LineNr">230 </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="L231" class="LineNr">231 </span> c3/return
<span id="L232" class="LineNr">232 </span>
<span id="L233" class="LineNr">233 </span><span class="subxTest"><a href='052kernel_string_equal.subx.html#L233'>test-compare-kernel-string-with-longer-array</a></span>:
<span id="L233" class="LineNr">233 </span><span class="subxTest">test-compare-kernel-string-with-longer-array</span>:
<span id="L234" class="LineNr">234 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Abcd&quot;)</span>
<span id="L235" class="LineNr">235 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L236" class="LineNr">236 </span> 68/push <span class="Constant">&quot;Abcd&quot;</span>/imm32
@ -313,9 +313,9 @@ if ('onhashchange' in window) {
<span id="L252" class="LineNr">252 </span>
<span id="L253" class="LineNr">253 </span>== data
<span id="L254" class="LineNr">254 </span>
<span id="L255" class="LineNr">255 </span><span class="SpecialChar"><a href='052kernel_string_equal.subx.html#L255'>Null-kernel-string</a></span>:
<span id="L255" class="LineNr">255 </span><span class="SpecialChar">Null-kernel-string</span>:
<span id="L256" class="LineNr">256 </span> 00/null
<span id="L257" class="LineNr">257 </span><span class="SpecialChar"><a href='052kernel_string_equal.subx.html#L257'>Abc-kernel-string</a></span>:
<span id="L257" class="LineNr">257 </span><span class="SpecialChar">Abc-kernel-string</span>:
<span id="L258" class="LineNr">258 </span> 41/A 62/b 63/c 00/null
<span id="L259" class="LineNr">259 </span>
<span id="L260" class="LineNr">260 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

4
html/subx/053new_segment.subx.html
View File

@ -81,7 +81,7 @@ if ('onhashchange' in window) {
<span id="L22" class="LineNr">22 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L23" class="LineNr">23 </span> cd/syscall 0x80/imm8
<span id="L24" class="LineNr">24 </span>
<span id="L25" class="LineNr">25 </span><span class="subxFunction"><a href='053new_segment.subx.html#L25'>new-segment</a></span>: <span class="subxComment"># len : int -&gt; address</span>
<span id="L25" class="LineNr">25 </span><span class="subxFunction">new-segment</span>: <span class="subxComment"># len : int -&gt; address</span>
<span id="L26" class="LineNr">26 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L27" class="LineNr">27 </span> 55/push-EBP
<span id="L28" class="LineNr">28 </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>
@ -105,7 +105,7 @@ if ('onhashchange' in window) {
<span id="L46" class="LineNr">46 </span>== data
<span id="L47" class="LineNr">47 </span>
<span id="L48" class="LineNr">48 </span><span class="subxComment"># various constants used here were found in the Linux sources (search for file mman-common.h)</span>
<span id="L49" class="LineNr">49 </span><span class="subxMinorFunction"><a href='053new_segment.subx.html#L49'>_mmap-new-segment</a></span>: <span class="subxComment"># type mmap_arg_struct</span>
<span id="L49" class="LineNr">49 </span><span class="subxMinorFunction">_mmap-new-segment</span>: <span class="subxComment"># type mmap_arg_struct</span>
<span id="L50" class="LineNr">50 </span> <span class="subxComment"># addr</span>
<span id="L51" class="LineNr">51 </span> 00 00 00 00 <span class="subxComment"># null</span>
<span id="L52" class="LineNr">52 </span> <span class="subxComment"># len</span>

10
html/subx/054string_equal.subx.html
View File

@ -74,7 +74,7 @@ if ('onhashchange' in window) {
<span id="L13" class="LineNr"> 13 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L14" class="LineNr"> 14 </span> cd/syscall 0x80/imm8
<span id="L15" class="LineNr"> 15 </span>
<span id="L16" class="LineNr"> 16 </span><span class="subxFunction"><a href='054string_equal.subx.html#L16'>string-equal</a></span>: <span class="subxComment"># s : string, benchmark : string -&gt; EAX : boolean</span>
<span id="L16" class="LineNr"> 16 </span><span class="subxFunction">string-equal</span>: <span class="subxComment"># s : string, benchmark : string -&gt; EAX : boolean</span>
<span id="L17" class="LineNr"> 17 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L18" class="LineNr"> 18 </span> 55/push-EBP
<span id="L19" class="LineNr"> 19 </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>
@ -148,7 +148,7 @@ if ('onhashchange' in window) {
<span id="L87" class="LineNr"> 87 </span>
<span id="L88" class="LineNr"> 88 </span><span class="subxH1Comment"># - tests</span>
<span id="L89" class="LineNr"> 89 </span>
<span id="L90" class="LineNr"> 90 </span><span class="subxTest"><a href='054string_equal.subx.html#L90'>test-compare-empty-with-empty-string</a></span>:
<span id="L90" class="LineNr"> 90 </span><span class="subxTest">test-compare-empty-with-empty-string</span>:
<span id="L91" class="LineNr"> 91 </span> <span class="subxComment"># EAX = string-equal(&quot;&quot;, &quot;&quot;)</span>
<span id="L92" class="LineNr"> 92 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L93" class="LineNr"> 93 </span> 68/push <span class="Constant">&quot;&quot;</span>/imm32
@ -168,7 +168,7 @@ if ('onhashchange' in window) {
<span id="L107" class="LineNr">107 </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="L108" class="LineNr">108 </span> c3/return
<span id="L109" class="LineNr">109 </span>
<span id="L110" class="LineNr">110 </span><span class="subxTest"><a href='054string_equal.subx.html#L110'>test-compare-empty-with-non-empty-string</a></span>: <span class="subxComment"># also checks length-mismatch code path</span>
<span id="L110" class="LineNr">110 </span><span class="subxTest">test-compare-empty-with-non-empty-string</span>: <span class="subxComment"># also checks length-mismatch code path</span>
<span id="L111" class="LineNr">111 </span> <span class="subxComment"># EAX = string-equal(&quot;&quot;, &quot;Abc&quot;)</span>
<span id="L112" class="LineNr">112 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L113" class="LineNr">113 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -188,7 +188,7 @@ if ('onhashchange' in window) {
<span id="L127" class="LineNr">127 </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="L128" class="LineNr">128 </span> c3/return
<span id="L129" class="LineNr">129 </span>
<span id="L130" class="LineNr">130 </span><span class="subxTest"><a href='054string_equal.subx.html#L130'>test-compare-equal-strings</a></span>:
<span id="L130" class="LineNr">130 </span><span class="subxTest">test-compare-equal-strings</span>:
<span id="L131" class="LineNr">131 </span> <span class="subxComment"># EAX = string-equal(&quot;Abc&quot;, &quot;Abc&quot;)</span>
<span id="L132" class="LineNr">132 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L133" class="LineNr">133 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -208,7 +208,7 @@ if ('onhashchange' in window) {
<span id="L147" class="LineNr">147 </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="L148" class="LineNr">148 </span> c3/return
<span id="L149" class="LineNr">149 </span>
<span id="L150" class="LineNr">150 </span><span class="subxTest"><a href='054string_equal.subx.html#L150'>test-compare-inequal-strings-equal-lengths</a></span>:
<span id="L150" class="LineNr">150 </span><span class="subxTest">test-compare-inequal-strings-equal-lengths</span>:
<span id="L151" class="LineNr">151 </span> <span class="subxComment"># EAX = string-equal(&quot;Abc&quot;, &quot;Adc&quot;)</span>
<span id="L152" class="LineNr">152 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L153" class="LineNr">153 </span> 68/push <span class="Constant">&quot;Adc&quot;</span>/imm32

20
html/subx/055trace.subx.html
View File

@ -84,12 +84,12 @@ if ('onhashchange' in window) {
<span id="L22" class="LineNr"> 22 </span>== data
<span id="L23" class="LineNr"> 23 </span>
<span id="L24" class="LineNr"> 24 </span><span class="subxComment"># We'll save the address of the trace segment here.</span>
<span id="L25" class="LineNr"> 25 </span><span class="SpecialChar"><a href='055trace.subx.html#L25'>Trace-stream</a></span>:
<span id="L25" class="LineNr"> 25 </span><span class="SpecialChar">Trace-stream</span>:
<span id="L26" class="LineNr"> 26 </span> 00 00 00 00
<span id="L27" class="LineNr"> 27 </span>
<span id="L28" class="LineNr"> 28 </span><span class="subxComment"># Fake trace-stream for tests.</span>
<span id="L29" class="LineNr"> 29 </span><span class="subxComment"># Also illustrates the layout of the real trace-stream (segment).</span>
<span id="L30" class="LineNr"> 30 </span><span class="subxMinorFunction"><a href='055trace.subx.html#L30'>_test-trace-stream</a></span>:
<span id="L30" class="LineNr"> 30 </span><span class="subxMinorFunction">_test-trace-stream</span>:
<span id="L31" class="LineNr"> 31 </span> <span class="subxComment"># current write index</span>
<span id="L32" class="LineNr"> 32 </span> 00 00 00 00
<span id="L33" class="LineNr"> 33 </span> <span class="subxComment"># current read index</span>
@ -114,7 +114,7 @@ if ('onhashchange' in window) {
<span id="L52" class="LineNr"> 52 </span>
<span id="L53" class="LineNr"> 53 </span><span class="subxComment"># Allocate a new segment for the trace stream, initialize its length, and save its address to Trace-stream.</span>
<span id="L54" class="LineNr"> 54 </span><span class="subxComment"># The Trace-stream segment will consist of variable-length lines separated by newlines (0x0a)</span>
<span id="L55" class="LineNr"> 55 </span><span class="subxFunction"><a href='055trace.subx.html#L55'>initialize-trace-stream</a></span>:
<span id="L55" class="LineNr"> 55 </span><span class="subxFunction">initialize-trace-stream</span>:
<span id="L56" class="LineNr"> 56 </span> <span class="subxComment"># EAX = new-segment(0x1000)</span>
<span id="L57" class="LineNr"> 57 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L58" class="LineNr"> 58 </span> 68/push 0x1000/imm32/N
@ -130,7 +130,7 @@ if ('onhashchange' in window) {
<span id="L68" class="LineNr"> 68 </span>
<span id="L69" class="LineNr"> 69 </span><span class="subxComment"># Append a string to the given trace stream.</span>
<span id="L70" class="LineNr"> 70 </span><span class="subxComment"># Silently give up if it's already full. Or truncate the string if there isn't enough room.</span>
<span id="L71" class="LineNr"> 71 </span><span class="subxFunction"><a href='055trace.subx.html#L71'>trace</a></span>: <span class="subxComment"># t : (address trace-stream), line : string</span>
<span id="L71" class="LineNr"> 71 </span><span class="subxFunction">trace</span>: <span class="subxComment"># t : (address trace-stream), line : string</span>
<span id="L72" class="LineNr"> 72 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L73" class="LineNr"> 73 </span> 55/push-EBP
<span id="L74" class="LineNr"> 74 </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>
@ -197,7 +197,7 @@ if ('onhashchange' in window) {
<span id="L135" class="LineNr">135 </span> 5d/pop-to-EBP
<span id="L136" class="LineNr">136 </span> c3/return
<span id="L137" class="LineNr">137 </span>
<span id="L138" class="LineNr">138 </span><span class="subxFunction"><a href='055trace.subx.html#L138'>clear-trace-stream</a></span>: <span class="subxComment"># t : (address trace-stream)</span>
<span id="L138" class="LineNr">138 </span><span class="subxFunction">clear-trace-stream</span>: <span class="subxComment"># t : (address trace-stream)</span>
<span id="L139" class="LineNr">139 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L140" class="LineNr">140 </span> 55/push-EBP
<span id="L141" class="LineNr">141 </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>
@ -237,7 +237,7 @@ if ('onhashchange' in window) {
<span id="L175" class="LineNr">175 </span>
<span id="L176" class="LineNr">176 </span><span class="subxH1Comment"># - tests</span>
<span id="L177" class="LineNr">177 </span>
<span id="L178" class="LineNr">178 </span><span class="subxTest"><a href='055trace.subx.html#L178'>test-trace-single</a></span>:
<span id="L178" class="LineNr">178 </span><span class="subxTest">test-trace-single</span>:
<span id="L179" class="LineNr">179 </span> <span class="subxComment"># clear-trace-stream(_test-trace-stream)</span>
<span id="L180" class="LineNr">180 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L181" class="LineNr">181 </span> 68/push <a href='055trace.subx.html#L30'>_test-trace-stream</a>/imm32
@ -267,7 +267,7 @@ if ('onhashchange' in window) {
<span id="L205" class="LineNr">205 </span> <span class="subxComment"># end</span>
<span id="L206" class="LineNr">206 </span> c3/return
<span id="L207" class="LineNr">207 </span>
<span id="L208" class="LineNr">208 </span><span class="subxTest"><a href='055trace.subx.html#L208'>test-trace-appends</a></span>:
<span id="L208" class="LineNr">208 </span><span class="subxTest">test-trace-appends</span>:
<span id="L209" class="LineNr">209 </span> <span class="subxComment"># clear-trace-stream(_test-trace-stream)</span>
<span id="L210" class="LineNr">210 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L211" class="LineNr">211 </span> 68/push <a href='055trace.subx.html#L30'>_test-trace-stream</a>/imm32
@ -305,7 +305,7 @@ if ('onhashchange' in window) {
<span id="L243" class="LineNr">243 </span> <span class="subxComment"># end</span>
<span id="L244" class="LineNr">244 </span> c3/return
<span id="L245" class="LineNr">245 </span>
<span id="L246" class="LineNr">246 </span><span class="subxTest"><a href='055trace.subx.html#L246'>test-trace-empty-line</a></span>:
<span id="L246" class="LineNr">246 </span><span class="subxTest">test-trace-empty-line</span>:
<span id="L247" class="LineNr">247 </span> <span class="subxComment"># clear-trace-stream(_test-trace-stream)</span>
<span id="L248" class="LineNr">248 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L249" class="LineNr">249 </span> 68/push <a href='055trace.subx.html#L30'>_test-trace-stream</a>/imm32
@ -338,7 +338,7 @@ if ('onhashchange' in window) {
<span id="L276" class="LineNr">276 </span><span class="subxH1Comment"># - helpers</span>
<span id="L277" class="LineNr">277 </span>
<span id="L278" class="LineNr">278 </span><span class="subxComment"># 3-argument variant of _append</span>
<span id="L279" class="LineNr">279 </span><span class="subxMinorFunction"><a href='055trace.subx.html#L279'>_append-3</a></span>: <span class="subxComment"># out : address, outend : address, s : (array byte) -&gt; num_bytes_appended/EAX</span>
<span id="L279" class="LineNr">279 </span><span class="subxMinorFunction">_append-3</span>: <span class="subxComment"># out : address, outend : address, s : (array byte) -&gt; num_bytes_appended/EAX</span>
<span id="L280" class="LineNr">280 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L281" class="LineNr">281 </span> 55/push-EBP
<span id="L282" class="LineNr">282 </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>
@ -370,7 +370,7 @@ if ('onhashchange' in window) {
<span id="L308" class="LineNr">308 </span> c3/return
<span id="L309" class="LineNr">309 </span>
<span id="L310" class="LineNr">310 </span><span class="subxComment"># 4-argument variant of _append</span>
<span id="L311" class="LineNr">311 </span><span class="subxMinorFunction"><a href='055trace.subx.html#L311'>_append-4</a></span>: <span class="subxComment"># out : address, outend : address, in : address, inend : address -&gt; num_bytes_appended/EAX</span>
<span id="L311" class="LineNr">311 </span><span class="subxMinorFunction">_append-4</span>: <span class="subxComment"># out : address, outend : address, in : address, inend : address -&gt; num_bytes_appended/EAX</span>
<span id="L312" class="LineNr">312 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L313" class="LineNr">313 </span> 55/push-EBP
<span id="L314" class="LineNr">314 </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>

10
html/subx/056write.subx.html
View File

@ -89,7 +89,7 @@ if ('onhashchange' in window) {
<span id="L28" class="LineNr"> 28 </span> cd/syscall 0x80/imm8
<span id="L29" class="LineNr"> 29 </span>
<span id="L30" class="LineNr"> 30 </span><span class="subxComment"># TODO: come up with a way to signal when a write to disk fails</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction"><a href='056write.subx.html#L31'>write</a></span>: <span class="subxComment"># f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction">write</span>: <span class="subxComment"># f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L32" class="LineNr"> 32 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L33" class="LineNr"> 33 </span> 55/push-EBP
<span id="L34" class="LineNr"> 34 </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>
@ -143,7 +143,7 @@ if ('onhashchange' in window) {
<span id="L82" class="LineNr"> 82 </span> 5d/pop-to-EBP
<span id="L83" class="LineNr"> 83 </span> c3/return
<span id="L84" class="LineNr"> 84 </span>
<span id="L85" class="LineNr"> 85 </span><span class="subxFunction"><a href='056write.subx.html#L85'>clear-stream</a></span>: <span class="subxComment"># f : (address stream) -&gt; &lt;void&gt;</span>
<span id="L85" class="LineNr"> 85 </span><span class="subxFunction">clear-stream</span>: <span class="subxComment"># f : (address stream) -&gt; &lt;void&gt;</span>
<span id="L86" class="LineNr"> 86 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L87" class="LineNr"> 87 </span> 55/push-EBP
<span id="L88" class="LineNr"> 88 </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>
@ -181,7 +181,7 @@ if ('onhashchange' in window) {
<span id="L120" class="LineNr">120 </span> 5d/pop-to-EBP
<span id="L121" class="LineNr">121 </span> c3/return
<span id="L122" class="LineNr">122 </span>
<span id="L123" class="LineNr">123 </span><span class="subxTest"><a href='056write.subx.html#L123'>test-write-single</a></span>:
<span id="L123" class="LineNr">123 </span><span class="subxTest">test-write-single</span>:
<span id="L124" class="LineNr">124 </span> <span class="subxComment"># clear-stream(_test-stream)</span>
<span id="L125" class="LineNr">125 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L126" class="LineNr">126 </span> 68/push <a href='056write.subx.html#L193'>_test-stream</a>/imm32
@ -211,7 +211,7 @@ if ('onhashchange' in window) {
<span id="L150" class="LineNr">150 </span> <span class="subxComment"># end</span>
<span id="L151" class="LineNr">151 </span> c3/return
<span id="L152" class="LineNr">152 </span>
<span id="L153" class="LineNr">153 </span><span class="subxTest"><a href='056write.subx.html#L153'>test-write-appends</a></span>:
<span id="L153" class="LineNr">153 </span><span class="subxTest">test-write-appends</span>:
<span id="L154" class="LineNr">154 </span> <span class="subxComment"># clear-stream(_test-stream)</span>
<span id="L155" class="LineNr">155 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L156" class="LineNr">156 </span> 68/push <a href='056write.subx.html#L193'>_test-stream</a>/imm32
@ -251,7 +251,7 @@ if ('onhashchange' in window) {
<span id="L190" class="LineNr">190 </span>
<span id="L191" class="LineNr">191 </span>== data
<span id="L192" class="LineNr">192 </span>
<span id="L193" class="LineNr">193 </span><span class="subxMinorFunction"><a href='056write.subx.html#L193'>_test-stream</a></span>:
<span id="L193" class="LineNr">193 </span><span class="subxMinorFunction">_test-stream</span>:
<span id="L194" class="LineNr">194 </span> <span class="subxComment"># current write index</span>
<span id="L195" class="LineNr">195 </span> 00 00 00 00
<span id="L196" class="LineNr">196 </span> <span class="subxComment"># current read index</span>

10
html/subx/057stop.subx.html
View File

@ -110,7 +110,7 @@ if ('onhashchange' in window) {
<span id="L48" class="LineNr"> 48 </span><span class="subxComment"># Configure an exit-descriptor for a call pushing 'nbytes' bytes of args to</span>
<span id="L49" class="LineNr"> 49 </span><span class="subxComment"># the stack.</span>
<span id="L50" class="LineNr"> 50 </span><span class="subxComment"># Ugly that we need to know the size of args, but so it goes.</span>
<span id="L51" class="LineNr"> 51 </span><span class="subxFunction"><a href='057stop.subx.html#L51'>tailor-exit-descriptor</a></span>: <span class="subxComment"># ed : (address exit-descriptor), nbytes : int -&gt; &lt;void&gt;</span>
<span id="L51" class="LineNr"> 51 </span><span class="subxFunction">tailor-exit-descriptor</span>: <span class="subxComment"># ed : (address exit-descriptor), nbytes : int -&gt; &lt;void&gt;</span>
<span id="L52" class="LineNr"> 52 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L53" class="LineNr"> 53 </span> 55/push-EBP
<span id="L54" class="LineNr"> 54 </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>
@ -158,7 +158,7 @@ if ('onhashchange' in window) {
<span id="L96" class="LineNr"> 96 </span> 5d/pop-to-EBP
<span id="L97" class="LineNr"> 97 </span> c3/return
<span id="L98" class="LineNr"> 98 </span>
<span id="L99" class="LineNr"> 99 </span><span class="subxFunction"><a href='057stop.subx.html#L99'>stop</a></span>: <span class="subxComment"># ed : (address exit-descriptor), value : int</span>
<span id="L99" class="LineNr"> 99 </span><span class="subxFunction">stop</span>: <span class="subxComment"># ed : (address exit-descriptor), value : int</span>
<span id="L100" class="LineNr">100 </span> <span class="subxComment"># no prolog; one way or another, we're going to clobber registers</span>
<span id="L101" class="LineNr">101 </span> <span class="subxComment"># EAX = ed</span>
<span id="L102" class="LineNr">102 </span> 8b/copy 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none <span class="Normal"> . </span> 0/r32/EAX 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ESP+4) to EAX</span>
@ -179,7 +179,7 @@ if ('onhashchange' in window) {
<span id="L117" class="LineNr">117 </span><span class="Constant">$stop:end</span>:
<span id="L118" class="LineNr">118 </span> c3/return <span class="subxComment"># doesn't return to caller</span>
<span id="L119" class="LineNr">119 </span>
<span id="L120" class="LineNr">120 </span><span class="subxTest"><a href='057stop.subx.html#L120'>test-stop-skips-returns-on-exit</a></span>:
<span id="L120" class="LineNr">120 </span><span class="subxTest">test-stop-skips-returns-on-exit</span>:
<span id="L121" class="LineNr">121 </span> <span class="subxComment"># This looks like the standard prolog, but is here for different reasons.</span>
<span id="L122" class="LineNr">122 </span> <span class="subxComment"># A function calling 'stop' can't rely on EBP persisting past the call.</span>
<span id="L123" class="LineNr">123 </span> <span class="subxComment">#</span>
@ -228,7 +228,7 @@ if ('onhashchange' in window) {
<span id="L166" class="LineNr">166 </span> 5d/pop-to-EBP
<span id="L167" class="LineNr">167 </span> c3/return
<span id="L168" class="LineNr">168 </span>
<span id="L169" class="LineNr">169 </span><span class="subxMinorFunction"><a href='057stop.subx.html#L169'>_test-stop-1</a></span>: <span class="subxComment"># ed : (address exit-descriptor)</span>
<span id="L169" class="LineNr">169 </span><span class="subxMinorFunction">_test-stop-1</span>: <span class="subxComment"># ed : (address exit-descriptor)</span>
<span id="L170" class="LineNr">170 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L171" class="LineNr">171 </span> 55/push-EBP
<span id="L172" class="LineNr">172 </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>
@ -255,7 +255,7 @@ if ('onhashchange' in window) {
<span id="L193" class="LineNr">193 </span> 5d/pop-to-EBP
<span id="L194" class="LineNr">194 </span> c3/return
<span id="L195" class="LineNr">195 </span>
<span id="L196" class="LineNr">196 </span><span class="subxMinorFunction"><a href='057stop.subx.html#L196'>_test-stop-2</a></span>: <span class="subxComment"># ed : (address exit-descriptor)</span>
<span id="L196" class="LineNr">196 </span><span class="subxMinorFunction">_test-stop-2</span>: <span class="subxComment"># ed : (address exit-descriptor)</span>
<span id="L197" class="LineNr">197 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L198" class="LineNr">198 </span> 55/push-EBP
<span id="L199" class="LineNr">199 </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>

12
html/subx/058read.subx.html
View File

@ -114,7 +114,7 @@ if ('onhashchange' in window) {
<span id="L52" class="LineNr"> 52 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L53" class="LineNr"> 53 </span> cd/syscall 0x80/imm8
<span id="L54" class="LineNr"> 54 </span>
<span id="L55" class="LineNr"> 55 </span><span class="subxFunction"><a href='058read.subx.html#L55'>read</a></span>: <span class="subxComment"># f : fd or (address stream), s : (address stream) -&gt; num-bytes-read/EAX</span>
<span id="L55" class="LineNr"> 55 </span><span class="subxFunction">read</span>: <span class="subxComment"># f : fd or (address stream), s : (address stream) -&gt; num-bytes-read/EAX</span>
<span id="L56" class="LineNr"> 56 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L57" class="LineNr"> 57 </span> 55/push-EBP
<span id="L58" class="LineNr"> 58 </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>
@ -180,7 +180,7 @@ if ('onhashchange' in window) {
<span id="L118" class="LineNr">118 </span><span class="subxComment"># Unclear how I'd use it, though. Callers seem to need the check anyway.</span>
<span id="L119" class="LineNr">119 </span><span class="subxComment"># Maybe a better helper would be 'empty-stream?'</span>
<span id="L120" class="LineNr">120 </span>
<span id="L121" class="LineNr">121 </span><span class="subxMinorFunction"><a href='058read.subx.html#L121'>_read</a></span>: <span class="subxComment"># fd : int, s : (address stream) -&gt; num-bytes-read/EAX</span>
<span id="L121" class="LineNr">121 </span><span class="subxMinorFunction">_read</span>: <span class="subxComment"># fd : int, s : (address stream) -&gt; num-bytes-read/EAX</span>
<span id="L122" class="LineNr">122 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L123" class="LineNr">123 </span> 55/push-EBP
<span id="L124" class="LineNr">124 </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>
@ -241,7 +241,7 @@ if ('onhashchange' in window) {
<span id="L179" class="LineNr">179 </span>
<span id="L180" class="LineNr">180 </span><span class="subxH1Comment"># - tests</span>
<span id="L181" class="LineNr">181 </span>
<span id="L182" class="LineNr">182 </span><span class="subxTest"><a href='058read.subx.html#L182'>test-read-single</a></span>:
<span id="L182" class="LineNr">182 </span><span class="subxTest">test-read-single</span>:
<span id="L183" class="LineNr">183 </span> <span class="subxH1Comment"># - write a single character into _test-stream, then read from its buffered-file</span>
<span id="L184" class="LineNr">184 </span> <span class="subxComment"># clear-stream(_test-stream)</span>
<span id="L185" class="LineNr">185 </span> <span class="subxS2Comment"># . . push args</span>
@ -296,7 +296,7 @@ if ('onhashchange' in window) {
<span id="L234" class="LineNr">234 </span> <span class="subxComment"># end</span>
<span id="L235" class="LineNr">235 </span> c3/return
<span id="L236" class="LineNr">236 </span>
<span id="L237" class="LineNr">237 </span><span class="subxTest"><a href='058read.subx.html#L237'>test-read-is-stateful</a></span>:
<span id="L237" class="LineNr">237 </span><span class="subxTest">test-read-is-stateful</span>:
<span id="L238" class="LineNr">238 </span> <span class="subxH1Comment"># - make two consecutive reads, check that their results are appended</span>
<span id="L239" class="LineNr">239 </span> <span class="subxComment"># clear-stream(_test-stream)</span>
<span id="L240" class="LineNr">240 </span> <span class="subxS2Comment"># . . push args</span>
@ -358,7 +358,7 @@ if ('onhashchange' in window) {
<span id="L296" class="LineNr">296 </span> <span class="subxComment"># end</span>
<span id="L297" class="LineNr">297 </span> c3/return
<span id="L298" class="LineNr">298 </span>
<span id="L299" class="LineNr">299 </span><span class="subxTest"><a href='058read.subx.html#L299'>test-read-returns-0-on-end-of-file</a></span>:
<span id="L299" class="LineNr">299 </span><span class="subxTest">test-read-returns-0-on-end-of-file</span>:
<span id="L300" class="LineNr">300 </span> <span class="subxH1Comment"># - read after hitting end-of-file, check that result is 0</span>
<span id="L301" class="LineNr">301 </span> <span class="subxComment"># setup</span>
<span id="L302" class="LineNr">302 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -415,7 +415,7 @@ if ('onhashchange' in window) {
<span id="L353" class="LineNr">353 </span>
<span id="L354" class="LineNr">354 </span>== data
<span id="L355" class="LineNr">355 </span>
<span id="L356" class="LineNr">356 </span><span class="subxMinorFunction"><a href='058read.subx.html#L356'>_test-stream-buffer</a></span>:
<span id="L356" class="LineNr">356 </span><span class="subxMinorFunction">_test-stream-buffer</span>:
<span id="L357" class="LineNr">357 </span> <span class="subxComment"># current write index</span>
<span id="L358" class="LineNr">358 </span> 00 00 00 00
<span id="L359" class="LineNr">359 </span> <span class="subxComment"># current read index</span>

14
html/subx/059read-byte.subx.html
View File

@ -74,7 +74,7 @@ if ('onhashchange' in window) {
<span id="L11" class="LineNr"> 11 </span>
<span id="L12" class="LineNr"> 12 </span><span class="subxComment"># The buffered file for standard input. Also illustrates the layout for</span>
<span id="L13" class="LineNr"> 13 </span><span class="subxComment"># buffered-file.</span>
<span id="L14" class="LineNr"> 14 </span><span class="SpecialChar"><a href='059read-byte.subx.html#L14'>Stdin</a></span>:
<span id="L14" class="LineNr"> 14 </span><span class="SpecialChar">Stdin</span>:
<span id="L15" class="LineNr"> 15 </span> <span class="subxComment"># file descriptor or (address stream)</span>
<span id="L16" class="LineNr"> 16 </span> 00 00 00 00 <span class="subxComment"># 0 = standard input</span>
<span id="L17" class="LineNr"> 17 </span> <span class="subxComment"># current write index</span>
@ -105,7 +105,7 @@ if ('onhashchange' in window) {
<span id="L42" class="LineNr"> 42 </span>
<span id="L43" class="LineNr"> 43 </span><span class="subxComment"># return next byte value in EAX, with top 3 bytes cleared.</span>
<span id="L44" class="LineNr"> 44 </span><span class="subxComment"># On EOF, return 0xffffffff.</span>
<span id="L45" class="LineNr"> 45 </span><span class="subxFunction"><a href='059read-byte.subx.html#L45'>read-byte</a></span>: <span class="subxComment"># f : (address buffered-file) -&gt; byte-or-eof/EAX</span>
<span id="L45" class="LineNr"> 45 </span><span class="subxFunction">read-byte</span>: <span class="subxComment"># f : (address buffered-file) -&gt; byte-or-eof/EAX</span>
<span id="L46" class="LineNr"> 46 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L47" class="LineNr"> 47 </span> 55/push-EBP
<span id="L48" class="LineNr"> 48 </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>
@ -160,7 +160,7 @@ if ('onhashchange' in window) {
<span id="L97" class="LineNr"> 97 </span>
<span id="L98" class="LineNr"> 98 </span><span class="subxH1Comment"># - tests</span>
<span id="L99" class="LineNr"> 99 </span>
<span id="L100" class="LineNr">100 </span><span class="subxTest"><a href='059read-byte.subx.html#L100'>test-read-byte-single</a></span>:
<span id="L100" class="LineNr">100 </span><span class="subxTest">test-read-byte-single</span>:
<span id="L101" class="LineNr">101 </span> <span class="subxH1Comment"># - check that read-byte returns first byte of 'file'</span>
<span id="L102" class="LineNr">102 </span> <span class="subxComment"># setup</span>
<span id="L103" class="LineNr">103 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -206,7 +206,7 @@ if ('onhashchange' in window) {
<span id="L143" class="LineNr">143 </span> <span class="subxS1Comment"># . end</span>
<span id="L144" class="LineNr">144 </span> c3/return
<span id="L145" class="LineNr">145 </span>
<span id="L146" class="LineNr">146 </span><span class="subxTest"><a href='059read-byte.subx.html#L146'>test-read-byte-multiple</a></span>:
<span id="L146" class="LineNr">146 </span><span class="subxTest">test-read-byte-multiple</span>:
<span id="L147" class="LineNr">147 </span> <span class="subxH1Comment"># - call read-byte twice, check that second call returns second byte</span>
<span id="L148" class="LineNr">148 </span> <span class="subxComment"># setup</span>
<span id="L149" class="LineNr">149 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -259,7 +259,7 @@ if ('onhashchange' in window) {
<span id="L196" class="LineNr">196 </span> <span class="subxS1Comment"># . end</span>
<span id="L197" class="LineNr">197 </span> c3/return
<span id="L198" class="LineNr">198 </span>
<span id="L199" class="LineNr">199 </span><span class="subxTest"><a href='059read-byte.subx.html#L199'>test-read-byte-end-of-file</a></span>:
<span id="L199" class="LineNr">199 </span><span class="subxTest">test-read-byte-end-of-file</span>:
<span id="L200" class="LineNr">200 </span> <span class="subxH1Comment"># - call read-byte on an empty 'file', check that it returns 0xffffffff</span>
<span id="L201" class="LineNr">201 </span> <span class="subxComment"># setup</span>
<span id="L202" class="LineNr">202 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -297,7 +297,7 @@ if ('onhashchange' in window) {
<span id="L234" class="LineNr">234 </span> <span class="subxS1Comment"># . end</span>
<span id="L235" class="LineNr">235 </span> c3/return
<span id="L236" class="LineNr">236 </span>
<span id="L237" class="LineNr">237 </span><span class="subxTest"><a href='059read-byte.subx.html#L237'>test-read-byte-refills-buffer</a></span>:
<span id="L237" class="LineNr">237 </span><span class="subxTest">test-read-byte-refills-buffer</span>:
<span id="L238" class="LineNr">238 </span> <span class="subxH1Comment"># - consume buffered-file's buffer, check that next read-byte still works</span>
<span id="L239" class="LineNr">239 </span> <span class="subxComment"># setup</span>
<span id="L240" class="LineNr">240 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -350,7 +350,7 @@ if ('onhashchange' in window) {
<span id="L287" class="LineNr">287 </span>== data
<span id="L288" class="LineNr">288 </span>
<span id="L289" class="LineNr">289 </span><span class="subxComment"># a test buffered file for _test-stream</span>
<span id="L290" class="LineNr">290 </span><span class="subxMinorFunction"><a href='059read-byte.subx.html#L290'>_test-buffered-file</a></span>:
<span id="L290" class="LineNr">290 </span><span class="subxMinorFunction">_test-buffered-file</span>:
<span id="L291" class="LineNr">291 </span> <span class="subxComment"># file descriptor or (address stream)</span>
<span id="L292" class="LineNr">292 </span> <a href='056write.subx.html#L193'>_test-stream</a>/imm32
<span id="L293" class="LineNr">293 </span> <span class="subxComment"># current write index</span>

10
html/subx/060write-stream.subx.html
View File

@ -81,7 +81,7 @@ if ('onhashchange' in window) {
<span id="L19" class="LineNr"> 19 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L20" class="LineNr"> 20 </span> cd/syscall 0x80/imm8
<span id="L21" class="LineNr"> 21 </span>
<span id="L22" class="LineNr"> 22 </span><span class="subxFunction"><a href='060write-stream.subx.html#L22'>write-stream</a></span>: <span class="subxComment"># f : fd or (address stream), s : (address stream) -&gt; &lt;void&gt;</span>
<span id="L22" class="LineNr"> 22 </span><span class="subxFunction">write-stream</span>: <span class="subxComment"># f : fd or (address stream), s : (address stream) -&gt; &lt;void&gt;</span>
<span id="L23" class="LineNr"> 23 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L24" class="LineNr"> 24 </span> 55/push-EBP
<span id="L25" class="LineNr"> 25 </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>
@ -141,7 +141,7 @@ if ('onhashchange' in window) {
<span id="L79" class="LineNr"> 79 </span> 5d/pop-to-EBP
<span id="L80" class="LineNr"> 80 </span> c3/return
<span id="L81" class="LineNr"> 81 </span>
<span id="L82" class="LineNr"> 82 </span><span class="subxMinorFunction"><a href='060write-stream.subx.html#L82'>_write-stream</a></span>: <span class="subxComment"># fd : int, s : (address stream) -&gt; &lt;void&gt;</span>
<span id="L82" class="LineNr"> 82 </span><span class="subxMinorFunction">_write-stream</span>: <span class="subxComment"># fd : int, s : (address stream) -&gt; &lt;void&gt;</span>
<span id="L83" class="LineNr"> 83 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L84" class="LineNr"> 84 </span> 55/push-EBP
<span id="L85" class="LineNr"> 85 </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>
@ -180,7 +180,7 @@ if ('onhashchange' in window) {
<span id="L118" class="LineNr">118 </span> 5d/pop-to-EBP
<span id="L119" class="LineNr">119 </span> c3/return
<span id="L120" class="LineNr">120 </span>
<span id="L121" class="LineNr">121 </span><span class="subxTest"><a href='060write-stream.subx.html#L121'>test-write-stream-single</a></span>:
<span id="L121" class="LineNr">121 </span><span class="subxTest">test-write-stream-single</span>:
<span id="L122" class="LineNr">122 </span> <span class="subxComment"># setup</span>
<span id="L123" class="LineNr">123 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
<span id="L124" class="LineNr">124 </span> <span class="subxS2Comment"># . . push args</span>
@ -226,7 +226,7 @@ if ('onhashchange' in window) {
<span id="L164" class="LineNr">164 </span> <span class="subxS1Comment"># . end</span>
<span id="L165" class="LineNr">165 </span> c3/return
<span id="L166" class="LineNr">166 </span>
<span id="L167" class="LineNr">167 </span><span class="subxTest"><a href='060write-stream.subx.html#L167'>test-write-stream-appends</a></span>:
<span id="L167" class="LineNr">167 </span><span class="subxTest">test-write-stream-appends</span>:
<span id="L168" class="LineNr">168 </span> <span class="subxComment"># setup</span>
<span id="L169" class="LineNr">169 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
<span id="L170" class="LineNr">170 </span> <span class="subxS2Comment"># . . push args</span>
@ -292,7 +292,7 @@ if ('onhashchange' in window) {
<span id="L230" class="LineNr">230 </span>
<span id="L231" class="LineNr">231 </span>== data
<span id="L232" class="LineNr">232 </span>
<span id="L233" class="LineNr">233 </span><span class="subxMinorFunction"><a href='060write-stream.subx.html#L233'>_test-stream2</a></span>:
<span id="L233" class="LineNr">233 </span><span class="subxMinorFunction">_test-stream2</span>:
<span id="L234" class="LineNr">234 </span> <span class="subxComment"># current write index</span>
<span id="L235" class="LineNr">235 </span> 04 00 00 00
<span id="L236" class="LineNr">236 </span> <span class="subxComment"># current read index</span>

2
html/subx/061error.subx.html
View File

@ -72,7 +72,7 @@ if ('onhashchange' in window) {
<span id="L13" class="LineNr">13 </span> cd/syscall 0x80/imm8
<span id="L14" class="LineNr">14 </span>
<span id="L15" class="LineNr">15 </span><span class="subxComment"># write(out, &quot;Error: &quot;+msg+&quot;\n&quot;) then stop(ed, 1)</span>
<span id="L16" class="LineNr">16 </span><span class="subxFunction"><a href='061error.subx.html#L16'>error</a></span>: <span class="subxComment"># ed : (address exit-descriptor), out : fd or (address stream), msg : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L16" class="LineNr">16 </span><span class="subxFunction">error</span>: <span class="subxComment"># ed : (address exit-descriptor), out : fd or (address stream), msg : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L17" class="LineNr">17 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L18" class="LineNr">18 </span> 55/push-EBP
<span id="L19" class="LineNr">19 </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>

8
html/subx/062write-byte.subx.html
View File

@ -68,7 +68,7 @@ if ('onhashchange' in window) {
<span id="L7" class="LineNr"> 7 </span>== data
<span id="L8" class="LineNr"> 8 </span>
<span id="L9" class="LineNr"> 9 </span><span class="subxComment"># The buffered file for standard output.</span>
<span id="L10" class="LineNr"> 10 </span><span class="SpecialChar"><a href='062write-byte.subx.html#L10'>Stdout</a></span>:
<span id="L10" class="LineNr"> 10 </span><span class="SpecialChar">Stdout</span>:
<span id="L11" class="LineNr"> 11 </span> <span class="subxComment"># file descriptor or (address stream)</span>
<span id="L12" class="LineNr"> 12 </span> 01 00 00 00 <span class="subxComment"># 1 = standard output</span>
<span id="L13" class="LineNr"> 13 </span> <span class="subxComment"># current write index</span>
@ -96,7 +96,7 @@ if ('onhashchange' in window) {
<span id="L35" class="LineNr"> 35 </span> cd/syscall 0x80/imm8
<span id="L36" class="LineNr"> 36 </span>
<span id="L37" class="LineNr"> 37 </span><span class="subxComment"># Write lower byte of 'n' to 'f'.</span>
<span id="L38" class="LineNr"> 38 </span><span class="subxFunction"><a href='062write-byte.subx.html#L38'>write-byte</a></span>: <span class="subxComment"># f : (address buffered-file), n : int -&gt; &lt;void&gt;</span>
<span id="L38" class="LineNr"> 38 </span><span class="subxFunction">write-byte</span>: <span class="subxComment"># f : (address buffered-file), n : int -&gt; &lt;void&gt;</span>
<span id="L39" class="LineNr"> 39 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L40" class="LineNr"> 40 </span> 55/push-EBP
<span id="L41" class="LineNr"> 41 </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>
@ -142,7 +142,7 @@ if ('onhashchange' in window) {
<span id="L81" class="LineNr"> 81 </span> 5d/pop-to-EBP
<span id="L82" class="LineNr"> 82 </span> c3/return
<span id="L83" class="LineNr"> 83 </span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction"><a href='062write-byte.subx.html#L84'>flush</a></span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction">flush</span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L85" class="LineNr"> 85 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L86" class="LineNr"> 86 </span> 55/push-EBP
<span id="L87" class="LineNr"> 87 </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>
@ -171,7 +171,7 @@ if ('onhashchange' in window) {
<span id="L110" class="LineNr">110 </span>
<span id="L111" class="LineNr">111 </span><span class="subxH1Comment"># - tests</span>
<span id="L112" class="LineNr">112 </span>
<span id="L113" class="LineNr">113 </span><span class="subxTest"><a href='062write-byte.subx.html#L113'>test-write-byte-single</a></span>:
<span id="L113" class="LineNr">113 </span><span class="subxTest">test-write-byte-single</span>:
<span id="L114" class="LineNr">114 </span> <span class="subxH1Comment"># - check that read-byte returns first byte of 'file'</span>
<span id="L115" class="LineNr">115 </span> <span class="subxComment"># setup</span>
<span id="L116" class="LineNr">116 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>

6
html/subx/063print-byte.subx.html
View File

@ -73,7 +73,7 @@ if ('onhashchange' in window) {
<span id="L12" class="LineNr"> 12 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L13" class="LineNr"> 13 </span> cd/syscall 0x80/imm8
<span id="L14" class="LineNr"> 14 </span>
<span id="L15" class="LineNr"> 15 </span><span class="subxFunction"><a href='063print-byte.subx.html#L15'>print-byte</a></span>: <span class="subxComment"># f : (address buffered-file), n : int -&gt; &lt;void&gt;</span>
<span id="L15" class="LineNr"> 15 </span><span class="subxFunction">print-byte</span>: <span class="subxComment"># f : (address buffered-file), n : int -&gt; &lt;void&gt;</span>
<span id="L16" class="LineNr"> 16 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L17" class="LineNr"> 17 </span> 55/push-EBP
<span id="L18" class="LineNr"> 18 </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>
@ -126,7 +126,7 @@ if ('onhashchange' in window) {
<span id="L65" class="LineNr"> 65 </span>
<span id="L66" class="LineNr"> 66 </span><span class="subxComment"># extract lowest 4 bits and convert to 8-byte ascii</span>
<span id="L67" class="LineNr"> 67 </span><span class="subxComment"># return 0xffffffff if more than 4 bits are set</span>
<span id="L68" class="LineNr"> 68 </span><span class="subxFunction"><a href='063print-byte.subx.html#L68'>hex-char</a></span>: <span class="subxComment"># n : int -&gt; char_or_error/EAX</span>
<span id="L68" class="LineNr"> 68 </span><span class="subxFunction">hex-char</span>: <span class="subxComment"># n : int -&gt; char_or_error/EAX</span>
<span id="L69" class="LineNr"> 69 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L70" class="LineNr"> 70 </span> 55/push-EBP
<span id="L71" class="LineNr"> 71 </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>
@ -152,7 +152,7 @@ if ('onhashchange' in window) {
<span id="L91" class="LineNr"> 91 </span> 5d/pop-to-EBP
<span id="L92" class="LineNr"> 92 </span> c3/return
<span id="L93" class="LineNr"> 93 </span>
<span id="L94" class="LineNr"> 94 </span><span class="subxTest"><a href='063print-byte.subx.html#L94'>test-print-byte</a></span>:
<span id="L94" class="LineNr"> 94 </span><span class="subxTest">test-print-byte</span>:
<span id="L95" class="LineNr"> 95 </span> <span class="subxH1Comment"># - check that print-byte prints the hex textual representation</span>
<span id="L96" class="LineNr"> 96 </span> <span class="subxComment"># setup</span>
<span id="L97" class="LineNr"> 97 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>

6
html/subx/064write-buffered.subx.html
View File

@ -76,7 +76,7 @@ if ('onhashchange' in window) {
<span id="L14" class="LineNr"> 14 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L15" class="LineNr"> 15 </span> cd/syscall 0x80/imm8
<span id="L16" class="LineNr"> 16 </span>
<span id="L17" class="LineNr"> 17 </span><span class="subxFunction"><a href='064write-buffered.subx.html#L17'>write-buffered</a></span>: <span class="subxComment"># f : (address buffered-file), msg : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L17" class="LineNr"> 17 </span><span class="subxFunction">write-buffered</span>: <span class="subxComment"># f : (address buffered-file), msg : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L18" class="LineNr"> 18 </span> <span class="subxComment"># pseudocode:</span>
<span id="L19" class="LineNr"> 19 </span> <span class="subxComment"># in = msg-&gt;data</span>
<span id="L20" class="LineNr"> 20 </span> <span class="subxComment"># inend = &amp;msg-&gt;data[msg-&gt;length]</span>
@ -174,7 +174,7 @@ if ('onhashchange' in window) {
<span id="L112" class="LineNr">112 </span> 5d/pop-to-EBP
<span id="L113" class="LineNr">113 </span> c3/return
<span id="L114" class="LineNr">114 </span>
<span id="L115" class="LineNr">115 </span><span class="subxTest"><a href='064write-buffered.subx.html#L115'>test-write-buffered</a></span>:
<span id="L115" class="LineNr">115 </span><span class="subxTest">test-write-buffered</span>:
<span id="L116" class="LineNr">116 </span> <span class="subxH1Comment"># - check that write-buffered writes to the file</span>
<span id="L117" class="LineNr">117 </span> <span class="subxComment"># setup</span>
<span id="L118" class="LineNr">118 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -222,7 +222,7 @@ if ('onhashchange' in window) {
<span id="L160" class="LineNr">160 </span> <span class="subxS1Comment"># . end</span>
<span id="L161" class="LineNr">161 </span> c3/return
<span id="L162" class="LineNr">162 </span>
<span id="L163" class="LineNr">163 </span><span class="subxTest"><a href='064write-buffered.subx.html#L163'>test-write-buffered-with-intermediate-flush</a></span>:
<span id="L163" class="LineNr">163 </span><span class="subxTest">test-write-buffered-with-intermediate-flush</span>:
<span id="L164" class="LineNr">164 </span> <span class="subxH1Comment"># - check that write-buffered flushes in the middle if its buffer fills up</span>
<span id="L165" class="LineNr">165 </span> <span class="subxComment"># setup</span>
<span id="L166" class="LineNr">166 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>

4
html/subx/065error-byte.subx.html
View File

@ -87,7 +87,7 @@ if ('onhashchange' in window) {
<span id="L27" class="LineNr"> 27 </span> cd/syscall 0x80/imm8
<span id="L28" class="LineNr"> 28 </span>
<span id="L29" class="LineNr"> 29 </span><span class="subxComment"># write(out, &quot;Error: &quot;+msg+&quot;: &quot;+byte) then stop(ed, 1)</span>
<span id="L30" class="LineNr"> 30 </span><span class="subxFunction"><a href='065error-byte.subx.html#L30'>error-byte</a></span>: <span class="subxComment"># ed : (address exit-descriptor), out : (address buffered-file), msg : (address array byte), n : byte -&gt; &lt;void&gt;</span>
<span id="L30" class="LineNr"> 30 </span><span class="subxFunction">error-byte</span>: <span class="subxComment"># ed : (address exit-descriptor), out : (address buffered-file), msg : (address array byte), n : byte -&gt; &lt;void&gt;</span>
<span id="L31" class="LineNr"> 31 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L32" class="LineNr"> 32 </span> 55/push-EBP
<span id="L33" class="LineNr"> 33 </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>
@ -154,7 +154,7 @@ if ('onhashchange' in window) {
<span id="L94" class="LineNr"> 94 </span>== data
<span id="L95" class="LineNr"> 95 </span>
<span id="L96" class="LineNr"> 96 </span><span class="subxComment"># The buffered file for standard error.</span>
<span id="L97" class="LineNr"> 97 </span><span class="SpecialChar"><a href='065error-byte.subx.html#L97'>Stderr</a></span>:
<span id="L97" class="LineNr"> 97 </span><span class="SpecialChar">Stderr</span>:
<span id="L98" class="LineNr"> 98 </span> <span class="subxComment"># file descriptor or (address stream)</span>
<span id="L99" class="LineNr"> 99 </span> 02 00 00 00 <span class="subxComment"># 1 = standard error</span>
<span id="L100" class="LineNr">100 </span> <span class="subxComment"># current write index</span>

8
html/subx/066allocate.subx.html
View File

@ -80,7 +80,7 @@ if ('onhashchange' in window) {
<span id="L20" class="LineNr"> 20 </span>
<span id="L21" class="LineNr"> 21 </span><span class="subxComment"># The 'global' allocation descriptor. Pass this into 'allocate' to claim a</span>
<span id="L22" class="LineNr"> 22 </span><span class="subxComment"># hitherto unused bit of memory.</span>
<span id="L23" class="LineNr"> 23 </span><span class="SpecialChar"><a href='066allocate.subx.html#L23'>Heap</a></span>:
<span id="L23" class="LineNr"> 23 </span><span class="SpecialChar">Heap</span>:
<span id="L24" class="LineNr"> 24 </span> <span class="SpecialChar">Start-of-heap</span>/imm32 <span class="subxComment"># curr</span>
<span id="L25" class="LineNr"> 25 </span> 00 00 00 0b <span class="subxComment"># limit = 0x0b000000; keep sync'd with DATA_SEGMENT + SEGMENT_ALIGNMENT</span>
<span id="L26" class="LineNr"> 26 </span>
@ -98,7 +98,7 @@ if ('onhashchange' in window) {
<span id="L38" class="LineNr"> 38 </span>
<span id="L39" class="LineNr"> 39 </span><span class="subxComment"># Claim the next 'n' bytes of memory starting at ad-&gt;curr and update ad-&gt;curr.</span>
<span id="L40" class="LineNr"> 40 </span><span class="subxComment"># If there isn't enough memory before ad-&gt;limit, return 0 and leave 'ad' unmodified.</span>
<span id="L41" class="LineNr"> 41 </span><span class="subxFunction"><a href='066allocate.subx.html#L41'>allocate</a></span>: <span class="subxComment"># ad : (address allocation-descriptor), n : int -&gt; address-or-null/EAX</span>
<span id="L41" class="LineNr"> 41 </span><span class="subxFunction">allocate</span>: <span class="subxComment"># ad : (address allocation-descriptor), n : int -&gt; address-or-null/EAX</span>
<span id="L42" class="LineNr"> 42 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L43" class="LineNr"> 43 </span> 55/push-EBP
<span id="L44" class="LineNr"> 44 </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>
@ -130,7 +130,7 @@ if ('onhashchange' in window) {
<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="subxTest"><a href='066allocate.subx.html#L73'>test-allocate-success</a></span>:
<span id="L73" class="LineNr"> 73 </span><span class="subxTest">test-allocate-success</span>:
<span id="L74" class="LineNr"> 74 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L75" class="LineNr"> 75 </span> 55/push-EBP
<span id="L76" class="LineNr"> 76 </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>
@ -169,7 +169,7 @@ if ('onhashchange' in window) {
<span id="L109" class="LineNr">109 </span> 5d/pop-to-EBP
<span id="L110" class="LineNr">110 </span> c3/return
<span id="L111" class="LineNr">111 </span>
<span id="L112" class="LineNr">112 </span><span class="subxTest"><a href='066allocate.subx.html#L112'>test-allocate-failure</a></span>:
<span id="L112" class="LineNr">112 </span><span class="subxTest">test-allocate-failure</span>:
<span id="L113" class="LineNr">113 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L114" class="LineNr">114 </span> 55/push-EBP
<span id="L115" class="LineNr">115 </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>

20
html/subx/apps/crenshaw2-1.subx.html
View File

@ -144,7 +144,7 @@ if ('onhashchange' in window) {
<span id="L81" class="LineNr"> 81 </span> cd/syscall 0x80/imm8
<span id="L82" class="LineNr"> 82 </span>
<span id="L83" class="LineNr"> 83 </span><span class="subxComment"># the main entry point</span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction"><a href='crenshaw2-1.subx.html#L84'>compile</a></span>: <span class="subxComment"># in : (address buffered-file), out : fd or (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction">compile</span>: <span class="subxComment"># in : (address buffered-file), out : fd or (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L85" class="LineNr"> 85 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L86" class="LineNr"> 86 </span> 55/push-EBP
<span id="L87" class="LineNr"> 87 </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>
@ -260,7 +260,7 @@ if ('onhashchange' in window) {
<span id="L197" class="LineNr">197 </span><span class="subxComment"># Read a single digit into 'out'. Abort if there are none, or if there is no space in 'out'.</span>
<span id="L198" class="LineNr">198 </span><span class="subxComment"># Input comes from the global variable 'Look', and we leave the next byte from</span>
<span id="L199" class="LineNr">199 </span><span class="subxComment"># 'in' into it on exit.</span>
<span id="L200" class="LineNr">200 </span><span class="subxFunction"><a href='crenshaw2-1.subx.html#L200'>get-num</a></span>: <span class="subxComment"># in : (address buffered-file), out : (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L200" class="LineNr">200 </span><span class="subxFunction">get-num</span>: <span class="subxComment"># in : (address buffered-file), out : (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L201" class="LineNr">201 </span> <span class="subxComment"># pseudocode:</span>
<span id="L202" class="LineNr">202 </span> <span class="subxComment"># if !is-digit?(Look) expected(ed, err, &quot;integer&quot;)</span>
<span id="L203" class="LineNr">203 </span> <span class="subxComment"># if out-&gt;write &gt;= out-&gt;length</span>
@ -364,7 +364,7 @@ if ('onhashchange' in window) {
<span id="L301" class="LineNr">301 </span> 5d/pop-to-EBP
<span id="L302" class="LineNr">302 </span> c3/return
<span id="L303" class="LineNr">303 </span>
<span id="L304" class="LineNr">304 </span><span class="subxTest"><a href='crenshaw2-1.subx.html#L304'>test-get-num-reads-single-digit</a></span>:
<span id="L304" class="LineNr">304 </span><span class="subxTest">test-get-num-reads-single-digit</span>:
<span id="L305" class="LineNr">305 </span> <span class="subxH1Comment"># - check that get-num returns first character if it's a digit</span>
<span id="L306" class="LineNr">306 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L307" class="LineNr">307 </span> 55/push-EBP
@ -455,7 +455,7 @@ if ('onhashchange' in window) {
<span id="L392" class="LineNr">392 </span> 5d/pop-to-EBP
<span id="L393" class="LineNr">393 </span> c3/return
<span id="L394" class="LineNr">394 </span>
<span id="L395" class="LineNr">395 </span><span class="subxTest"><a href='crenshaw2-1.subx.html#L395'>test-get-num-aborts-on-non-digit-in-Look</a></span>:
<span id="L395" class="LineNr">395 </span><span class="subxTest">test-get-num-aborts-on-non-digit-in-Look</span>:
<span id="L396" class="LineNr">396 </span> <span class="subxH1Comment"># - check that get-num returns first character if it's a digit</span>
<span id="L397" class="LineNr">397 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L398" class="LineNr">398 </span> 55/push-EBP
@ -543,7 +543,7 @@ if ('onhashchange' in window) {
<span id="L480" class="LineNr">480 </span><span class="subxComment">## helpers</span>
<span id="L481" class="LineNr">481 </span>
<span id="L482" class="LineNr">482 </span><span class="subxComment"># write(f, &quot;Error: &quot;+s+&quot; expected\n&quot;) then stop(ed, 1)</span>
<span id="L483" class="LineNr">483 </span><span class="subxFunction"><a href='crenshaw2-1.subx.html#L483'>expected</a></span>: <span class="subxComment"># ed : (address exit-descriptor), f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L483" class="LineNr">483 </span><span class="subxFunction">expected</span>: <span class="subxComment"># ed : (address exit-descriptor), f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L484" class="LineNr">484 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L485" class="LineNr">485 </span> 55/push-EBP
<span id="L486" class="LineNr">486 </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>
@ -593,7 +593,7 @@ if ('onhashchange' in window) {
<span id="L530" class="LineNr">530 </span> c3/return
<span id="L531" class="LineNr">531 </span>
<span id="L532" class="LineNr">532 </span><span class="subxComment"># read a byte from 'f', and save it in 'Look'</span>
<span id="L533" class="LineNr">533 </span><span class="subxFunction"><a href='crenshaw2-1.subx.html#L533'>get-char</a></span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L533" class="LineNr">533 </span><span class="subxFunction">get-char</span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L534" class="LineNr">534 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L535" class="LineNr">535 </span> 55/push-EBP
<span id="L536" class="LineNr">536 </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>
@ -616,7 +616,7 @@ if ('onhashchange' in window) {
<span id="L553" class="LineNr">553 </span> 5d/pop-to-EBP
<span id="L554" class="LineNr">554 </span> c3/return
<span id="L555" class="LineNr">555 </span>
<span id="L556" class="LineNr">556 </span><span class="subxFunction"><a href='crenshaw2-1.subx.html#L556'>is-digit?</a></span>: <span class="subxComment"># c : int -&gt; bool/EAX</span>
<span id="L556" class="LineNr">556 </span><span class="subxFunction">is-digit?</span>: <span class="subxComment"># c : int -&gt; bool/EAX</span>
<span id="L557" class="LineNr">557 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L558" class="LineNr">558 </span> 55/push-EBP
<span id="L559" class="LineNr">559 </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>
@ -638,10 +638,10 @@ if ('onhashchange' in window) {
<span id="L575" class="LineNr">575 </span>
<span id="L576" class="LineNr">576 </span>== data
<span id="L577" class="LineNr">577 </span>
<span id="L578" class="LineNr">578 </span><span class="SpecialChar"><a href='crenshaw2-1.subx.html#L578'>Look</a></span>: <span class="subxComment"># (char)</span>
<span id="L578" class="LineNr">578 </span><span class="SpecialChar">Look</span>: <span class="subxComment"># (char)</span>
<span id="L579" class="LineNr">579 </span> 00 00 00 00 <span class="subxComment"># = 0</span>
<span id="L580" class="LineNr">580 </span>
<span id="L581" class="LineNr">581 </span><span class="subxMinorFunction"><a href='crenshaw2-1.subx.html#L581'>_test-output-stream</a></span>:
<span id="L581" class="LineNr">581 </span><span class="subxMinorFunction">_test-output-stream</span>:
<span id="L582" class="LineNr">582 </span> <span class="subxComment"># current write index</span>
<span id="L583" class="LineNr">583 </span> 00 00 00 00
<span id="L584" class="LineNr">584 </span> <span class="subxComment"># current read index</span>
@ -651,7 +651,7 @@ if ('onhashchange' in window) {
<span id="L588" class="LineNr">588 </span> <span class="subxComment"># data</span>
<span id="L589" class="LineNr">589 </span> 00 00 00 00 00 00 00 00 <span class="subxComment"># 8 bytes</span>
<span id="L590" class="LineNr">590 </span>
<span id="L591" class="LineNr">591 </span><span class="subxMinorFunction"><a href='crenshaw2-1.subx.html#L591'>_test-error-stream</a></span>:
<span id="L591" class="LineNr">591 </span><span class="subxMinorFunction">_test-error-stream</span>:
<span id="L592" class="LineNr">592 </span> <span class="subxComment"># current write index</span>
<span id="L593" class="LineNr">593 </span> 00 00 00 00
<span id="L594" class="LineNr">594 </span> <span class="subxComment"># current read index</span>

24
html/subx/apps/crenshaw2-1b.subx.html
View File

@ -144,7 +144,7 @@ if ('onhashchange' in window) {
<span id="L81" class="LineNr"> 81 </span> cd/syscall 0x80/imm8
<span id="L82" class="LineNr"> 82 </span>
<span id="L83" class="LineNr"> 83 </span><span class="subxComment"># the main entry point</span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction"><a href='crenshaw2-1b.subx.html#L84'>compile</a></span>: <span class="subxComment"># in : (address buffered-file), out : fd or (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L84" class="LineNr"> 84 </span><span class="subxFunction">compile</span>: <span class="subxComment"># in : (address buffered-file), out : fd or (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L85" class="LineNr"> 85 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L86" class="LineNr"> 86 </span> 55/push-EBP
<span id="L87" class="LineNr"> 87 </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>
@ -261,7 +261,7 @@ if ('onhashchange' in window) {
<span id="L198" class="LineNr">198 </span><span class="subxComment"># no space in 'out'.</span>
<span id="L199" class="LineNr">199 </span><span class="subxComment"># Input comes from the global variable 'Look' (first byte) and the argument</span>
<span id="L200" class="LineNr">200 </span><span class="subxComment"># 'in' (rest). We leave the next byte from 'in' into 'Look' on exit.</span>
<span id="L201" class="LineNr">201 </span><span class="subxFunction"><a href='crenshaw2-1b.subx.html#L201'>get-num</a></span>: <span class="subxComment"># in : (address buffered-file), out : (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L201" class="LineNr">201 </span><span class="subxFunction">get-num</span>: <span class="subxComment"># in : (address buffered-file), out : (address stream), err : fd or (address stream), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L202" class="LineNr">202 </span> <span class="subxComment"># pseudocode:</span>
<span id="L203" class="LineNr">203 </span> <span class="subxComment"># if !is-digit?(Look) expected(ed, err, &quot;integer&quot;)</span>
<span id="L204" class="LineNr">204 </span> <span class="subxComment"># do</span>
@ -381,7 +381,7 @@ if ('onhashchange' in window) {
<span id="L318" class="LineNr">318 </span> 5d/pop-to-EBP
<span id="L319" class="LineNr">319 </span> c3/return
<span id="L320" class="LineNr">320 </span>
<span id="L321" class="LineNr">321 </span><span class="subxTest"><a href='crenshaw2-1b.subx.html#L321'>test-get-num-reads-single-digit</a></span>:
<span id="L321" class="LineNr">321 </span><span class="subxTest">test-get-num-reads-single-digit</span>:
<span id="L322" class="LineNr">322 </span> <span class="subxH1Comment"># - check that get-num returns first character if it's a digit</span>
<span id="L323" class="LineNr">323 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L324" class="LineNr">324 </span> 55/push-EBP
@ -472,7 +472,7 @@ if ('onhashchange' in window) {
<span id="L409" class="LineNr">409 </span> 5d/pop-to-EBP
<span id="L410" class="LineNr">410 </span> c3/return
<span id="L411" class="LineNr">411 </span>
<span id="L412" class="LineNr">412 </span><span class="subxTest"><a href='crenshaw2-1b.subx.html#L412'>test-get-num-aborts-on-non-digit-in-Look</a></span>:
<span id="L412" class="LineNr">412 </span><span class="subxTest">test-get-num-aborts-on-non-digit-in-Look</span>:
<span id="L413" class="LineNr">413 </span> <span class="subxH1Comment"># - check that get-num returns first character if it's a digit</span>
<span id="L414" class="LineNr">414 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L415" class="LineNr">415 </span> 55/push-EBP
@ -557,7 +557,7 @@ if ('onhashchange' in window) {
<span id="L494" class="LineNr">494 </span> 5d/pop-to-EBP
<span id="L495" class="LineNr">495 </span> c3/return
<span id="L496" class="LineNr">496 </span>
<span id="L497" class="LineNr">497 </span><span class="subxTest"><a href='crenshaw2-1b.subx.html#L497'>test-get-num-reads-multiple-digits</a></span>:
<span id="L497" class="LineNr">497 </span><span class="subxTest">test-get-num-reads-multiple-digits</span>:
<span id="L498" class="LineNr">498 </span> <span class="subxH1Comment"># - check that get-num returns all initial digits until it encounters a non-digit</span>
<span id="L499" class="LineNr">499 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L500" class="LineNr">500 </span> 55/push-EBP
@ -648,7 +648,7 @@ if ('onhashchange' in window) {
<span id="L585" class="LineNr">585 </span> 5d/pop-to-EBP
<span id="L586" class="LineNr">586 </span> c3/return
<span id="L587" class="LineNr">587 </span>
<span id="L588" class="LineNr">588 </span><span class="subxTest"><a href='crenshaw2-1b.subx.html#L588'>test-get-num-reads-multiple-digits-followed-by-nondigit</a></span>:
<span id="L588" class="LineNr">588 </span><span class="subxTest">test-get-num-reads-multiple-digits-followed-by-nondigit</span>:
<span id="L589" class="LineNr">589 </span> <span class="subxH1Comment"># - check that get-num returns all initial digits until it encounters a non-digit</span>
<span id="L590" class="LineNr">590 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L591" class="LineNr">591 </span> 55/push-EBP
@ -742,7 +742,7 @@ if ('onhashchange' in window) {
<span id="L679" class="LineNr">679 </span><span class="subxComment">## helpers</span>
<span id="L680" class="LineNr">680 </span>
<span id="L681" class="LineNr">681 </span><span class="subxComment"># write(f, &quot;Error: &quot;+s+&quot; expected\n&quot;) then stop(ed, 1)</span>
<span id="L682" class="LineNr">682 </span><span class="subxFunction"><a href='crenshaw2-1b.subx.html#L682'>expected</a></span>: <span class="subxComment"># ed : (address exit-descriptor), f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L682" class="LineNr">682 </span><span class="subxFunction">expected</span>: <span class="subxComment"># ed : (address exit-descriptor), f : fd or (address stream), s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L683" class="LineNr">683 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L684" class="LineNr">684 </span> 55/push-EBP
<span id="L685" class="LineNr">685 </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>
@ -791,7 +791,7 @@ if ('onhashchange' in window) {
<span id="L728" class="LineNr">728 </span> c3/return
<span id="L729" class="LineNr">729 </span>
<span id="L730" class="LineNr">730 </span><span class="subxComment"># read a byte from 'f', and save it in 'Look'</span>
<span id="L731" class="LineNr">731 </span><span class="subxFunction"><a href='crenshaw2-1b.subx.html#L731'>get-char</a></span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L731" class="LineNr">731 </span><span class="subxFunction">get-char</span>: <span class="subxComment"># f : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L732" class="LineNr">732 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L733" class="LineNr">733 </span> 55/push-EBP
<span id="L734" class="LineNr">734 </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>
@ -813,7 +813,7 @@ if ('onhashchange' in window) {
<span id="L750" class="LineNr">750 </span> 5d/pop-to-EBP
<span id="L751" class="LineNr">751 </span> c3/return
<span id="L752" class="LineNr">752 </span>
<span id="L753" class="LineNr">753 </span><span class="subxFunction"><a href='crenshaw2-1b.subx.html#L753'>is-digit?</a></span>: <span class="subxComment"># c : int -&gt; bool/EAX</span>
<span id="L753" class="LineNr">753 </span><span class="subxFunction">is-digit?</span>: <span class="subxComment"># c : int -&gt; bool/EAX</span>
<span id="L754" class="LineNr">754 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L755" class="LineNr">755 </span> 55/push-EBP
<span id="L756" class="LineNr">756 </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>
@ -835,10 +835,10 @@ if ('onhashchange' in window) {
<span id="L772" class="LineNr">772 </span>
<span id="L773" class="LineNr">773 </span>== data
<span id="L774" class="LineNr">774 </span>
<span id="L775" class="LineNr">775 </span><span class="SpecialChar"><a href='crenshaw2-1b.subx.html#L775'>Look</a></span>: <span class="subxComment"># (char)</span>
<span id="L775" class="LineNr">775 </span><span class="SpecialChar">Look</span>: <span class="subxComment"># (char)</span>
<span id="L776" class="LineNr">776 </span> 00 00 00 00 <span class="subxComment"># = 0</span>
<span id="L777" class="LineNr">777 </span>
<span id="L778" class="LineNr">778 </span><span class="subxMinorFunction"><a href='crenshaw2-1b.subx.html#L778'>_test-output-stream</a></span>:
<span id="L778" class="LineNr">778 </span><span class="subxMinorFunction">_test-output-stream</span>:
<span id="L779" class="LineNr">779 </span> <span class="subxComment"># current write index</span>
<span id="L780" class="LineNr">780 </span> 00 00 00 00
<span id="L781" class="LineNr">781 </span> <span class="subxComment"># current read index</span>
@ -848,7 +848,7 @@ if ('onhashchange' in window) {
<span id="L785" class="LineNr">785 </span> <span class="subxComment"># data</span>
<span id="L786" class="LineNr">786 </span> 00 00 00 00 00 00 00 00 <span class="subxComment"># 8 bytes</span>
<span id="L787" class="LineNr">787 </span>
<span id="L788" class="LineNr">788 </span><span class="subxMinorFunction"><a href='crenshaw2-1b.subx.html#L788'>_test-error-stream</a></span>:
<span id="L788" class="LineNr">788 </span><span class="subxMinorFunction">_test-error-stream</span>:
<span id="L789" class="LineNr">789 </span> <span class="subxComment"># current write index</span>
<span id="L790" class="LineNr">790 </span> 00 00 00 00
<span id="L791" class="LineNr">791 </span> <span class="subxComment"># current read index</span>

4
html/subx/apps/factorial.subx.html
View File

@ -116,7 +116,7 @@ if ('onhashchange' in window) {
<span id="L55" class="LineNr"> 55 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L56" class="LineNr"> 56 </span> cd/syscall 0x80/imm8
<span id="L57" class="LineNr"> 57 </span>
<span id="L58" class="LineNr"> 58 </span><span class="subxFunction"><a href='factorial.subx.html#L58'>factorial</a></span>: <span class="subxComment"># n : int -&gt; int/EAX</span>
<span id="L58" class="LineNr"> 58 </span><span class="subxFunction">factorial</span>: <span class="subxComment"># n : int -&gt; int/EAX</span>
<span id="L59" class="LineNr"> 59 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L60" class="LineNr"> 60 </span> 55/push-EBP
<span id="L61" class="LineNr"> 61 </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>
@ -146,7 +146,7 @@ if ('onhashchange' in window) {
<span id="L85" class="LineNr"> 85 </span> 5d/pop-to-EBP
<span id="L86" class="LineNr"> 86 </span> c3/return
<span id="L87" class="LineNr"> 87 </span>
<span id="L88" class="LineNr"> 88 </span><span class="subxTest"><a href='factorial.subx.html#L88'>test-factorial</a></span>:
<span id="L88" class="LineNr"> 88 </span><span class="subxTest">test-factorial</span>:
<span id="L89" class="LineNr"> 89 </span> <span class="subxComment"># factorial(5)</span>
<span id="L90" class="LineNr"> 90 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L91" class="LineNr"> 91 </span> 68/push 5/imm32

14
html/subx/apps/handle.subx.html
View File

@ -91,7 +91,7 @@ if ('onhashchange' in window) {
<span id="L30" class="LineNr"> 30 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L31" class="LineNr"> 31 </span> cd/syscall 0x80/imm8
<span id="L32" class="LineNr"> 32 </span>
<span id="L33" class="LineNr"> 33 </span><span class="subxFunction"><a href='handle.subx.html#L33'>new</a></span>: <span class="subxComment"># ad : (address allocation-descriptor), n : int, out : (address handle)</span>
<span id="L33" class="LineNr"> 33 </span><span class="subxFunction">new</span>: <span class="subxComment"># ad : (address allocation-descriptor), n : int, out : (address handle)</span>
<span id="L34" class="LineNr"> 34 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L35" class="LineNr"> 35 </span> 55/push-EBP
<span id="L36" class="LineNr"> 36 </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>
@ -139,7 +139,7 @@ if ('onhashchange' in window) {
<span id="L78" class="LineNr"> 78 </span> 5d/pop-to-EBP
<span id="L79" class="LineNr"> 79 </span> c3/return
<span id="L80" class="LineNr"> 80 </span>
<span id="L81" class="LineNr"> 81 </span><span class="subxTest"><a href='handle.subx.html#L81'>test-new</a></span>: <span class="subxH1Comment"># - this test uses the bottom of the stack segment as scratch space</span>
<span id="L81" class="LineNr"> 81 </span><span class="subxTest">test-new</span>: <span class="subxH1Comment"># - this test uses the bottom of the stack segment as scratch space</span>
<span id="L82" class="LineNr"> 82 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L83" class="LineNr"> 83 </span> 55/push-EBP
<span id="L84" class="LineNr"> 84 </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>
@ -207,7 +207,7 @@ if ('onhashchange' in window) {
<span id="L146" class="LineNr">146 </span> 5d/pop-to-EBP
<span id="L147" class="LineNr">147 </span> c3/return
<span id="L148" class="LineNr">148 </span>
<span id="L149" class="LineNr">149 </span><span class="subxTest"><a href='handle.subx.html#L149'>test-new-failure</a></span>:
<span id="L149" class="LineNr">149 </span><span class="subxTest">test-new-failure</span>:
<span id="L150" class="LineNr">150 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L151" class="LineNr">151 </span> 55/push-EBP
<span id="L152" class="LineNr">152 </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>
@ -269,7 +269,7 @@ if ('onhashchange' in window) {
<span id="L208" class="LineNr">208 </span> 5d/pop-to-EBP
<span id="L209" class="LineNr">209 </span> c3/return
<span id="L210" class="LineNr">210 </span>
<span id="L211" class="LineNr">211 </span><span class="subxFunction"><a href='handle.subx.html#L211'>lookup</a></span>: <span class="subxComment"># h : (handle T) -&gt; EAX : (address T)</span>
<span id="L211" class="LineNr">211 </span><span class="subxFunction">lookup</span>: <span class="subxComment"># h : (handle T) -&gt; EAX : (address T)</span>
<span id="L212" class="LineNr">212 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L213" class="LineNr">213 </span> 55/push-EBP
<span id="L214" class="LineNr">214 </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>
@ -311,7 +311,7 @@ if ('onhashchange' in window) {
<span id="L250" class="LineNr">250 </span> 5d/pop-to-EBP
<span id="L251" class="LineNr">251 </span> c3/return
<span id="L252" class="LineNr">252 </span>
<span id="L253" class="LineNr">253 </span><span class="subxTest"><a href='handle.subx.html#L253'>test-lookup-success</a></span>:
<span id="L253" class="LineNr">253 </span><span class="subxTest">test-lookup-success</span>:
<span id="L254" class="LineNr">254 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L255" class="LineNr">255 </span> 55/push-EBP
<span id="L256" class="LineNr">256 </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>
@ -361,7 +361,7 @@ if ('onhashchange' in window) {
<span id="L300" class="LineNr">300 </span> 5d/pop-to-EBP
<span id="L301" class="LineNr">301 </span> c3/return
<span id="L302" class="LineNr">302 </span>
<span id="L303" class="LineNr">303 </span><span class="subxTest"><a href='handle.subx.html#L303'>test-lookup-failure</a></span>:
<span id="L303" class="LineNr">303 </span><span class="subxTest">test-lookup-failure</span>:
<span id="L304" class="LineNr">304 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L305" class="LineNr">305 </span> 55/push-EBP
<span id="L306" class="LineNr">306 </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>
@ -426,7 +426,7 @@ if ('onhashchange' in window) {
<span id="L365" class="LineNr">365 </span>== data
<span id="L366" class="LineNr">366 </span>
<span id="L367" class="LineNr">367 </span><span class="subxComment"># Monotonically increasing counter for calls to 'new'</span>
<span id="L368" class="LineNr">368 </span><span class="SpecialChar"><a href='handle.subx.html#L368'>Next-alloc-id</a></span>:
<span id="L368" class="LineNr">368 </span><span class="SpecialChar">Next-alloc-id</span>:
<span id="L369" class="LineNr">369 </span> 01 00 00 00 <span class="subxComment"># 1</span>
<span id="L370" class="LineNr">370 </span>
<span id="L371" class="LineNr">371 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

50
html/subx/apps/hex.subx.html
View File

@ -138,7 +138,7 @@ if ('onhashchange' in window) {
<span id="L75" class="LineNr"> 75 </span> cd/syscall 0x80/imm8
<span id="L76" class="LineNr"> 76 </span>
<span id="L77" class="LineNr"> 77 </span><span class="subxComment"># the main entry point</span>
<span id="L78" class="LineNr"> 78 </span><span class="subxFunction"><a href='hex.subx.html#L78'>convert</a></span>: <span class="subxComment"># in : (address buffered-file), out : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L78" class="LineNr"> 78 </span><span class="subxFunction">convert</span>: <span class="subxComment"># in : (address buffered-file), out : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; &lt;void&gt;</span>
<span id="L79" class="LineNr"> 79 </span> <span class="subxComment"># pseudocode:</span>
<span id="L80" class="LineNr"> 80 </span> <span class="subxComment"># repeatedly</span>
<span id="L81" class="LineNr"> 81 </span> <span class="subxComment"># EAX = convert-next-octet(in, err, ed)</span>
@ -196,7 +196,7 @@ if ('onhashchange' in window) {
<span id="L133" class="LineNr"> 133 </span><span class="subxComment"># raise an error and abort on all other unexpected bytes</span>
<span id="L134" class="LineNr"> 134 </span><span class="subxComment"># return in EAX an _octet_ containing the binary value of the two hex characters</span>
<span id="L135" class="LineNr"> 135 </span><span class="subxComment"># return 0xffffffff on end of file</span>
<span id="L136" class="LineNr"> 136 </span><span class="subxFunction"><a href='hex.subx.html#L136'>convert-next-octet</a></span>: <span class="subxComment"># in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; byte-or-eof/EAX</span>
<span id="L136" class="LineNr"> 136 </span><span class="subxFunction">convert-next-octet</span>: <span class="subxComment"># in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; byte-or-eof/EAX</span>
<span id="L137" class="LineNr"> 137 </span> <span class="subxComment"># pseudocode:</span>
<span id="L138" class="LineNr"> 138 </span> <span class="subxComment"># EAX = scan-next-byte(in, err, ed)</span>
<span id="L139" class="LineNr"> 139 </span> <span class="subxComment"># if (EAX == 0xffffffff) return</span>
@ -264,7 +264,7 @@ if ('onhashchange' in window) {
<span id="L201" class="LineNr"> 201 </span> 5d/pop-to-EBP
<span id="L202" class="LineNr"> 202 </span> c3/return
<span id="L203" class="LineNr"> 203 </span>
<span id="L204" class="LineNr"> 204 </span><span class="subxTest"><a href='hex.subx.html#L204'>test-convert-next-octet</a></span>:
<span id="L204" class="LineNr"> 204 </span><span class="subxTest">test-convert-next-octet</span>:
<span id="L205" class="LineNr"> 205 </span> <span class="subxH1Comment"># - check that the first two bytes of the input are assembled into the resulting octet</span>
<span id="L206" class="LineNr"> 206 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L207" class="LineNr"> 207 </span> 55/push-EBP
@ -366,7 +366,7 @@ if ('onhashchange' in window) {
<span id="L303" class="LineNr"> 303 </span> 5d/pop-to-EBP
<span id="L304" class="LineNr"> 304 </span> c3/return
<span id="L305" class="LineNr"> 305 </span>
<span id="L306" class="LineNr"> 306 </span><span class="subxTest"><a href='hex.subx.html#L306'>test-convert-next-octet-handles-eof</a></span>:
<span id="L306" class="LineNr"> 306 </span><span class="subxTest">test-convert-next-octet-handles-eof</span>:
<span id="L307" class="LineNr"> 307 </span> <span class="subxH1Comment"># - check that eof returns the sentinel octet</span>
<span id="L308" class="LineNr"> 308 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L309" class="LineNr"> 309 </span> 55/push-EBP
@ -460,7 +460,7 @@ if ('onhashchange' in window) {
<span id="L397" class="LineNr"> 397 </span> 5d/pop-to-EBP
<span id="L398" class="LineNr"> 398 </span> c3/return
<span id="L399" class="LineNr"> 399 </span>
<span id="L400" class="LineNr"> 400 </span><span class="subxTest"><a href='hex.subx.html#L400'>test-convert-next-octet-aborts-on-single-hex-byte</a></span>:
<span id="L400" class="LineNr"> 400 </span><span class="subxTest">test-convert-next-octet-aborts-on-single-hex-byte</span>:
<span id="L401" class="LineNr"> 401 </span> <span class="subxH1Comment"># - check that a single unaccompanied hex byte aborts</span>
<span id="L402" class="LineNr"> 402 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L403" class="LineNr"> 403 </span> 55/push-EBP
@ -554,7 +554,7 @@ if ('onhashchange' in window) {
<span id="L491" class="LineNr"> 491 </span><span class="subxComment"># return 0xffffffff if file ends without finding a hex byte</span>
<span id="L492" class="LineNr"> 492 </span><span class="subxComment"># on '#' skip all bytes until newline</span>
<span id="L493" class="LineNr"> 493 </span><span class="subxComment"># abort on any other byte</span>
<span id="L494" class="LineNr"> 494 </span><span class="subxFunction"><a href='hex.subx.html#L494'>scan-next-byte</a></span>: <span class="subxComment"># in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; byte-or-eof/EAX</span>
<span id="L494" class="LineNr"> 494 </span><span class="subxFunction">scan-next-byte</span>: <span class="subxComment"># in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -&gt; byte-or-eof/EAX</span>
<span id="L495" class="LineNr"> 495 </span> <span class="subxComment"># pseudocode:</span>
<span id="L496" class="LineNr"> 496 </span> <span class="subxComment"># repeatedly</span>
<span id="L497" class="LineNr"> 497 </span> <span class="subxComment"># EAX = read-byte(in)</span>
@ -633,7 +633,7 @@ if ('onhashchange' in window) {
<span id="L570" class="LineNr"> 570 </span> 5d/pop-to-EBP
<span id="L571" class="LineNr"> 571 </span> c3/return
<span id="L572" class="LineNr"> 572 </span>
<span id="L573" class="LineNr"> 573 </span><span class="subxTest"><a href='hex.subx.html#L573'>test-scan-next-byte</a></span>:
<span id="L573" class="LineNr"> 573 </span><span class="subxTest">test-scan-next-byte</span>:
<span id="L574" class="LineNr"> 574 </span> <span class="subxH1Comment"># - check that the first byte of the input is returned</span>
<span id="L575" class="LineNr"> 575 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L576" class="LineNr"> 576 </span> 55/push-EBP
@ -735,7 +735,7 @@ if ('onhashchange' in window) {
<span id="L672" class="LineNr"> 672 </span> 5d/pop-to-EBP
<span id="L673" class="LineNr"> 673 </span> c3/return
<span id="L674" class="LineNr"> 674 </span>
<span id="L675" class="LineNr"> 675 </span><span class="subxTest"><a href='hex.subx.html#L675'>test-scan-next-byte-skips-whitespace</a></span>:
<span id="L675" class="LineNr"> 675 </span><span class="subxTest">test-scan-next-byte-skips-whitespace</span>:
<span id="L676" class="LineNr"> 676 </span> <span class="subxH1Comment"># - check that the first byte after whitespace is returned</span>
<span id="L677" class="LineNr"> 677 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L678" class="LineNr"> 678 </span> 55/push-EBP
@ -837,7 +837,7 @@ if ('onhashchange' in window) {
<span id="L774" class="LineNr"> 774 </span> 5d/pop-to-EBP
<span id="L775" class="LineNr"> 775 </span> c3/return
<span id="L776" class="LineNr"> 776 </span>
<span id="L777" class="LineNr"> 777 </span><span class="subxTest"><a href='hex.subx.html#L777'>test-scan-next-byte-skips-comment</a></span>:
<span id="L777" class="LineNr"> 777 </span><span class="subxTest">test-scan-next-byte-skips-comment</span>:
<span id="L778" class="LineNr"> 778 </span> <span class="subxH1Comment"># - check that the first byte after a comment (and newline) is returned</span>
<span id="L779" class="LineNr"> 779 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L780" class="LineNr"> 780 </span> 55/push-EBP
@ -955,7 +955,7 @@ if ('onhashchange' in window) {
<span id="L892" class="LineNr"> 892 </span> 5d/pop-to-EBP
<span id="L893" class="LineNr"> 893 </span> c3/return
<span id="L894" class="LineNr"> 894 </span>
<span id="L895" class="LineNr"> 895 </span><span class="subxTest"><a href='hex.subx.html#L895'>test-scan-next-byte-skips-comment-and-whitespace</a></span>:
<span id="L895" class="LineNr"> 895 </span><span class="subxTest">test-scan-next-byte-skips-comment-and-whitespace</span>:
<span id="L896" class="LineNr"> 896 </span> <span class="subxH1Comment"># - check that the first byte after a comment and any further whitespace is returned</span>
<span id="L897" class="LineNr"> 897 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L898" class="LineNr"> 898 </span> 55/push-EBP
@ -1073,7 +1073,7 @@ if ('onhashchange' in window) {
<span id="L1010" class="LineNr">1010 </span> 5d/pop-to-EBP
<span id="L1011" class="LineNr">1011 </span> c3/return
<span id="L1012" class="LineNr">1012 </span>
<span id="L1013" class="LineNr">1013 </span><span class="subxTest"><a href='hex.subx.html#L1013'>test-scan-next-byte-skips-whitespace-and-comment</a></span>:
<span id="L1013" class="LineNr">1013 </span><span class="subxTest">test-scan-next-byte-skips-whitespace-and-comment</span>:
<span id="L1014" class="LineNr">1014 </span> <span class="subxH1Comment"># - check that the first byte after any whitespace and comments is returned</span>
<span id="L1015" class="LineNr">1015 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L1016" class="LineNr">1016 </span> 55/push-EBP
@ -1191,7 +1191,7 @@ if ('onhashchange' in window) {
<span id="L1128" class="LineNr">1128 </span> 5d/pop-to-EBP
<span id="L1129" class="LineNr">1129 </span> c3/return
<span id="L1130" class="LineNr">1130 </span>
<span id="L1131" class="LineNr">1131 </span><span class="subxTest"><a href='hex.subx.html#L1131'>test-scan-next-byte-reads-final-byte</a></span>:
<span id="L1131" class="LineNr">1131 </span><span class="subxTest">test-scan-next-byte-reads-final-byte</span>:
<span id="L1132" class="LineNr">1132 </span> <span class="subxH1Comment"># - check that the final byte in input is returned</span>
<span id="L1133" class="LineNr">1133 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L1134" class="LineNr">1134 </span> 55/push-EBP
@ -1293,7 +1293,7 @@ if ('onhashchange' in window) {
<span id="L1230" class="LineNr">1230 </span> 5d/pop-to-EBP
<span id="L1231" class="LineNr">1231 </span> c3/return
<span id="L1232" class="LineNr">1232 </span>
<span id="L1233" class="LineNr">1233 </span><span class="subxTest"><a href='hex.subx.html#L1233'>test-scan-next-byte-handles-eof</a></span>:
<span id="L1233" class="LineNr">1233 </span><span class="subxTest">test-scan-next-byte-handles-eof</span>:
<span id="L1234" class="LineNr">1234 </span> <span class="subxH1Comment"># - check that the right sentinel value is returned when there's no data remaining to be read</span>
<span id="L1235" class="LineNr">1235 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L1236" class="LineNr">1236 </span> 55/push-EBP
@ -1387,7 +1387,7 @@ if ('onhashchange' in window) {
<span id="L1324" class="LineNr">1324 </span> 5d/pop-to-EBP
<span id="L1325" class="LineNr">1325 </span> c3/return
<span id="L1326" class="LineNr">1326 </span>
<span id="L1327" class="LineNr">1327 </span><span class="subxTest"><a href='hex.subx.html#L1327'>test-scan-next-byte-aborts-on-invalid-byte</a></span>:
<span id="L1327" class="LineNr">1327 </span><span class="subxTest">test-scan-next-byte-aborts-on-invalid-byte</span>:
<span id="L1328" class="LineNr">1328 </span> <span class="subxH1Comment"># - check that the a bad byte immediately aborts</span>
<span id="L1329" class="LineNr">1329 </span> <span class="subxComment"># This test uses exit-descriptors. Use EBP for setting up local variables.</span>
<span id="L1330" class="LineNr">1330 </span> 55/push-EBP
@ -1477,7 +1477,7 @@ if ('onhashchange' in window) {
<span id="L1414" class="LineNr">1414 </span> 5d/pop-to-EBP
<span id="L1415" class="LineNr">1415 </span> c3/return
<span id="L1416" class="LineNr">1416 </span>
<span id="L1417" class="LineNr">1417 </span><span class="subxFunction"><a href='hex.subx.html#L1417'>is-hex-lowercase-byte?</a></span>: <span class="subxComment"># c : byte -&gt; bool/EAX</span>
<span id="L1417" class="LineNr">1417 </span><span class="subxFunction">is-hex-lowercase-byte?</span>: <span class="subxComment"># c : byte -&gt; bool/EAX</span>
<span id="L1418" class="LineNr">1418 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L1419" class="LineNr">1419 </span> 55/push-EBP
<span id="L1420" class="LineNr">1420 </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>
@ -1509,7 +1509,7 @@ if ('onhashchange' in window) {
<span id="L1446" class="LineNr">1446 </span> 5d/pop-to-EBP
<span id="L1447" class="LineNr">1447 </span> c3/return
<span id="L1448" class="LineNr">1448 </span>
<span id="L1449" class="LineNr">1449 </span><span class="subxTest"><a href='hex.subx.html#L1449'>test-hex-below-0</a></span>:
<span id="L1449" class="LineNr">1449 </span><span class="subxTest">test-hex-below-0</span>:
<span id="L1450" class="LineNr">1450 </span> <span class="subxComment"># is-hex-lowercase-byte?(0x2f)</span>
<span id="L1451" class="LineNr">1451 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1452" class="LineNr">1452 </span> 68/push 0x2f/imm32
@ -1528,7 +1528,7 @@ if ('onhashchange' in window) {
<span id="L1465" class="LineNr">1465 </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="L1466" class="LineNr">1466 </span> c3/return
<span id="L1467" class="LineNr">1467 </span>
<span id="L1468" class="LineNr">1468 </span><span class="subxTest"><a href='hex.subx.html#L1468'>test-hex-0-to-9</a></span>:
<span id="L1468" class="LineNr">1468 </span><span class="subxTest">test-hex-0-to-9</span>:
<span id="L1469" class="LineNr">1469 </span> <span class="subxComment"># is-hex-lowercase-byte?(0x30)</span>
<span id="L1470" class="LineNr">1470 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1471" class="LineNr">1471 </span> 68/push 0x30/imm32
@ -1563,7 +1563,7 @@ if ('onhashchange' in window) {
<span id="L1500" class="LineNr">1500 </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="L1501" class="LineNr">1501 </span> c3/return
<span id="L1502" class="LineNr">1502 </span>
<span id="L1503" class="LineNr">1503 </span><span class="subxTest"><a href='hex.subx.html#L1503'>test-hex-above-9-to-a</a></span>:
<span id="L1503" class="LineNr">1503 </span><span class="subxTest">test-hex-above-9-to-a</span>:
<span id="L1504" class="LineNr">1504 </span> <span class="subxComment"># is-hex-lowercase-byte?(0x3a)</span>
<span id="L1505" class="LineNr">1505 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1506" class="LineNr">1506 </span> 68/push 0x3a/imm32
@ -1582,7 +1582,7 @@ if ('onhashchange' in window) {
<span id="L1519" class="LineNr">1519 </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="L1520" class="LineNr">1520 </span> c3/return
<span id="L1521" class="LineNr">1521 </span>
<span id="L1522" class="LineNr">1522 </span><span class="subxTest"><a href='hex.subx.html#L1522'>test-hex-a-to-f</a></span>:
<span id="L1522" class="LineNr">1522 </span><span class="subxTest">test-hex-a-to-f</span>:
<span id="L1523" class="LineNr">1523 </span> <span class="subxComment"># is-hex-lowercase-byte?(0x61)</span>
<span id="L1524" class="LineNr">1524 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1525" class="LineNr">1525 </span> 68/push 0x61/imm32
@ -1617,7 +1617,7 @@ if ('onhashchange' in window) {
<span id="L1554" class="LineNr">1554 </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="L1555" class="LineNr">1555 </span> c3/return
<span id="L1556" class="LineNr">1556 </span>
<span id="L1557" class="LineNr">1557 </span><span class="subxTest"><a href='hex.subx.html#L1557'>test-hex-above-f</a></span>:
<span id="L1557" class="LineNr">1557 </span><span class="subxTest">test-hex-above-f</span>:
<span id="L1558" class="LineNr">1558 </span> <span class="subxComment"># is-hex-lowercase-byte?(0x67)</span>
<span id="L1559" class="LineNr">1559 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L1560" class="LineNr">1560 </span> 68/push 0x67/imm32
@ -1636,7 +1636,7 @@ if ('onhashchange' in window) {
<span id="L1573" class="LineNr">1573 </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="L1574" class="LineNr">1574 </span> c3/return
<span id="L1575" class="LineNr">1575 </span>
<span id="L1576" class="LineNr">1576 </span><span class="subxFunction"><a href='hex.subx.html#L1576'>parse-hex-digit</a></span>: <span class="subxComment"># in/EAX : byte -&gt; out/EAX : num</span>
<span id="L1576" class="LineNr">1576 </span><span class="subxFunction">parse-hex-digit</span>: <span class="subxComment"># in/EAX : byte -&gt; out/EAX : num</span>
<span id="L1577" class="LineNr">1577 </span> <span class="subxComment"># no error checking; accepts argument in EAX</span>
<span id="L1578" class="LineNr">1578 </span> <span class="subxComment"># if EAX &lt;= '9' return EAX - '0'</span>
<span id="L1579" class="LineNr">1579 </span> 3d/compare-EAX 0x39/imm32/9
@ -1648,7 +1648,7 @@ if ('onhashchange' in window) {
<span id="L1585" class="LineNr">1585 </span> 2d/subtract-from-EAX 0x57/imm32/a-10
<span id="L1586" class="LineNr">1586 </span> c3/return
<span id="L1587" class="LineNr">1587 </span>
<span id="L1588" class="LineNr">1588 </span><span class="subxFunction"><a href='hex.subx.html#L1588'>skip-until-newline</a></span>: <span class="subxComment"># in : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L1588" class="LineNr">1588 </span><span class="subxFunction">skip-until-newline</span>: <span class="subxComment"># in : (address buffered-file) -&gt; &lt;void&gt;</span>
<span id="L1589" class="LineNr">1589 </span> <span class="subxComment"># pseudocode:</span>
<span id="L1590" class="LineNr">1590 </span> <span class="subxComment"># push EAX</span>
<span id="L1591" class="LineNr">1591 </span> <span class="subxComment"># repeatedly:</span>
@ -1683,7 +1683,7 @@ if ('onhashchange' in window) {
<span id="L1620" class="LineNr">1620 </span> 5d/pop-to-EBP
<span id="L1621" class="LineNr">1621 </span> c3/return
<span id="L1622" class="LineNr">1622 </span>
<span id="L1623" class="LineNr">1623 </span><span class="subxTest"><a href='hex.subx.html#L1623'>test-skip-until-newline</a></span>:
<span id="L1623" class="LineNr">1623 </span><span class="subxTest">test-skip-until-newline</span>:
<span id="L1624" class="LineNr">1624 </span> <span class="subxH1Comment"># - check that the read pointer points after the newline</span>
<span id="L1625" class="LineNr">1625 </span> <span class="subxComment"># setup</span>
<span id="L1626" class="LineNr">1626 </span> <span class="subxS1Comment"># . clear-stream(_test-stream)</span>
@ -1749,7 +1749,7 @@ if ('onhashchange' in window) {
<span id="L1686" class="LineNr">1686 </span>
<span id="L1687" class="LineNr">1687 </span>== data
<span id="L1688" class="LineNr">1688 </span>
<span id="L1689" class="LineNr">1689 </span><span class="subxMinorFunction"><a href='hex.subx.html#L1689'>_test-error-stream</a></span>:
<span id="L1689" class="LineNr">1689 </span><span class="subxMinorFunction">_test-error-stream</span>:
<span id="L1690" class="LineNr">1690 </span> <span class="subxComment"># current write index</span>
<span id="L1691" class="LineNr">1691 </span> 00 00 00 00
<span id="L1692" class="LineNr">1692 </span> <span class="subxComment"># current read index</span>
@ -1760,7 +1760,7 @@ if ('onhashchange' in window) {
<span id="L1697" class="LineNr">1697 </span> 00 00 00 00 00 00 00 00 <span class="subxComment"># 8 bytes</span>
<span id="L1698" class="LineNr">1698 </span>
<span id="L1699" class="LineNr">1699 </span><span class="subxComment"># a test buffered file for _test-stream</span>
<span id="L1700" class="LineNr">1700 </span><span class="subxMinorFunction"><a href='hex.subx.html#L1700'>_test-error-buffered-file</a></span>:
<span id="L1700" class="LineNr">1700 </span><span class="subxMinorFunction">_test-error-buffered-file</span>:
<span id="L1701" class="LineNr">1701 </span> <span class="subxComment"># file descriptor or (address stream)</span>
<span id="L1702" class="LineNr">1702 </span> <a href='hex.subx.html#L1689'>_test-error-stream</a>/imm32
<span id="L1703" class="LineNr">1703 </span> <span class="subxComment"># current write index</span>

2
html/subx/examples/ex10.subx.html
View File

@ -92,7 +92,7 @@ if ('onhashchange' in window) {
<span id="L34" class="LineNr">34 </span>
<span id="L35" class="LineNr">35 </span><span class="subxComment"># compare two null-terminated ascii strings</span>
<span id="L36" class="LineNr">36 </span><span class="subxComment"># reason for the name: the only place we should have null-terminated ascii strings is from commandline args</span>
<span id="L37" class="LineNr">37 </span><span class="subxFunction"><a href='ex10.subx.html#L37'>argv-equal</a></span>: <span class="subxComment"># (s1, s2) : null-terminated ascii strings -&gt; EAX : boolean</span>
<span id="L37" class="LineNr">37 </span><span class="subxFunction">argv-equal</span>: <span class="subxComment"># (s1, s2) : null-terminated ascii strings -&gt; EAX : boolean</span>
<span id="L38" class="LineNr">38 </span> <span class="subxComment"># initialize s1 (ECX) and s2 (EDX)</span>
<span id="L39" class="LineNr">39 </span> 8b/copy 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none <span class="Normal"> . </span> 1/r32/ECX 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ESP+4) to ECX</span>
<span id="L40" class="LineNr">40 </span> 8b/copy 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none <span class="Normal"> . </span> 2/r32/EDX 8/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ESP+8) to EDX</span>

26
html/subx/examples/ex11.subx.html
View File

@ -89,7 +89,7 @@ if ('onhashchange' in window) {
<span id="L28" class="LineNr"> 28 </span>
<span id="L29" class="LineNr"> 29 </span><span class="subxComment"># compare a null-terminated ascii string with a more idiomatic length-prefixed byte array</span>
<span id="L30" class="LineNr"> 30 </span><span class="subxComment"># reason for the name: the only place we should have null-terminated ascii strings is from commandline args</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction"><a href='ex11.subx.html#L31'>kernel-string-equal</a></span>: <span class="subxComment"># s : null-terminated ascii string, benchmark : length-prefixed ascii string -&gt; EAX : boolean</span>
<span id="L31" class="LineNr"> 31 </span><span class="subxFunction">kernel-string-equal</span>: <span class="subxComment"># s : null-terminated ascii string, benchmark : length-prefixed ascii string -&gt; EAX : boolean</span>
<span id="L32" class="LineNr"> 32 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L33" class="LineNr"> 33 </span> 55/push-EBP
<span id="L34" class="LineNr"> 34 </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>
@ -171,7 +171,7 @@ if ('onhashchange' in window) {
<span id="L110" class="LineNr">110 </span>
<span id="L111" class="LineNr">111 </span><span class="subxH1Comment"># - tests</span>
<span id="L112" class="LineNr">112 </span>
<span id="L113" class="LineNr">113 </span><span class="subxTest"><a href='ex11.subx.html#L113'>test-compare-null-kernel-string-with-empty-array</a></span>:
<span id="L113" class="LineNr">113 </span><span class="subxTest">test-compare-null-kernel-string-with-empty-array</span>:
<span id="L114" class="LineNr">114 </span> <span class="subxComment"># EAX = kernel-string-equal(Null-kernel-string, &quot;&quot;)</span>
<span id="L115" class="LineNr">115 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L116" class="LineNr">116 </span> 68/push <span class="Constant">&quot;&quot;</span>/imm32
@ -191,7 +191,7 @@ if ('onhashchange' in window) {
<span id="L130" class="LineNr">130 </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="L131" class="LineNr">131 </span> c3/return
<span id="L132" class="LineNr">132 </span>
<span id="L133" class="LineNr">133 </span><span class="subxTest"><a href='ex11.subx.html#L133'>test-compare-null-kernel-string-with-non-empty-array</a></span>:
<span id="L133" class="LineNr">133 </span><span class="subxTest">test-compare-null-kernel-string-with-non-empty-array</span>:
<span id="L134" class="LineNr">134 </span> <span class="subxComment"># EAX = kernel-string-equal(Null-kernel-string, &quot;Abc&quot;)</span>
<span id="L135" class="LineNr">135 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L136" class="LineNr">136 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -211,7 +211,7 @@ if ('onhashchange' in window) {
<span id="L150" class="LineNr">150 </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="L151" class="LineNr">151 </span> c3/return
<span id="L152" class="LineNr">152 </span>
<span id="L153" class="LineNr">153 </span><span class="subxTest"><a href='ex11.subx.html#L153'>test-compare-kernel-string-with-equal-array</a></span>:
<span id="L153" class="LineNr">153 </span><span class="subxTest">test-compare-kernel-string-with-equal-array</span>:
<span id="L154" class="LineNr">154 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Abc&quot;)</span>
<span id="L155" class="LineNr">155 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L156" class="LineNr">156 </span> 68/push <span class="Constant">&quot;Abc&quot;</span>/imm32
@ -231,7 +231,7 @@ if ('onhashchange' in window) {
<span id="L170" class="LineNr">170 </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="L171" class="LineNr">171 </span> c3/return
<span id="L172" class="LineNr">172 </span>
<span id="L173" class="LineNr">173 </span><span class="subxTest"><a href='ex11.subx.html#L173'>test-compare-kernel-string-with-inequal-array</a></span>:
<span id="L173" class="LineNr">173 </span><span class="subxTest">test-compare-kernel-string-with-inequal-array</span>:
<span id="L174" class="LineNr">174 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Adc&quot;)</span>
<span id="L175" class="LineNr">175 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L176" class="LineNr">176 </span> 68/push <span class="Constant">&quot;Adc&quot;</span>/imm32
@ -251,7 +251,7 @@ if ('onhashchange' in window) {
<span id="L190" class="LineNr">190 </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="L191" class="LineNr">191 </span> c3/return
<span id="L192" class="LineNr">192 </span>
<span id="L193" class="LineNr">193 </span><span class="subxTest"><a href='ex11.subx.html#L193'>test-compare-kernel-string-with-empty-array</a></span>:
<span id="L193" class="LineNr">193 </span><span class="subxTest">test-compare-kernel-string-with-empty-array</span>:
<span id="L194" class="LineNr">194 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;&quot;)</span>
<span id="L195" class="LineNr">195 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L196" class="LineNr">196 </span> 68/push <span class="Constant">&quot;&quot;</span>/imm32
@ -271,7 +271,7 @@ if ('onhashchange' in window) {
<span id="L210" class="LineNr">210 </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="L211" class="LineNr">211 </span> c3/return
<span id="L212" class="LineNr">212 </span>
<span id="L213" class="LineNr">213 </span><span class="subxTest"><a href='ex11.subx.html#L213'>test-compare-kernel-string-with-shorter-array</a></span>:
<span id="L213" class="LineNr">213 </span><span class="subxTest">test-compare-kernel-string-with-shorter-array</span>:
<span id="L214" class="LineNr">214 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Ab&quot;)</span>
<span id="L215" class="LineNr">215 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L216" class="LineNr">216 </span> 68/push <span class="Constant">&quot;Ab&quot;</span>/imm32
@ -291,7 +291,7 @@ if ('onhashchange' in window) {
<span id="L230" class="LineNr">230 </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="L231" class="LineNr">231 </span> c3/return
<span id="L232" class="LineNr">232 </span>
<span id="L233" class="LineNr">233 </span><span class="subxTest"><a href='ex11.subx.html#L233'>test-compare-kernel-string-with-longer-array</a></span>:
<span id="L233" class="LineNr">233 </span><span class="subxTest">test-compare-kernel-string-with-longer-array</span>:
<span id="L234" class="LineNr">234 </span> <span class="subxComment"># EAX = kernel-string-equal(Abc-kernel-string, &quot;Abcd&quot;)</span>
<span id="L235" class="LineNr">235 </span> <span class="subxS2Comment"># . . push args</span>
<span id="L236" class="LineNr">236 </span> 68/push <span class="Constant">&quot;Abcd&quot;</span>/imm32
@ -314,7 +314,7 @@ if ('onhashchange' in window) {
<span id="L253" class="LineNr">253 </span><span class="subxH1Comment"># - helpers</span>
<span id="L254" class="LineNr">254 </span>
<span id="L255" class="LineNr">255 </span><span class="subxComment"># print msg to stderr if a != b, otherwise print &quot;.&quot;</span>
<span id="L256" class="LineNr">256 </span><span class="subxFunction"><a href='ex11.subx.html#L256'>check-ints-equal</a></span>: <span class="subxComment"># (a : int, b : int, msg : (address array byte)) -&gt; boolean</span>
<span id="L256" class="LineNr">256 </span><span class="subxFunction">check-ints-equal</span>: <span class="subxComment"># (a : int, b : int, msg : (address array byte)) -&gt; boolean</span>
<span id="L257" class="LineNr">257 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L258" class="LineNr">258 </span> 55/push-EBP
<span id="L259" class="LineNr">259 </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>
@ -363,7 +363,7 @@ if ('onhashchange' in window) {
<span id="L302" class="LineNr">302 </span> 5d/pop-to-EBP
<span id="L303" class="LineNr">303 </span> c3/return
<span id="L304" class="LineNr">304 </span>
<span id="L305" class="LineNr">305 </span><span class="subxFunction"><a href='ex11.subx.html#L305'>write-stderr</a></span>: <span class="subxComment"># s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L305" class="LineNr">305 </span><span class="subxFunction">write-stderr</span>: <span class="subxComment"># s : (address array byte) -&gt; &lt;void&gt;</span>
<span id="L306" class="LineNr">306 </span> <span class="subxS1Comment"># . prolog</span>
<span id="L307" class="LineNr">307 </span> 55/push-EBP
<span id="L308" class="LineNr">308 </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>
@ -396,16 +396,16 @@ if ('onhashchange' in window) {
<span id="L335" class="LineNr">335 </span>
<span id="L336" class="LineNr">336 </span>== data
<span id="L337" class="LineNr">337 </span>
<span id="L338" class="LineNr">338 </span><span class="SpecialChar"><a href='ex11.subx.html#L338'>Newline</a></span>:
<span id="L338" class="LineNr">338 </span><span class="SpecialChar">Newline</span>:
<span id="L339" class="LineNr">339 </span> <span class="subxComment"># size</span>
<span id="L340" class="LineNr">340 </span> 01 00 00 00
<span id="L341" class="LineNr">341 </span> <span class="subxComment"># data</span>
<span id="L342" class="LineNr">342 </span> 0a/newline
<span id="L343" class="LineNr">343 </span>
<span id="L344" class="LineNr">344 </span><span class="subxComment"># for kernel-string-equal tests</span>
<span id="L345" class="LineNr">345 </span><span class="SpecialChar"><a href='ex11.subx.html#L345'>Null-kernel-string</a></span>:
<span id="L345" class="LineNr">345 </span><span class="SpecialChar">Null-kernel-string</span>:
<span id="L346" class="LineNr">346 </span> 00/null
<span id="L347" class="LineNr">347 </span><span class="SpecialChar"><a href='ex11.subx.html#L347'>Abc-kernel-string</a></span>:
<span id="L347" class="LineNr">347 </span><span class="SpecialChar">Abc-kernel-string</span>:
<span id="L348" class="LineNr">348 </span> 41/A 62/b 63/c 00/null
<span id="L349" class="LineNr">349 </span>
<span id="L350" class="LineNr">350 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

2
html/subx/examples/ex12.subx.html
View File

@ -84,7 +84,7 @@ if ('onhashchange' in window) {
<span id="L27" class="LineNr">27 </span>== data
<span id="L28" class="LineNr">28 </span>
<span id="L29" class="LineNr">29 </span><span class="subxComment"># various constants used here were found in the Linux sources (search for file mman-common.h)</span>
<span id="L30" class="LineNr">30 </span><span class="SpecialChar"><a href='ex12.subx.html#L30'>Mmap-new-segment</a></span>: <span class="subxComment"># type mmap_arg_struct</span>
<span id="L30" class="LineNr">30 </span><span class="SpecialChar">Mmap-new-segment</span>: <span class="subxComment"># type mmap_arg_struct</span>
<span id="L31" class="LineNr">31 </span> <span class="subxComment"># addr</span>
<span id="L32" class="LineNr">32 </span> 00 00 00 00 <span class="subxComment"># null</span>
<span id="L33" class="LineNr">33 </span> <span class="subxComment"># len</span>

2
html/subx/examples/ex4.subx.html
View File

@ -90,7 +90,7 @@ if ('onhashchange' in window) {
<span id="L34" class="LineNr">34 </span>
<span id="L35" class="LineNr">35 </span>== data
<span id="L36" class="LineNr">36 </span>
<span id="L37" class="LineNr">37 </span><span class="SpecialChar"><a href='ex4.subx.html#L37'>X</a></span>:
<span id="L37" class="LineNr">37 </span><span class="SpecialChar">X</span>:
<span id="L38" class="LineNr">38 </span> 00 00 00 00 <span class="subxComment"># space for read() to write to</span>
<span id="L39" class="LineNr">39 </span>
<span id="L40" class="LineNr">40 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

4
html/subx/examples/ex6.subx.html
View File

@ -84,9 +84,9 @@ if ('onhashchange' in window) {
<span id="L27" class="LineNr">27 </span>
<span id="L28" class="LineNr">28 </span>== data
<span id="L29" class="LineNr">29 </span>
<span id="L30" class="LineNr">30 </span><span class="SpecialChar"><a href='ex6.subx.html#L30'>Size</a></span>: <span class="subxComment"># size of string</span>
<span id="L30" class="LineNr">30 </span><span class="SpecialChar">Size</span>: <span class="subxComment"># size of string</span>
<span id="L31" class="LineNr">31 </span> 0e 00 00 00 <span class="subxComment"># 14</span>
<span id="L32" class="LineNr">32 </span><span class="SpecialChar"><a href='ex6.subx.html#L32'>X</a></span>: <span class="subxComment"># string to print</span>
<span id="L32" class="LineNr">32 </span><span class="SpecialChar">X</span>: <span class="subxComment"># string to print</span>
<span id="L33" class="LineNr">33 </span> 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 0a 00
<span id="L34" class="LineNr">34 </span><span class="subxComment"># H e l l o , ␣ w o r l d ! newline null</span>
<span id="L35" class="LineNr">35 </span>

8
html/subx/examples/ex7.subx.html
View File

@ -150,13 +150,13 @@ if ('onhashchange' in window) {
<span id="L93" class="LineNr"> 93 </span>
<span id="L94" class="LineNr"> 94 </span>== data
<span id="L95" class="LineNr"> 95 </span>
<span id="L96" class="LineNr"> 96 </span><span class="SpecialChar"><a href='ex7.subx.html#L96'>Stream</a></span>:
<span id="L96" class="LineNr"> 96 </span><span class="SpecialChar">Stream</span>:
<span id="L97" class="LineNr"> 97 </span> 00 00 00 00
<span id="L98" class="LineNr"> 98 </span><span class="SpecialChar"><a href='ex7.subx.html#L98'>A</a></span>:
<span id="L98" class="LineNr"> 98 </span><span class="SpecialChar">A</span>:
<span id="L99" class="LineNr"> 99 </span> 61 00 00 00
<span id="L100" class="LineNr">100 </span><span class="SpecialChar"><a href='ex7.subx.html#L100'>B</a></span>:
<span id="L100" class="LineNr">100 </span><span class="SpecialChar">B</span>:
<span id="L101" class="LineNr">101 </span> 00 00 00 00
<span id="L102" class="LineNr">102 </span><span class="SpecialChar"><a href='ex7.subx.html#L102'>Filename</a></span>:
<span id="L102" class="LineNr">102 </span><span class="SpecialChar">Filename</span>:
<span id="L103" class="LineNr">103 </span> 2e 66 6f 6f 00 00 00 00
<span id="L104" class="LineNr">104 </span>
<span id="L105" class="LineNr">105 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>

2
html/subx/examples/ex8.subx.html
View File

@ -92,7 +92,7 @@ if ('onhashchange' in window) {
<span id="L34" class="LineNr">34 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L35" class="LineNr">35 </span> cd/syscall 0x80/imm8
<span id="L36" class="LineNr">36 </span>
<span id="L37" class="LineNr">37 </span><span class="subxFunction"><a href='ex8.subx.html#L37'>ascii-length</a></span>: <span class="subxComment"># s : (address array byte) -&gt; n/EAX</span>
<span id="L37" class="LineNr">37 </span><span class="subxFunction">ascii-length</span>: <span class="subxComment"># s : (address array byte) -&gt; n/EAX</span>
<span id="L38" class="LineNr">38 </span> <span class="subxComment"># EDX = s</span>
<span id="L39" class="LineNr">39 </span> 8b/copy 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none <span class="Normal"> . </span> 2/r32/EDX 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ESP+4) to EDX</span>
<span id="L40" class="LineNr">40 </span> <span class="subxComment"># var result/EAX = 0</span>

2
html/subx/examples/ex9.subx.html
View File

@ -95,7 +95,7 @@ if ('onhashchange' in window) {
<span id="L38" class="LineNr">38 </span> b8/copy-to-EAX 1/imm32/exit
<span id="L39" class="LineNr">39 </span> cd/syscall 0x80/imm8
<span id="L40" class="LineNr">40 </span>
<span id="L41" class="LineNr">41 </span><span class="subxFunction"><a href='ex9.subx.html#L41'>ascii-difference</a></span>: <span class="subxComment"># (s1, s2) : null-terminated ascii strings</span>
<span id="L41" class="LineNr">41 </span><span class="subxFunction">ascii-difference</span>: <span class="subxComment"># (s1, s2) : null-terminated ascii strings</span>
<span id="L42" class="LineNr">42 </span> <span class="subxComment"># a = first letter of s1 (ECX)</span>
<span id="L43" class="LineNr">43 </span> 8b/copy 1/mod/*+disp8 4/rm32/sib 4/base/ESP 4/index/none 0/r32/EAX 4/disp8 <span class="Normal"> . </span> <span class="subxComment"># copy *(ESP+4) to EAX</span>
<span id="L44" class="LineNr">44 </span> 8b/copy 0/mod/indirect 0/rm32/EAX <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 EAX</span>

6
linkify/linkify.cc
View File

@ -131,7 +131,9 @@ void replace_tags_in_file(const string& filename, const map<string, syminfo>& in
out << line.substr(0, skip_first_span);
istringstream in2(line.substr(skip_first_span));
in2 >> std::noskipws;
bool at_start_of_line = ends_with(filename, ".subx");
// only in .subx files, refuse to linkify the first word on a line
bool at_start_of_line = ends_with(filename, ".subx.html");
//? cerr << filename << ": " << at_start_of_line << '\n';
while (has_data(in2)) {
if (isspace(in2.peek())) {
//? cerr << "space\n";
@ -229,7 +231,7 @@ void replace_tags_in_file(const string& filename, const map<string, syminfo>& in
}
else {
if (at_start_of_line) {
//? cerr << " at start of line\n";
//? cerr << " at start of line; refusing to linkify " << symbol << "\n";
out << symbol;
}
else {