about summary refs log tree commit diff stats
path: root/README
blob: 4860bbe53e4101c125319ff65857917f01e1da33 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
dwm - dynamic window manager
----------------------------
dwm is an extremely fast, small, and dynamic window manager for X.


Requirements
------------
In order to build dwm you need the Xlib header files.


Installation
------------
Edit config.mk to match your local setup (dwm is installed into
the /usr/local namespace by default).

Afterwards enter the following command to build and install dwm (if
necessary as root):

    make clean install


Running dwm
-----------
Add the following line to your .xinitrc to start dwm using startx:

    exec dwm

In order to connect dwm to a specific display, make sure that
the DISPLAY environment variable is set correctly, e.g.:

    DISPLAY=foo.bar:1 exec dwm

(This will start dwm on display :1 of the host foo.bar.)

In order to display status info in the bar, you can do something
like this in your .xinitrc:

    while true
    do
        echo `date` `uptime | sed 's/.*://; s/,//g'`
        sleep 1
    done | dwm


Configuration
-------------
The configuration of dwm is done by creating a custom config.h
and (re)compiling the source code.
='n244' href='#n244'>244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Mu - 054string-equal.subx</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.subxComment { color: #005faf; }
.subxFunction { color: #af5f00; text-decoration: underline; }
.subxS2Comment { color: #8a8a8a; }
.LineNr { }
.subxS1Comment { color: #0000af; }
.CommentedCode { color: #8a8a8a; }
.SpecialChar { color: #d70000; }
.Normal { color: #000000; background-color: #c6c6c6; padding-bottom: 1px; }
.Constant { color: #008787; }
.subxTest { color: #5f8700; }
.subxH1Comment { color: #005faf; text-decoration: underline; }
-->
</style>

<script type='text/javascript'>
<!--

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  var lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<a href='https://github.com/akkartik/mu/blob/master/054string-equal.subx'>https://github.com/akkartik/mu/blob/master/054string-equal.subx</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="subxComment"># Comparing 'regular' length-prefixed strings.</span>
<span id="L2" class="LineNr">  2 </span>
<span id="L3" class="LineNr">  3 </span>== code
<span id="L4" class="LineNr">  4 </span><span class="subxComment">#   instruction                     effective address                                                   register    displacement    immediate</span>
<span id="L5" class="LineNr">  5 </span><span class="subxS1Comment"># . op          subop               mod             rm32          base        index         scale       r32</span>
<span id="L6" class="LineNr">  6 </span><span class="subxS1Comment"># . 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes</span>
<span id="L7" class="LineNr">  7 </span>
<span id="L8" class="LineNr">  8 </span><span class="SpecialChar">Entry</span>:  <span class="subxComment"># run all tests</span>
<span id="L9" class="LineNr">  9 </span><span class="CommentedCode">#?     e8/call test-compare-equal-strings/disp32</span>
<span id="L10" class="LineNr"> 10 </span>    e8/call  run-tests/disp32  <span class="subxComment"># 'run-tests' is a function created automatically by SubX. It calls all functions that start with 'test-'.</span>
<span id="L11" class="LineNr"> 11 </span>    <span class="subxComment"># syscall(exit, Num-test-failures)</span>
<span id="L12" class="LineNr"> 12 </span>    8b/copy                         0/mod/indirect  5/rm32/.disp32           <span class="Normal"> . </span>           <span class="Normal"> . </span>          3/r32/ebx   <span class="SpecialChar"><a href='051test.subx.html#L90'>Num-test-failures</a></span>/disp32          <span class="subxComment"># copy *Num-test-failures to ebx</span>
<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">string-equal?</span>:  <span class="subxComment"># s : (address string), benchmark : (address string) -&gt; eax : boolean</span>
<span id="L17" class="LineNr"> 17 </span>    <span class="subxComment"># pseudocode:</span>
<span id="L18" class="LineNr"> 18 </span>    <span class="subxComment">#   if (s-&gt;length != benchmark-&gt;length) return false</span>
<span id="L19" class="LineNr"> 19 </span>    <span class="subxComment">#   currs = s-&gt;data</span>
<span id="L20" class="LineNr"> 20 </span>    <span class="subxComment">#   currb = benchmark-&gt;data</span>
<span id="L21" class="LineNr"> 21 </span>    <span class="subxComment">#   maxs = s-&gt;data + s-&gt;length</span>
<span id="L22" class="LineNr"> 22 </span>    <span class="subxComment">#   while currs &lt; maxs</span>
<span id="L23" class="LineNr"> 23 </span>    <span class="subxComment">#     c1 = *currs</span>
<span id="L24" class="LineNr"> 24 </span>    <span class="subxComment">#     c2 = *currb</span>
<span id="L25" class="LineNr"> 25 </span>    <span class="subxComment">#     if (c1 != c2) return false</span>
<span id="L26" class="LineNr"> 26 </span>    <span class="subxComment">#     ++currs, ++currb</span>
<span id="L27" class="LineNr"> 27 </span>    <span class="subxComment">#   return true</span>
<span id="L28" class="LineNr"> 28 </span>    <span class="subxComment">#</span>
<span id="L29" class="LineNr"> 29 </span>    <span class="subxComment"># registers:</span>
<span id="L30" class="LineNr"> 30 </span>    <span class="subxComment">#   currs: esi</span>
<span id="L31" class="LineNr"> 31 </span>    <span class="subxComment">#   maxs: ecx</span>
<span id="L32" class="LineNr"> 32 </span>    <span class="subxComment">#   currb: edi</span>
<span id="L33" class="LineNr"> 33 </span>    <span class="subxComment">#   c1: eax</span>
<span id="L34" class="LineNr"> 34 </span>    <span class="subxComment">#   c2: ebx</span>
<span id="L35" class="LineNr"> 35 </span>    <span class="subxComment">#</span>
<span id="L36" class="LineNr"> 36 </span>    <span class="subxS1Comment"># . prolog</span>
<span id="L37" class="LineNr"> 37 </span>    55/push-ebp
<span id="L38" class="LineNr"> 38 </span>    89/copy                         3/mod/direct    5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          4/r32/esp  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy esp to ebp</span>
<span id="L39" class="LineNr"> 39 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L40" class="LineNr"> 40 </span>    51/push-ecx
<span id="L41" class="LineNr"> 41 </span>    52/push-edx
<span id="L42" class="LineNr"> 42 </span>    56/push-esi
<span id="L43" class="LineNr"> 43 </span>    57/push-edi
<span id="L44" class="LineNr"> 44 </span>    <span class="subxComment"># esi = s</span>
<span id="L45" class="LineNr"> 45 </span>    8b/copy                         1/mod/*+disp8   5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          6/r32/esi   8/disp8        <span class="Normal"> . </span>                <span class="subxComment"># copy *(ebp+8) to esi</span>
<span id="L46" class="LineNr"> 46 </span>    <span class="subxComment"># edi = benchmark</span>
<span id="L47" class="LineNr"> 47 </span>    8b/copy                         1/mod/*+disp8   5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          7/r32/edi   0xc/disp8      <span class="Normal"> . </span>                <span class="subxComment"># copy *(ebp+12) to edi</span>
<span id="L48" class="LineNr"> 48 </span>    <span class="subxComment"># ecx = s-&gt;length</span>
<span id="L49" class="LineNr"> 49 </span>    8b/copy                         0/mod/indirect  6/rm32/esi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          1/r32/ecx  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy *esi to ecx</span>
<span id="L50" class="LineNr"> 50 </span><span class="Constant">$string-equal?:lengths</span>:
<span id="L51" class="LineNr"> 51 </span>    <span class="subxComment"># if (ecx != benchmark-&gt;length) return false</span>
<span id="L52" class="LineNr"> 52 </span>    39/compare                      0/mod/indirect  7/rm32/edi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          1/r32/ecx  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># compare *edi and ecx</span>
<span id="L53" class="LineNr"> 53 </span>    75/jump-if-not-equal  $string-equal?:false/disp8
<span id="L54" class="LineNr"> 54 </span>    <span class="subxComment"># currs/esi = s-&gt;data</span>
<span id="L55" class="LineNr"> 55 </span>    81          0/subop/add         3/mod/direct    6/rm32/esi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              4/imm32           <span class="subxComment"># add to esi</span>
<span id="L56" class="LineNr"> 56 </span>    <span class="subxComment"># maxs/ecx = s-&gt;data + s-&gt;length</span>
<span id="L57" class="LineNr"> 57 </span>    01/add                          3/mod/direct    1/rm32/ecx   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          6/r32/esi  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># add esi to ecx</span>
<span id="L58" class="LineNr"> 58 </span>    <span class="subxComment"># currb/edi = benchmark-&gt;data</span>
<span id="L59" class="LineNr"> 59 </span>    81          0/subop/add         3/mod/direct    7/rm32/edi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              4/imm32           <span class="subxComment"># add to edi</span>
<span id="L60" class="LineNr"> 60 </span>    <span class="subxComment"># c1/eax = c2/edx = 0</span>
<span id="L61" class="LineNr"> 61 </span>    31/xor                          3/mod/direct    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"># clear eax</span>
<span id="L62" class="LineNr"> 62 </span>    31/xor                          3/mod/direct    2/rm32/edx   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          2/r32/edx  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># clear edx</span>
<span id="L63" class="LineNr"> 63 </span><span class="Constant">$string-equal?:loop</span>:
<span id="L64" class="LineNr"> 64 </span>    <span class="subxComment"># if (currs &gt;= maxs) return true</span>
<span id="L65" class="LineNr"> 65 </span>    39/compare                      3/mod/direct    6/rm32/esi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          1/r32/ecx  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># compare esi with ecx</span>
<span id="L66" class="LineNr"> 66 </span>    73/jump-if-greater-or-equal-unsigned  $string-equal?:true/disp8
<span id="L67" class="LineNr"> 67 </span>    <span class="subxComment"># c1 = *currs</span>
<span id="L68" class="LineNr"> 68 </span>    8a/copy-byte                    0/mod/indirect  6/rm32/esi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          0/r32/AL   <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy byte at *esi to AL</span>
<span id="L69" class="LineNr"> 69 </span>    <span class="subxComment"># c2 = *currb</span>
<span id="L70" class="LineNr"> 70 </span>    8a/copy-byte                    0/mod/indirect  7/rm32/edi   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          2/r32/DL   <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy byte at *edi to DL</span>
<span id="L71" class="LineNr"> 71 </span>    <span class="subxComment"># if (c1 != c2) return false</span>
<span id="L72" class="LineNr"> 72 </span>    39/compare                      3/mod/direct    0/rm32/eax   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          2/r32/edx  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># compare eax and edx</span>
<span id="L73" class="LineNr"> 73 </span>    75/jump-if-not-equal  $string-equal?:false/disp8
<span id="L74" class="LineNr"> 74 </span>    <span class="subxComment"># ++currs</span>
<span id="L75" class="LineNr"> 75 </span>    46/increment-esi
<span id="L76" class="LineNr"> 76 </span>    <span class="subxComment"># ++currb</span>
<span id="L77" class="LineNr"> 77 </span>    47/increment-edi
<span id="L78" class="LineNr"> 78 </span>    eb/jump  $string-equal?:<span class="Constant">loop</span>/disp8
<span id="L79" class="LineNr"> 79 </span><span class="Constant">$string-equal?:true</span>:
<span id="L80" class="LineNr"> 80 </span>    b8/copy-to-eax  1/imm32
<span id="L81" class="LineNr"> 81 </span>    eb/jump  $string-equal?:end/disp8
<span id="L82" class="LineNr"> 82 </span><span class="Constant">$string-equal?:false</span>:
<span id="L83" class="LineNr"> 83 </span>    b8/copy-to-eax  0/imm32
<span id="L84" class="LineNr"> 84 </span><span class="Constant">$string-equal?:end</span>:
<span id="L85" class="LineNr"> 85 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L86" class="LineNr"> 86 </span>    5f/pop-to-edi
<span id="L87" class="LineNr"> 87 </span>    5e/pop-to-esi
<span id="L88" class="LineNr"> 88 </span>    5a/pop-to-edx
<span id="L89" class="LineNr"> 89 </span>    59/pop-to-ecx
<span id="L90" class="LineNr"> 90 </span>    <span class="subxS1Comment"># . epilog</span>
<span id="L91" class="LineNr"> 91 </span>    89/copy                         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          5/r32/ebp  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy ebp to esp</span>
<span id="L92" class="LineNr"> 92 </span>    5d/pop-to-ebp
<span id="L93" class="LineNr"> 93 </span>    c3/return
<span id="L94" class="LineNr"> 94 </span>
<span id="L95" class="LineNr"> 95 </span><span class="subxH1Comment"># - tests</span>
<span id="L96" class="LineNr"> 96 </span>
<span id="L97" class="LineNr"> 97 </span><span class="subxTest">test-compare-empty-with-empty-string</span>:
<span id="L98" class="LineNr"> 98 </span>    <span class="subxComment"># eax = string-equal?(&quot;&quot;, &quot;&quot;)</span>
<span id="L99" class="LineNr"> 99 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L100" class="LineNr">100 </span>    68/push  <span class="Constant">&quot;&quot;</span>/imm32
<span id="L101" class="LineNr">101 </span>    68/push  <span class="Constant">&quot;&quot;</span>/imm32
<span id="L102" class="LineNr">102 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L103" class="LineNr">103 </span>    e8/call  <a href='054string-equal.subx.html#L16'>string-equal?</a>/disp32
<span id="L104" class="LineNr">104 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L105" class="LineNr">105 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L106" class="LineNr">106 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L107" class="LineNr">107 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L108" class="LineNr">108 </span>    68/push  <span class="Constant">&quot;F - test-compare-empty-with-empty-string&quot;</span>/imm32
<span id="L109" class="LineNr">109 </span>    68/push  1/imm32/true
<span id="L110" class="LineNr">110 </span>    50/push-eax
<span id="L111" class="LineNr">111 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L112" class="LineNr">112 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L113" class="LineNr">113 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L114" class="LineNr">114 </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="L115" class="LineNr">115 </span>    c3/return
<span id="L116" class="LineNr">116 </span>
<span id="L117" class="LineNr">117 </span><span class="subxTest">test-compare-empty-with-non-empty-string</span>:  <span class="subxComment"># also checks length-mismatch code path</span>
<span id="L118" class="LineNr">118 </span>    <span class="subxComment"># eax = string-equal?(&quot;&quot;, &quot;Abc&quot;)</span>
<span id="L119" class="LineNr">119 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L120" class="LineNr">120 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L121" class="LineNr">121 </span>    68/push  <span class="Constant">&quot;&quot;</span>/imm32
<span id="L122" class="LineNr">122 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L123" class="LineNr">123 </span>    e8/call  <a href='054string-equal.subx.html#L16'>string-equal?</a>/disp32
<span id="L124" class="LineNr">124 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L125" class="LineNr">125 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L126" class="LineNr">126 </span>    <span class="subxComment"># check-ints-equal(eax, 0, msg)</span>
<span id="L127" class="LineNr">127 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L128" class="LineNr">128 </span>    68/push  <span class="Constant">&quot;F - test-compare-empty-with-non-empty-string&quot;</span>/imm32
<span id="L129" class="LineNr">129 </span>    68/push  0/imm32/false
<span id="L130" class="LineNr">130 </span>    50/push-eax
<span id="L131" class="LineNr">131 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L132" class="LineNr">132 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L133" class="LineNr">133 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L134" class="LineNr">134 </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="L135" class="LineNr">135 </span>    c3/return
<span id="L136" class="LineNr">136 </span>
<span id="L137" class="LineNr">137 </span><span class="subxTest">test-compare-equal-strings</span>:
<span id="L138" class="LineNr">138 </span>    <span class="subxComment"># eax = string-equal?(&quot;Abc&quot;, &quot;Abc&quot;)</span>
<span id="L139" class="LineNr">139 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L140" class="LineNr">140 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L141" class="LineNr">141 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L142" class="LineNr">142 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L143" class="LineNr">143 </span>    e8/call  <a href='054string-equal.subx.html#L16'>string-equal?</a>/disp32
<span id="L144" class="LineNr">144 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L145" class="LineNr">145 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L146" class="LineNr">146 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L147" class="LineNr">147 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L148" class="LineNr">148 </span>    68/push  <span class="Constant">&quot;F - test-compare-equal-strings&quot;</span>/imm32
<span id="L149" class="LineNr">149 </span>    68/push  1/imm32/true
<span id="L150" class="LineNr">150 </span>    50/push-eax
<span id="L151" class="LineNr">151 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L152" class="LineNr">152 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L153" class="LineNr">153 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L154" class="LineNr">154 </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="L155" class="LineNr">155 </span>    c3/return
<span id="L156" class="LineNr">156 </span>
<span id="L157" class="LineNr">157 </span><span class="subxTest">test-compare-inequal-strings-equal-lengths</span>:
<span id="L158" class="LineNr">158 </span>    <span class="subxComment"># eax = string-equal?(&quot;Abc&quot;, &quot;Adc&quot;)</span>
<span id="L159" class="LineNr">159 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L160" class="LineNr">160 </span>    68/push  <span class="Constant">&quot;Adc&quot;</span>/imm32
<span id="L161" class="LineNr">161 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L162" class="LineNr">162 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L163" class="LineNr">163 </span>    e8/call  <a href='054string-equal.subx.html#L16'>string-equal?</a>/disp32
<span id="L164" class="LineNr">164 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L165" class="LineNr">165 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L166" class="LineNr">166 </span>    <span class="subxComment"># check-ints-equal(eax, 0, msg)</span>
<span id="L167" class="LineNr">167 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L168" class="LineNr">168 </span>    68/push  <span class="Constant">&quot;F - test-compare-inequal-strings-equal-lengths&quot;</span>/imm32
<span id="L169" class="LineNr">169 </span>    68/push  0/imm32/false
<span id="L170" class="LineNr">170 </span>    50/push-eax
<span id="L171" class="LineNr">171 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L172" class="LineNr">172 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L173" class="LineNr">173 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L174" class="LineNr">174 </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="L175" class="LineNr">175 </span>    c3/return
<span id="L176" class="LineNr">176 </span>
<span id="L177" class="LineNr">177 </span><span class="subxComment"># helper for later tests</span>
<span id="L178" class="LineNr">178 </span><span class="subxFunction">check-string-equal</span>:  <span class="subxComment"># s : (address string), expected : (address string), msg : (address string)</span>
<span id="L179" class="LineNr">179 </span>    <span class="subxS1Comment"># . prolog</span>
<span id="L180" class="LineNr">180 </span>    55/push-ebp
<span id="L181" class="LineNr">181 </span>    89/copy                         3/mod/direct    5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          4/r32/esp  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy esp to ebp</span>
<span id="L182" class="LineNr">182 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L183" class="LineNr">183 </span>    50/push-eax
<span id="L184" class="LineNr">184 </span>    <span class="subxComment"># eax = string-equal?(s, expected)</span>
<span id="L185" class="LineNr">185 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L186" class="LineNr">186 </span>    ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>          0xc/disp8      <span class="Normal"> . </span>                <span class="subxComment"># push *(ebp+12)</span>
<span id="L187" class="LineNr">187 </span>    ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>          8/disp8        <span class="Normal"> . </span>                <span class="subxComment"># push *(ebp+8)</span>
<span id="L188" class="LineNr">188 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L189" class="LineNr">189 </span>    e8/call  <a href='054string-equal.subx.html#L16'>string-equal?</a>/disp32
<span id="L190" class="LineNr">190 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L191" class="LineNr">191 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L192" class="LineNr">192 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L193" class="LineNr">193 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L194" class="LineNr">194 </span>    ff          6/subop/push        1/mod/*+disp8   5/rm32/ebp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>          0x10/disp8     <span class="Normal"> . </span>                <span class="subxComment"># push *(ebp+16)</span>
<span id="L195" class="LineNr">195 </span>    68/push  1/imm32
<span id="L196" class="LineNr">196 </span>    50/push-eax
<span id="L197" class="LineNr">197 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L198" class="LineNr">198 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L199" class="LineNr">199 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L200" class="LineNr">200 </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="L201" class="LineNr">201 </span><span class="Constant">$check-string-equal:end</span>:
<span id="L202" class="LineNr">202 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L203" class="LineNr">203 </span>    58/pop-to-eax
<span id="L204" class="LineNr">204 </span>    <span class="subxS1Comment"># . epilog</span>
<span id="L205" class="LineNr">205 </span>    89/copy                         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          5/r32/ebp  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy ebp to esp</span>
<span id="L206" class="LineNr">206 </span>    5d/pop-to-ebp
<span id="L207" class="LineNr">207 </span>    c3/return
<span id="L208" class="LineNr">208 </span>
<span id="L209" class="LineNr">209 </span><span class="subxComment"># test the helper</span>
<span id="L210" class="LineNr">210 </span><span class="subxTest">test-check-string-equal</span>:
<span id="L211" class="LineNr">211 </span>    <span class="subxComment"># check-string-equal?(&quot;Abc&quot;, &quot;Abc&quot;)</span>
<span id="L212" class="LineNr">212 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L213" class="LineNr">213 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L214" class="LineNr">214 </span>    68/push  <span class="Constant">&quot;Abc&quot;</span>/imm32
<span id="L215" class="LineNr">215 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L216" class="LineNr">216 </span>    e8/call  <a href='054string-equal.subx.html#L178'>check-string-equal</a>/disp32
<span id="L217" class="LineNr">217 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L218" class="LineNr">218 </span>    81          0/subop/add         3/mod/direct    4/rm32/esp   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              8/imm32           <span class="subxComment"># add to esp</span>
<span id="L219" class="LineNr">219 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L220" class="LineNr">220 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L221" class="LineNr">221 </span>    68/push  <span class="Constant">&quot;F - test-check-string-equal&quot;</span>/imm32
<span id="L222" class="LineNr">222 </span>    68/push  0/imm32/false
<span id="L223" class="LineNr">223 </span>    50/push-eax
<span id="L224" class="LineNr">224 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L225" class="LineNr">225 </span>    e8/call  <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L226" class="LineNr">226 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L227" class="LineNr">227 </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="L228" class="LineNr">228 </span>    c3/return
<span id="L229" class="LineNr">229 </span>
<span id="L230" class="LineNr">230 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->