summary refs log tree commit diff stats
path: root/doc/pydoc/ranger.gui.widgets.titlebar.html
blob: 8823b03a7a9542685600fc4f905cb3d467ccf554 (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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html><head><title>Python: module ranger.gui.widgets.titlebar</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head><body bgcolor="#f0f0f8">

<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="heading">
<tr bgcolor="#7799ee">
<td valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial">&nbsp;<br><big><big><strong><a href="ranger.html"><font color="#ffffff">ranger</font></a>.<a href="ranger.gui.html"><font color="#ffffff">gui</font></a>.<a href="ranger.gui.widgets.html"><font color="#ffffff">widgets</font></a>.titlebar</strong></big></big></font></td
><td align=right valign=bottom
><font color="#ffffff" face="helvetica, arial"><a href=".">index</a><br><a href="file:/home/hut/code/ranger/ranger/gui/widgets/titlebar.py">/home/hut/code/ranger/ranger/gui/widgets/titlebar.py</a></font></td></tr></table>
    <p><tt>The&nbsp;titlebar&nbsp;is&nbsp;the&nbsp;widget&nbsp;at&nbsp;the&nbsp;top,&nbsp;giving&nbsp;you&nbsp;broad&nbsp;orientation.<br>
&nbsp;<br>
It&nbsp;displays&nbsp;the&nbsp;current&nbsp;path&nbsp;among&nbsp;other&nbsp;things.</tt></p>
<p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ee77aa">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#ffffff" face="helvetica, arial"><big><strong>Classes</strong></big></font></td></tr>
    
<tr><td bgcolor="#ee77aa"><tt>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><dl>
<dt><font face="helvetica, arial"><a href="ranger.gui.widgets.html#Widget">ranger.gui.widgets.Widget</a>(<a href="ranger.gui.displayable.html#Displayable">ranger.gui.displayable.Displayable</a>)
</font></dt><dd>
<dl>
<dt><font face="helvetica, arial"><a href="ranger.gui.widgets.titlebar.html#TitleBar">TitleBar</a>
</font></dt></dl>
</dd>
</dl>
 <p>
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
<tr bgcolor="#ffc8d8">
<td colspan=3 valign=bottom>&nbsp;<br>
<font color="#000000" face="helvetica, arial"><a name="TitleBar">class <strong>TitleBar</strong></a>(<a href="ranger.gui.widgets.html#Widget">ranger.gui.widgets.Widget</a>)</font></td></tr>
    
<tr><td bgcolor="#ffc8d8"><tt>&nbsp;&nbsp;&nbsp;</tt></td><td>&nbsp;</td>
<td width="100%"><dl><dt>Method resolution order:</dt>
<dd><a href="ranger.gui.widgets.titlebar.html#TitleBar">TitleBar</a></dd>
<dd><a href="ranger.gui.widgets.html#Widget">ranger.gui.widgets.Widget</a></dd>
<dd><a href="ranger.gui.displayable.html#Displayable">ranger.gui.displayable.Displayable</a></dd>
<dd><a href="ranger.shared.html#EnvironmentAware">ranger.shared.EnvironmentAware</a></dd>
<dd><a href="ranger.shared.html#FileManagerAware">ranger.shared.FileManagerAware</a></dd>
<dd><a href="ranger.shared.html#Awareness">ranger.shared.Awareness</a></dd>
<dd><a href="ranger.gui.curses_shortcuts.html#CursesShortcuts">ranger.gui.curses_shortcuts.CursesShortcuts</a></dd>
<dd><a href="ranger.shared.settings.html#SettingsAware">ranger.shared.settings.SettingsAware</a></dd>
<dd><a href="builtins.html#object">builtins.object</a></dd>
</dl>
<hr>
Methods defined here:<br>
<dl><dt><a name="TitleBar-__init__"><strong>__init__</strong></a>(self, *args, **keywords)</dt></dl>

<dl><dt><a name="TitleBar-click"><strong>click</strong></a>(self, event)</dt><dd><tt>Handle&nbsp;a&nbsp;MouseEvent</tt></dd></dl>

<dl><dt><a name="TitleBar-draw"><strong>draw</strong></a>(self)</dt></dl>

<dl><dt><a name="TitleBar-request_redraw"><strong>request_redraw</strong></a>(self)</dt></dl>

<hr>
Data and other attributes defined here:<br>
<dl><dt><strong>need_redraw</strong> = False</dl>

<dl><dt><strong>old_cf</strong> = None</dl>

<dl><dt><strong>old_keybuffer</strong> = None</dl>

<dl><dt><strong>old_wid</strong> = None</dl>

<dl><dt><strong>result</strong> = None</dl>

<dl><dt><strong>tab_width</strong> = 0</dl>

<dl><dt><strong>throbber</strong> = ' '</dl>

<hr>
Methods inherited from <a href="ranger.gui.displayable.html#Displayable">ranger.gui.displayable.Displayable</a>:<br>
<dl><dt><a name="TitleBar-__bool__"><strong>__bool__</strong></a> = __nonzero__(self)</dt><dd><tt>Always&nbsp;True</tt></dd></dl>

<dl><dt><a name="TitleBar-__contains__"><strong>__contains__</strong></a>(self, item)</dt><dd><tt>Is&nbsp;item&nbsp;inside&nbsp;the&nbsp;boundaries?<br>
item&nbsp;can&nbsp;be&nbsp;an&nbsp;iterable&nbsp;like&nbsp;[y,&nbsp;x]&nbsp;or&nbsp;an&nbsp;object&nbsp;with&nbsp;x&nbsp;and&nbsp;y&nbsp;methods.</tt></dd></dl>

<dl><dt><a name="TitleBar-__nonzero__"><strong>__nonzero__</strong></a>(self)</dt><dd><tt>Always&nbsp;True</tt></dd></dl>

<dl><dt><a name="TitleBar-__str__"><strong>__str__</strong></a>(self)</dt></dl>

<dl><dt><a name="TitleBar-contains_point"><strong>contains_point</strong></a>(self, y, x)</dt><dd><tt>Test&nbsp;whether&nbsp;the&nbsp;point&nbsp;(with&nbsp;absolute&nbsp;coordinates)&nbsp;lies<br>
within&nbsp;the&nbsp;boundaries&nbsp;of&nbsp;this&nbsp;object.</tt></dd></dl>

<dl><dt><a name="TitleBar-destroy"><strong>destroy</strong></a>(self)</dt><dd><tt>Called&nbsp;when&nbsp;the&nbsp;object&nbsp;is&nbsp;destroyed.<br>
Override&nbsp;this!</tt></dd></dl>

<dl><dt><a name="TitleBar-finalize"><strong>finalize</strong></a>(self)</dt><dd><tt>Called&nbsp;after&nbsp;every&nbsp;displayable&nbsp;is&nbsp;done&nbsp;drawing.<br>
Override&nbsp;this!</tt></dd></dl>

<dl><dt><a name="TitleBar-poke"><strong>poke</strong></a>(self)</dt><dd><tt>Called&nbsp;before&nbsp;drawing,&nbsp;even&nbsp;if&nbsp;invisible</tt></dd></dl>

<dl><dt><a name="TitleBar-press"><strong>press</strong></a>(self, key)</dt><dd><tt>Called&nbsp;when&nbsp;a&nbsp;key&nbsp;is&nbsp;pressed&nbsp;and&nbsp;self.<strong>focused</strong>&nbsp;is&nbsp;True.<br>
Override&nbsp;this!</tt></dd></dl>

<dl><dt><a name="TitleBar-resize"><strong>resize</strong></a>(self, y, x, hei<font color="#909090">=None</font>, wid<font color="#909090">=None</font>)</dt><dd><tt>Resize&nbsp;the&nbsp;widget</tt></dd></dl>

<hr>
Data and other attributes inherited from <a href="ranger.shared.html#EnvironmentAware">ranger.shared.EnvironmentAware</a>:<br>
<dl><dt><strong>env</strong> = None</dl>

<hr>
Data and other attributes inherited from <a href="ranger.shared.html#FileManagerAware">ranger.shared.FileManagerAware</a>:<br>
<dl><dt><strong>fm</strong> = None</dl>

<hr>
Data descriptors inherited from <a href="ranger.shared.html#Awareness">ranger.shared.Awareness</a>:<br>
<dl><dt><strong>__dict__</strong></dt>
<dd><tt>dictionary&nbsp;for&nbsp;instance&nbsp;variables&nbsp;(if&nbsp;defined)</tt></dd>
</dl>
<dl><dt><strong>__weakref__</strong></dt>
<dd><tt>list&nbsp;of&nbsp;weak&nbsp;references&nbsp;to&nbsp;the&nbsp;object&nbsp;(if&nbsp;defined)</tt></dd>
</dl>
<hr>
Methods inherited from <a href="ranger.gui.curses_shortcuts.html#CursesShortcuts">ranger.gui.curses_shortcuts.CursesShortcuts</a>:<br>
<dl><dt><a name="TitleBar-addch"><strong>addch</strong></a>(self, *args)</dt></dl>

<dl><dt><a name="TitleBar-addnstr"><strong>addnstr</strong></a>(self, *args)</dt></dl>

<dl><dt><a name="TitleBar-addstr"><strong>addstr</strong></a>(self, *args)</dt></dl>

<dl><dt><a name="TitleBar-color"><strong>color</strong></a>(self, *keys)</dt><dd><tt>Change&nbsp;the&nbsp;colors&nbsp;from&nbsp;now&nbsp;on.</tt></dd></dl>

<dl><dt><a name="TitleBar-color_at"><strong>color_at</strong></a>(self, y, x, wid, *keys)</dt><dd><tt>Change&nbsp;the&nbsp;colors&nbsp;at&nbsp;the&nbsp;specified&nbsp;position</tt></dd></dl>

<dl><dt><a name="TitleBar-color_reset"><strong>color_reset</strong></a>(self)</dt><dd><tt>Change&nbsp;the&nbsp;colors&nbsp;to&nbsp;the&nbsp;default&nbsp;colors</tt></dd></dl>

<hr>
Data and other attributes inherited from <a href="ranger.shared.settings.html#SettingsAware">ranger.shared.settings.SettingsAware</a>:<br>
<dl><dt><strong>settings</strong> = {}</dl>

</td></tr></table></td></tr></table>
</body></html>
ref='#n533'>533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663































































                                                                                                                                           
                                                                                                                                                                                       

































                                                                                                                       
                                                                                                                



                                                                                                                      
                                                                                    
                                                                                                                       
                                                                        
                                                                                                                       
                                                                        
                                                                                                  
                                                                  

                                                                                                 


                                                                                                             
                                                                                      
                                                                                                          
                                                                    
                                                                                                          


                                                                                                              
                                                                                    



























                                                                                                           
                                                                                                       

                                                                    
                                                                                                       



























                                                                                                                                                                                          
                                                                                                           


                                                                     
                                                                                                          



























                                                                                                                                                 
                                                                                                                 




                                                                     
                                                                                                                 






























                                                                                                                                   
                                                                                                                 




                                                                     
                                                                                                                 


























                                                                                                                                                   
                                                                                                                                                                                                                            











                                                                                                                                            
                                                                                                                     





                                                                                                                                                                
                                                                                                                           














                                                                                                                    
                                                                                                                       
                                                                                
                                                                                                                                         



                                                                                                       
                                                                                                      



                                                                                                          
                                                                                                    













                                                                                                                                       
                                                                                                    















                                                                                                                                           
                                                                                                                                          














                                                                                                               
                                                                                                                       



                                                                                
                                                                                                                           



                                                                                                                     
                                                                                                 













                                                                                                                                                          
                                                                                                 











                                                                                                                                                            

                                                                                                                          


                                                                                                
                                                                                                                               






























                                                                                                                
                                                                                                                 




























































































                                                                                                                                         
                                                                                                                 




































                                                                                                                                                   
                                                                                                                                                                                                   




                                                                                                   
                                                                                                                                                    






































                                                                                                                                         
                                                                                                                 























                                                                                                                                           
<!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 - 100array-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; }
.subxS2Comment { color: #8a8a8a; }
.LineNr { }
.SpecialChar { color: #d70000; }
.subxS1Comment { color: #0000af; }
.subxFunction { color: #af5f00; text-decoration: underline; }
.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/100array-equal.subx'>https://github.com/akkartik/mu/blob/master/100array-equal.subx</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="subxComment"># Comparing arrays of numbers.</span>
<span id="L2" class="LineNr">  2 </span>
<span id="L3" class="LineNr">  3 </span>== code
<span id="L4" class="LineNr">  4 </span>
<span id="L5" class="LineNr">  5 </span><span class="subxFunction">array-equal?</span>:  <span class="subxComment"># a: (addr array int), b: (addr array int) -&gt; eax: boolean</span>
<span id="L6" class="LineNr">  6 </span>    <span class="subxComment"># pseudocode:</span>
<span id="L7" class="LineNr">  7 </span>    <span class="subxComment">#   lena = a-&gt;length</span>
<span id="L8" class="LineNr">  8 </span>    <span class="subxComment">#   if (lena != b-&gt;length) return false</span>
<span id="L9" class="LineNr">  9 </span>    <span class="subxComment">#   i = 0</span>
<span id="L10" class="LineNr"> 10 </span>    <span class="subxComment">#   curra = a-&gt;data</span>
<span id="L11" class="LineNr"> 11 </span>    <span class="subxComment">#   currb = b-&gt;data</span>
<span id="L12" class="LineNr"> 12 </span>    <span class="subxComment">#   while i &lt; lena</span>
<span id="L13" class="LineNr"> 13 </span>    <span class="subxComment">#     i1 = *curra</span>
<span id="L14" class="LineNr"> 14 </span>    <span class="subxComment">#     i2 = *currb</span>
<span id="L15" class="LineNr"> 15 </span>    <span class="subxComment">#     if (c1 != c2) return false</span>
<span id="L16" class="LineNr"> 16 </span>    <span class="subxComment">#     i+=4, curra+=4, currb+=4</span>
<span id="L17" class="LineNr"> 17 </span>    <span class="subxComment">#   return true</span>
<span id="L18" class="LineNr"> 18 </span>    <span class="subxComment">#</span>
<span id="L19" class="LineNr"> 19 </span>    <span class="subxComment"># registers:</span>
<span id="L20" class="LineNr"> 20 </span>    <span class="subxComment">#   i: ecx</span>
<span id="L21" class="LineNr"> 21 </span>    <span class="subxComment">#   lena: edx</span>
<span id="L22" class="LineNr"> 22 </span>    <span class="subxComment">#   curra: esi</span>
<span id="L23" class="LineNr"> 23 </span>    <span class="subxComment">#   currb: edi</span>
<span id="L24" class="LineNr"> 24 </span>    <span class="subxComment">#   i1: eax</span>
<span id="L25" class="LineNr"> 25 </span>    <span class="subxComment">#   i2: ebx</span>
<span id="L26" class="LineNr"> 26 </span>    <span class="subxComment">#</span>
<span id="L27" class="LineNr"> 27 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L28" class="LineNr"> 28 </span>    55/push-ebp
<span id="L29" class="LineNr"> 29 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L30" class="LineNr"> 30 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L31" class="LineNr"> 31 </span>    51/push-ecx
<span id="L32" class="LineNr"> 32 </span>    52/push-edx
<span id="L33" class="LineNr"> 33 </span>    53/push-ebx
<span id="L34" class="LineNr"> 34 </span>    56/push-esi
<span id="L35" class="LineNr"> 35 </span>    57/push-edi
<span id="L36" class="LineNr"> 36 </span>    <span class="subxComment"># esi = a</span>
<span id="L37" class="LineNr"> 37 </span>    8b/-&gt; *(ebp+8) 6/r32/esi
<span id="L38" class="LineNr"> 38 </span>    <span class="subxComment"># edi = b</span>
<span id="L39" class="LineNr"> 39 </span>    8b/-&gt; *(ebp+0xc) 7/r32/edi
<span id="L40" class="LineNr"> 40 </span>    <span class="subxComment"># var lena/edx: int = a-&gt;length</span>
<span id="L41" class="LineNr"> 41 </span>    8b/-&gt; *esi 2/r32/edx
<span id="L42" class="LineNr"> 42 </span><span class="Constant">$array-equal?:lengths</span>:
<span id="L43" class="LineNr"> 43 </span>    <span class="subxComment"># if (lena != b-&gt;length) return false</span>
<span id="L44" class="LineNr"> 44 </span>    39/compare *edi 2/r32/edx
<span id="L45" class="LineNr"> 45 </span>    75/jump-if-!= $array-equal?:false/disp8
<span id="L46" class="LineNr"> 46 </span>    <span class="subxComment"># var curra/esi: (addr byte) = a-&gt;data</span>
<span id="L47" class="LineNr"> 47 </span>    81 0/subop/add %esi 4/imm32
<span id="L48" class="LineNr"> 48 </span>    <span class="subxComment"># var currb/edi: (addr byte) = b-&gt;data</span>
<span id="L49" class="LineNr"> 49 </span>    81 0/subop/add %edi 4/imm32
<span id="L50" class="LineNr"> 50 </span>    <span class="subxComment"># var i/ecx: int = 0</span>
<span id="L51" class="LineNr"> 51 </span>    31/xor %ecx 1/r32/ecx
<span id="L52" class="LineNr"> 52 </span>    <span class="subxComment"># var vala/eax: int</span>
<span id="L53" class="LineNr"> 53 </span>    <span class="subxComment"># var valb/ebx: int</span>
<span id="L54" class="LineNr"> 54 </span><span class="Constant">$array-equal?:loop</span>:
<span id="L55" class="LineNr"> 55 </span>    <span class="subxComment"># if (i &gt;= lena) return true</span>
<span id="L56" class="LineNr"> 56 </span>    39/compare %ecx 2/r32/edx
<span id="L57" class="LineNr"> 57 </span>    7d/jump-if-&gt;= $array-equal?:true/disp8
<span id="L58" class="LineNr"> 58 </span>    <span class="subxComment"># var vala/eax: int = *curra</span>
<span id="L59" class="LineNr"> 59 </span>    8b/-&gt; *esi 0/r32/eax
<span id="L60" class="LineNr"> 60 </span>    <span class="subxComment"># var valb/ebx: int = *currb</span>
<span id="L61" class="LineNr"> 61 </span>    8b/-&gt; *edi 3/r32/ebx
<span id="L62" class="LineNr"> 62 </span>    <span class="subxComment"># if (vala != valb) return false</span>
<span id="L63" class="LineNr"> 63 </span>    39/compare %eax 3/r32/ebx
<span id="L64" class="LineNr"> 64 </span>    75/jump-if-!= $array-equal?:false/disp8
<span id="L65" class="LineNr"> 65 </span>    <span class="subxComment"># i += 4</span>
<span id="L66" class="LineNr"> 66 </span>    81 0/subop/add %ecx 4/imm32
<span id="L67" class="LineNr"> 67 </span>    <span class="subxComment"># currs += 4</span>
<span id="L68" class="LineNr"> 68 </span>    81 0/subop/add %esi 4/imm32
<span id="L69" class="LineNr"> 69 </span>    <span class="subxComment"># currb += 4</span>
<span id="L70" class="LineNr"> 70 </span>    81 0/subop/add %edi 4/imm32
<span id="L71" class="LineNr"> 71 </span>    eb/jump $array-equal?:<span class="Constant">loop</span>/disp8
<span id="L72" class="LineNr"> 72 </span><span class="Constant">$array-equal?:true</span>:
<span id="L73" class="LineNr"> 73 </span>    b8/copy-to-eax 1/imm32
<span id="L74" class="LineNr"> 74 </span>    eb/jump $array-equal?:end/disp8
<span id="L75" class="LineNr"> 75 </span><span class="Constant">$array-equal?:false</span>:
<span id="L76" class="LineNr"> 76 </span>    b8/copy-to-eax 0/imm32
<span id="L77" class="LineNr"> 77 </span><span class="Constant">$array-equal?:end</span>:
<span id="L78" class="LineNr"> 78 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L79" class="LineNr"> 79 </span>    5f/pop-to-edi
<span id="L80" class="LineNr"> 80 </span>    5e/pop-to-esi
<span id="L81" class="LineNr"> 81 </span>    5b/pop-to-ebx
<span id="L82" class="LineNr"> 82 </span>    5a/pop-to-edx
<span id="L83" class="LineNr"> 83 </span>    59/pop-to-ecx
<span id="L84" class="LineNr"> 84 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L85" class="LineNr"> 85 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L86" class="LineNr"> 86 </span>    5d/pop-to-ebp
<span id="L87" class="LineNr"> 87 </span>    c3/return
<span id="L88" class="LineNr"> 88 </span>
<span id="L89" class="LineNr"> 89 </span><span class="subxTest">test-compare-empty-with-empty-array</span>:
<span id="L90" class="LineNr"> 90 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L91" class="LineNr"> 91 </span>    55/push-ebp
<span id="L92" class="LineNr"> 92 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L93" class="LineNr"> 93 </span>    <span class="subxComment"># var ecx: (array _) = []</span>
<span id="L94" class="LineNr"> 94 </span>    68/push 0/imm32/size
<span id="L95" class="LineNr"> 95 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L96" class="LineNr"> 96 </span>    <span class="subxComment"># var edx: (array _) = []</span>
<span id="L97" class="LineNr"> 97 </span>    68/push 0/imm32/size
<span id="L98" class="LineNr"> 98 </span>    89/&lt;- %edx 4/r32/esp
<span id="L99" class="LineNr"> 99 </span>    <span class="subxComment"># eax = array-equal?(ecx, edx)</span>
<span id="L100" class="LineNr">100 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L101" class="LineNr">101 </span>    52/push-edx
<span id="L102" class="LineNr">102 </span>    51/push-ecx
<span id="L103" class="LineNr">103 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L104" class="LineNr">104 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L105" class="LineNr">105 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L106" class="LineNr">106 </span>    81 0/subop/add %esp 8/imm32
<span id="L107" class="LineNr">107 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L108" class="LineNr">108 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L109" class="LineNr">109 </span>    68/push <span class="Constant">&quot;F - test-compare-empty-with-empty-array&quot;</span>/imm32
<span id="L110" class="LineNr">110 </span>    68/push 1/imm32/true
<span id="L111" class="LineNr">111 </span>    50/push-eax
<span id="L112" class="LineNr">112 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L113" class="LineNr">113 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L114" class="LineNr">114 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L115" class="LineNr">115 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L116" class="LineNr">116 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L117" class="LineNr">117 </span>    89/&lt;- %esp 5/r32/ebp
<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">test-compare-empty-with-non-empty-array</span>:  <span class="subxComment"># also checks length-mismatch code path</span>
<span id="L122" class="LineNr">122 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L123" class="LineNr">123 </span>    55/push-ebp
<span id="L124" class="LineNr">124 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L125" class="LineNr">125 </span>    <span class="subxComment"># var ecx: (array int) = [1]</span>
<span id="L126" class="LineNr">126 </span>    68/push 1/imm32
<span id="L127" class="LineNr">127 </span>    68/push 4/imm32/size
<span id="L128" class="LineNr">128 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L129" class="LineNr">129 </span>    <span class="subxComment"># var edx: (array int) = []</span>
<span id="L130" class="LineNr">130 </span>    68/push 0/imm32/size
<span id="L131" class="LineNr">131 </span>    89/&lt;- %edx 4/r32/esp
<span id="L132" class="LineNr">132 </span>    <span class="subxComment"># eax = array-equal?(ecx, edx)</span>
<span id="L133" class="LineNr">133 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L134" class="LineNr">134 </span>    52/push-edx
<span id="L135" class="LineNr">135 </span>    51/push-ecx
<span id="L136" class="LineNr">136 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L137" class="LineNr">137 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L138" class="LineNr">138 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L139" class="LineNr">139 </span>    81 0/subop/add %esp 8/imm32
<span id="L140" class="LineNr">140 </span>    <span class="subxComment"># check-ints-equal(eax, 0, msg)</span>
<span id="L141" class="LineNr">141 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L142" class="LineNr">142 </span>    68/push <span class="Constant">&quot;F - test-compare-empty-with-non-empty-array&quot;</span>/imm32
<span id="L143" class="LineNr">143 </span>    68/push 0/imm32/false
<span id="L144" class="LineNr">144 </span>    50/push-eax
<span id="L145" class="LineNr">145 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L146" class="LineNr">146 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L147" class="LineNr">147 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L148" class="LineNr">148 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L149" class="LineNr">149 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L150" class="LineNr">150 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L151" class="LineNr">151 </span>    5d/pop-to-ebp
<span id="L152" class="LineNr">152 </span>    c3/return
<span id="L153" class="LineNr">153 </span>
<span id="L154" class="LineNr">154 </span><span class="subxTest">test-compare-equal-arrays</span>:
<span id="L155" class="LineNr">155 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L156" class="LineNr">156 </span>    55/push-ebp
<span id="L157" class="LineNr">157 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L158" class="LineNr">158 </span>    <span class="subxComment"># var ecx: (array int) = [1, 2, 3]</span>
<span id="L159" class="LineNr">159 </span>    68/push 3/imm32
<span id="L160" class="LineNr">160 </span>    68/push 2/imm32
<span id="L161" class="LineNr">161 </span>    68/push 1/imm32
<span id="L162" class="LineNr">162 </span>    68/push 0xc/imm32/size
<span id="L163" class="LineNr">163 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L164" class="LineNr">164 </span>    <span class="subxComment"># var edx: (array int) = [1, 2, 3]</span>
<span id="L165" class="LineNr">165 </span>    68/push 3/imm32
<span id="L166" class="LineNr">166 </span>    68/push 2/imm32
<span id="L167" class="LineNr">167 </span>    68/push 1/imm32
<span id="L168" class="LineNr">168 </span>    68/push 0xc/imm32/size
<span id="L169" class="LineNr">169 </span>    89/&lt;- %edx 4/r32/esp
<span id="L170" class="LineNr">170 </span>    <span class="subxComment"># eax = array-equal?(ecx, edx)</span>
<span id="L171" class="LineNr">171 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L172" class="LineNr">172 </span>    52/push-edx
<span id="L173" class="LineNr">173 </span>    51/push-ecx
<span id="L174" class="LineNr">174 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L175" class="LineNr">175 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L176" class="LineNr">176 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L177" class="LineNr">177 </span>    81 0/subop/add %esp 8/imm32
<span id="L178" class="LineNr">178 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L179" class="LineNr">179 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L180" class="LineNr">180 </span>    68/push <span class="Constant">&quot;F - test-compare-equal-arrays&quot;</span>/imm32
<span id="L181" class="LineNr">181 </span>    68/push 1/imm32/true
<span id="L182" class="LineNr">182 </span>    50/push-eax
<span id="L183" class="LineNr">183 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L184" class="LineNr">184 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L185" class="LineNr">185 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L186" class="LineNr">186 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L187" class="LineNr">187 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L188" class="LineNr">188 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L189" class="LineNr">189 </span>    5d/pop-to-ebp
<span id="L190" class="LineNr">190 </span>    c3/return
<span id="L191" class="LineNr">191 </span>
<span id="L192" class="LineNr">192 </span><span class="subxTest">test-compare-inequal-arrays-equal-lengths</span>:
<span id="L193" class="LineNr">193 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L194" class="LineNr">194 </span>    55/push-ebp
<span id="L195" class="LineNr">195 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L196" class="LineNr">196 </span>    <span class="subxComment"># var ecx: (array int) = [1, 4, 3]</span>
<span id="L197" class="LineNr">197 </span>    68/push 3/imm32
<span id="L198" class="LineNr">198 </span>    68/push 4/imm32
<span id="L199" class="LineNr">199 </span>    68/push 1/imm32
<span id="L200" class="LineNr">200 </span>    68/push 0xc/imm32/size
<span id="L201" class="LineNr">201 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L202" class="LineNr">202 </span>    <span class="subxComment"># var edx: (array int) = [1, 2, 3]</span>
<span id="L203" class="LineNr">203 </span>    68/push 3/imm32
<span id="L204" class="LineNr">204 </span>    68/push 2/imm32
<span id="L205" class="LineNr">205 </span>    68/push 1/imm32
<span id="L206" class="LineNr">206 </span>    68/push 0xc/imm32/size
<span id="L207" class="LineNr">207 </span>    89/&lt;- %edx 4/r32/esp
<span id="L208" class="LineNr">208 </span>    <span class="subxComment"># eax = array-equal?(ecx, edx)</span>
<span id="L209" class="LineNr">209 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L210" class="LineNr">210 </span>    52/push-edx
<span id="L211" class="LineNr">211 </span>    51/push-ecx
<span id="L212" class="LineNr">212 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L213" class="LineNr">213 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L214" class="LineNr">214 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L215" class="LineNr">215 </span>    81 0/subop/add %esp 8/imm32
<span id="L216" class="LineNr">216 </span>    <span class="subxComment"># check-ints-equal(eax, 0, msg)</span>
<span id="L217" class="LineNr">217 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L218" class="LineNr">218 </span>    68/push <span class="Constant">&quot;F - test-compare-inequal-arrays-equal-lengths&quot;</span>/imm32
<span id="L219" class="LineNr">219 </span>    68/push 0/imm32/false
<span id="L220" class="LineNr">220 </span>    50/push-eax
<span id="L221" class="LineNr">221 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L222" class="LineNr">222 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L223" class="LineNr">223 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L224" class="LineNr">224 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L225" class="LineNr">225 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L226" class="LineNr">226 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L227" class="LineNr">227 </span>    5d/pop-to-ebp
<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="subxFunction">parse-array-of-ints</span>:  <span class="subxComment"># ad: (addr allocation-descriptor), s: (addr string) -&gt; result/eax: (handle array int)</span>
<span id="L231" class="LineNr">231 </span>    <span class="subxComment"># pseudocode</span>
<span id="L232" class="LineNr">232 </span>    <span class="subxComment">#   end = &amp;s-&gt;data[s-&gt;length]</span>
<span id="L233" class="LineNr">233 </span>    <span class="subxComment">#   curr = s-&gt;data</span>
<span id="L234" class="LineNr">234 </span>    <span class="subxComment">#   size = 0</span>
<span id="L235" class="LineNr">235 </span>    <span class="subxComment">#   while true</span>
<span id="L236" class="LineNr">236 </span>    <span class="subxComment">#     if (curr &gt;= end) break</span>
<span id="L237" class="LineNr">237 </span>    <span class="subxComment">#     curr = skip-chars-matching-in-slice(curr, end, ' ')</span>
<span id="L238" class="LineNr">238 </span>    <span class="subxComment">#     if (curr &gt;= end) break</span>
<span id="L239" class="LineNr">239 </span>    <span class="subxComment">#     curr = skip-chars-not-matching-in-slice(curr, end, ' ')</span>
<span id="L240" class="LineNr">240 </span>    <span class="subxComment">#     ++size</span>
<span id="L241" class="LineNr">241 </span>    <span class="subxComment">#   result = allocate(ad, (size+1)*4)</span>
<span id="L242" class="LineNr">242 </span>    <span class="subxComment">#   result-&gt;size = (size+1)*4</span>
<span id="L243" class="LineNr">243 </span>    <span class="subxComment">#   var slice: slice = {s-&gt;data, 0}</span>
<span id="L244" class="LineNr">244 </span>    <span class="subxComment">#   out = result-&gt;data</span>
<span id="L245" class="LineNr">245 </span>    <span class="subxComment">#   while true</span>
<span id="L246" class="LineNr">246 </span>    <span class="subxComment">#     if (slice-&gt;start &gt;= end) break</span>
<span id="L247" class="LineNr">247 </span>    <span class="subxComment">#     slice-&gt;start = skip-chars-matching-in-slice(slice-&gt;start, end, ' ')</span>
<span id="L248" class="LineNr">248 </span>    <span class="subxComment">#     if (slice-&gt;start &gt;= end) break</span>
<span id="L249" class="LineNr">249 </span>    <span class="subxComment">#     slice-&gt;end = skip-chars-not-matching-in-slice(slice-&gt;start, end, ' ')</span>
<span id="L250" class="LineNr">250 </span>    <span class="subxComment">#     *out = parse-hex-int-from-slice(slice)</span>
<span id="L251" class="LineNr">251 </span>    <span class="subxComment">#     out += 4</span>
<span id="L252" class="LineNr">252 </span>    <span class="subxComment">#     slice-&gt;start = slice-&gt;end</span>
<span id="L253" class="LineNr">253 </span>    <span class="subxComment">#   return result</span>
<span id="L254" class="LineNr">254 </span>    <span class="subxComment">#</span>
<span id="L255" class="LineNr">255 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L256" class="LineNr">256 </span>    55/push-ebp
<span id="L257" class="LineNr">257 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L258" class="LineNr">258 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L259" class="LineNr">259 </span>    51/push-ecx
<span id="L260" class="LineNr">260 </span>    52/push-edx
<span id="L261" class="LineNr">261 </span>    53/push-ebx
<span id="L262" class="LineNr">262 </span>    56/push-esi
<span id="L263" class="LineNr">263 </span>    57/push-edi
<span id="L264" class="LineNr">264 </span>    <span class="subxComment"># esi = s</span>
<span id="L265" class="LineNr">265 </span>    8b/-&gt; *(ebp+0xc) 6/r32/esi
<span id="L266" class="LineNr">266 </span>    <span class="subxComment"># var curr/ecx: (addr byte) = s-&gt;data</span>
<span id="L267" class="LineNr">267 </span>    8d/copy-address *(esi+4) 1/r32/ecx
<span id="L268" class="LineNr">268 </span>    <span class="subxComment"># var end/edx: (addr byte) = &amp;s-&gt;data[s-&gt;length]</span>
<span id="L269" class="LineNr">269 </span>    <span class="subxS1Comment"># . edx = s-&gt;length</span>
<span id="L270" class="LineNr">270 </span>    8b/-&gt; *esi 2/r32/edx
<span id="L271" class="LineNr">271 </span>    <span class="subxS1Comment"># . edx += curr</span>
<span id="L272" class="LineNr">272 </span>    01/add %edx 1/r32/ecx
<span id="L273" class="LineNr">273 </span>    <span class="subxComment"># var size/ebx: int = 0</span>
<span id="L274" class="LineNr">274 </span>    31/xor %ebx 3/r32/ebx
<span id="L275" class="LineNr">275 </span><span class="Constant">$parse-array-of-ints:loop1</span>:
<span id="L276" class="LineNr">276 </span>    <span class="subxComment"># if (curr &gt;= end) break</span>
<span id="L277" class="LineNr">277 </span>    39/compare %ecx 2/r32/edx
<span id="L278" class="LineNr">278 </span>    73/jump-if-addr&gt;= $parse-array-of-ints:break1/disp8
<span id="L279" class="LineNr">279 </span>    <span class="subxComment"># curr = skip-chars-matching-in-slice(curr, end, ' ')</span>
<span id="L280" class="LineNr">280 </span>    <span class="subxS1Comment"># . eax = skip-chars-matching-in-slice(curr, end, ' ')</span>
<span id="L281" class="LineNr">281 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L282" class="LineNr">282 </span>    68/push 0x20/imm32/space
<span id="L283" class="LineNr">283 </span>    52/push-edx
<span id="L284" class="LineNr">284 </span>    51/push-ecx
<span id="L285" class="LineNr">285 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L286" class="LineNr">286 </span>    e8/call <a href='073next-token.subx.html#L804'>skip-chars-matching-in-slice</a>/disp32
<span id="L287" class="LineNr">287 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L288" class="LineNr">288 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L289" class="LineNr">289 </span>    <span class="subxS1Comment"># . ecx = eax</span>
<span id="L290" class="LineNr">290 </span>    89/&lt;- %ecx 0/r32/eax
<span id="L291" class="LineNr">291 </span>    <span class="subxComment"># if (curr &gt;= end) break</span>
<span id="L292" class="LineNr">292 </span>    39/compare %ecx 2/r32/edx
<span id="L293" class="LineNr">293 </span>    73/jump-if-addr&gt;= $parse-array-of-ints:break1/disp8
<span id="L294" class="LineNr">294 </span>    <span class="subxComment"># curr = skip-chars-not-matching-in-slice(curr, end, ' ')</span>
<span id="L295" class="LineNr">295 </span>    <span class="subxS1Comment"># . eax = skip-chars-not-matching-in-slice(curr, end, ' ')</span>
<span id="L296" class="LineNr">296 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L297" class="LineNr">297 </span>    68/push 0x20/imm32/space
<span id="L298" class="LineNr">298 </span>    52/push-edx
<span id="L299" class="LineNr">299 </span>    51/push-ecx
<span id="L300" class="LineNr">300 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L301" class="LineNr">301 </span>    e8/call <a href='073next-token.subx.html#L973'>skip-chars-not-matching-in-slice</a>/disp32
<span id="L302" class="LineNr">302 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L303" class="LineNr">303 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L304" class="LineNr">304 </span>    <span class="subxS1Comment"># . ecx = eax</span>
<span id="L305" class="LineNr">305 </span>    89/&lt;- %ecx 0/r32/eax
<span id="L306" class="LineNr">306 </span>    <span class="subxComment"># size += 4</span>
<span id="L307" class="LineNr">307 </span>    81 0/subop/add %ebx 4/imm32
<span id="L308" class="LineNr">308 </span>    eb/jump $parse-array-of-ints:loop1/disp8
<span id="L309" class="LineNr">309 </span><span class="Constant">$parse-array-of-ints:break1</span>:
<span id="L310" class="LineNr">310 </span>    <span class="subxComment"># var result/edi: (handle array int) = allocate(ad, size+4)</span>
<span id="L311" class="LineNr">311 </span>    <span class="subxS1Comment"># . eax = allocate(ad, size+4)</span>
<span id="L312" class="LineNr">312 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L313" class="LineNr">313 </span>    89/&lt;- %eax 3/r32/ebx
<span id="L314" class="LineNr">314 </span>    05/add-to-eax 4/imm32
<span id="L315" class="LineNr">315 </span>    50/push-eax
<span id="L316" class="LineNr">316 </span>    ff 6/subop/push *(ebp+8)
<span id="L317" class="LineNr">317 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L318" class="LineNr">318 </span>    e8/call <a href='069allocate.subx.html#L59'>allocate</a>/disp32
<span id="L319" class="LineNr">319 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L320" class="LineNr">320 </span>    81 0/subop/add %esp 8/imm32
<span id="L321" class="LineNr">321 </span>    <span class="subxS1Comment"># . edi = eax</span>
<span id="L322" class="LineNr">322 </span>    89/&lt;- %edi 0/r32/eax
<span id="L323" class="LineNr">323 </span>    <span class="subxComment"># result-&gt;size = size</span>
<span id="L324" class="LineNr">324 </span>    89/&lt;- *eax 3/r32/ebx
<span id="L325" class="LineNr">325 </span><span class="Constant">$parse-array-of-ints:pass2</span>:
<span id="L326" class="LineNr">326 </span>    <span class="subxComment"># var slice/ecx: slice = {s-&gt;data, 0}</span>
<span id="L327" class="LineNr">327 </span>    68/push 0/imm32/end
<span id="L328" class="LineNr">328 </span>    8d/copy-address *(esi+4) 1/r32/ecx
<span id="L329" class="LineNr">329 </span>    51/push-ecx
<span id="L330" class="LineNr">330 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L331" class="LineNr">331 </span>    <span class="subxComment"># var out/ebx: (addr byte) = result-&gt;data</span>
<span id="L332" class="LineNr">332 </span>    8d/copy-address *(eax+4) 3/r32/ebx
<span id="L333" class="LineNr">333 </span><span class="Constant">$parse-array-of-ints:loop2</span>:
<span id="L334" class="LineNr">334 </span>    <span class="subxComment"># if (slice-&gt;start &gt;= end) break</span>
<span id="L335" class="LineNr">335 </span>    39/compare *ecx 2/r32/edx
<span id="L336" class="LineNr">336 </span>    73/jump-if-addr&gt;= $parse-array-of-ints:end/disp8
<span id="L337" class="LineNr">337 </span>    <span class="subxComment"># slice-&gt;start = skip-chars-matching-in-slice(slice-&gt;start, end, ' ')</span>
<span id="L338" class="LineNr">338 </span>    <span class="subxS1Comment"># . eax = skip-chars-matching-in-slice(slice-&gt;start, end, ' ')</span>
<span id="L339" class="LineNr">339 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L340" class="LineNr">340 </span>    68/push 0x20/imm32/space
<span id="L341" class="LineNr">341 </span>    52/push-edx
<span id="L342" class="LineNr">342 </span>    ff 6/subop/push *ecx
<span id="L343" class="LineNr">343 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L344" class="LineNr">344 </span>    e8/call <a href='073next-token.subx.html#L804'>skip-chars-matching-in-slice</a>/disp32
<span id="L345" class="LineNr">345 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L346" class="LineNr">346 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L347" class="LineNr">347 </span>    <span class="subxS1Comment"># . slice-&gt;start = eax</span>
<span id="L348" class="LineNr">348 </span>    89/&lt;- *ecx 0/r32/eax
<span id="L349" class="LineNr">349 </span>    <span class="subxComment"># if (slice-&gt;start &gt;= end) break</span>
<span id="L350" class="LineNr">350 </span>    39/compare *ecx 2/r32/edx
<span id="L351" class="LineNr">351 </span>    73/jump-if-addr&gt;= $parse-array-of-ints:end/disp8
<span id="L352" class="LineNr">352 </span>    <span class="subxComment"># slice-&gt;end = skip-chars-not-matching-in-slice(slice-&gt;start, end, ' ')</span>
<span id="L353" class="LineNr">353 </span>    <span class="subxS1Comment"># . eax = skip-chars-not-matching-in-slice(curr, end, ' ')</span>
<span id="L354" class="LineNr">354 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L355" class="LineNr">355 </span>    68/push 0x20/imm32/space
<span id="L356" class="LineNr">356 </span>    52/push-edx
<span id="L357" class="LineNr">357 </span>    50/push-eax
<span id="L358" class="LineNr">358 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L359" class="LineNr">359 </span>    e8/call <a href='073next-token.subx.html#L973'>skip-chars-not-matching-in-slice</a>/disp32
<span id="L360" class="LineNr">360 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L361" class="LineNr">361 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L362" class="LineNr">362 </span>    <span class="subxS1Comment"># . slice-&gt;end = eax</span>
<span id="L363" class="LineNr">363 </span>    89/&lt;- *(ecx+4) 0/r32/eax
<span id="L364" class="LineNr">364 </span>    <span class="subxComment"># *out = parse-hex-int-from-slice(slice)</span>
<span id="L365" class="LineNr">365 </span>    <span class="subxS1Comment"># . eax = parse-hex-int-from-slice(slice)</span>
<span id="L366" class="LineNr">366 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L367" class="LineNr">367 </span>    51/push-ecx
<span id="L368" class="LineNr">368 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L369" class="LineNr">369 </span>    e8/call <a href='067parse-hex.subx.html#L387'>parse-hex-int-from-slice</a>/disp32
<span id="L370" class="LineNr">370 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L371" class="LineNr">371 </span>    81 0/subop/add %esp 4/imm32
<span id="L372" class="LineNr">372 </span>    <span class="subxS1Comment"># . *out = eax</span>
<span id="L373" class="LineNr">373 </span>    89/&lt;- *ebx 0/r32/eax
<span id="L374" class="LineNr">374 </span>    <span class="subxComment"># out += 4</span>
<span id="L375" class="LineNr">375 </span>    81 0/subop/add %ebx 4/imm32
<span id="L376" class="LineNr">376 </span>    <span class="subxComment"># slice-&gt;start = slice-&gt;end</span>
<span id="L377" class="LineNr">377 </span>    8b/-&gt; *(ecx+4) 0/r32/eax
<span id="L378" class="LineNr">378 </span>    89/&lt;- *ecx 0/r32/eax
<span id="L379" class="LineNr">379 </span>    81 0/subop/add %ecx 4/imm32
<span id="L380" class="LineNr">380 </span>    eb/jump $parse-array-of-ints:loop2/disp8
<span id="L381" class="LineNr">381 </span><span class="Constant">$parse-array-of-ints:end</span>:
<span id="L382" class="LineNr">382 </span>    <span class="subxComment"># return edi</span>
<span id="L383" class="LineNr">383 </span>    89/&lt;- %eax 7/r32/edi
<span id="L384" class="LineNr">384 </span>    <span class="subxS1Comment"># . reclaim locals</span>
<span id="L385" class="LineNr">385 </span>    81 0/subop/add %esp 8/imm32
<span id="L386" class="LineNr">386 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L387" class="LineNr">387 </span>    5f/pop-to-edi
<span id="L388" class="LineNr">388 </span>    5e/pop-to-esi
<span id="L389" class="LineNr">389 </span>    5b/pop-to-ebx
<span id="L390" class="LineNr">390 </span>    5a/pop-to-edx
<span id="L391" class="LineNr">391 </span>    59/pop-to-ecx
<span id="L392" class="LineNr">392 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L393" class="LineNr">393 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L394" class="LineNr">394 </span>    5d/pop-to-ebp
<span id="L395" class="LineNr">395 </span>    c3/return
<span id="L396" class="LineNr">396 </span>
<span id="L397" class="LineNr">397 </span><span class="subxTest">test-parse-array-of-ints</span>:
<span id="L398" class="LineNr">398 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L399" class="LineNr">399 </span>    55/push-ebp
<span id="L400" class="LineNr">400 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L401" class="LineNr">401 </span>    <span class="subxComment"># var ecx: (array int) = [1, 2, 3]</span>
<span id="L402" class="LineNr">402 </span>    68/push 3/imm32
<span id="L403" class="LineNr">403 </span>    68/push 2/imm32
<span id="L404" class="LineNr">404 </span>    68/push 1/imm32
<span id="L405" class="LineNr">405 </span>    68/push 0xc/imm32/size
<span id="L406" class="LineNr">406 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L407" class="LineNr">407 </span>    <span class="subxComment"># eax = parse-array-of-ints(Heap, &quot;1 2 3&quot;)</span>
<span id="L408" class="LineNr">408 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L409" class="LineNr">409 </span>    68/push <span class="Constant">&quot;1 2 3&quot;</span>/imm32
<span id="L410" class="LineNr">410 </span>    68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L411" class="LineNr">411 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L412" class="LineNr">412 </span>    e8/call <a href='100array-equal.subx.html#L230'>parse-array-of-ints</a>/disp32
<span id="L413" class="LineNr">413 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L414" class="LineNr">414 </span>    81 0/subop/add %esp 8/imm32
<span id="L415" class="LineNr">415 </span>    <span class="subxComment"># eax = array-equal?(ecx, eax)</span>
<span id="L416" class="LineNr">416 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L417" class="LineNr">417 </span>    50/push-eax
<span id="L418" class="LineNr">418 </span>    51/push-ecx
<span id="L419" class="LineNr">419 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L420" class="LineNr">420 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L421" class="LineNr">421 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L422" class="LineNr">422 </span>    81 0/subop/add %esp 8/imm32
<span id="L423" class="LineNr">423 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L424" class="LineNr">424 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L425" class="LineNr">425 </span>    68/push <span class="Constant">&quot;F - test-parse-array-of-ints&quot;</span>/imm32
<span id="L426" class="LineNr">426 </span>    68/push 1/imm32/true
<span id="L427" class="LineNr">427 </span>    50/push-eax
<span id="L428" class="LineNr">428 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L429" class="LineNr">429 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L430" class="LineNr">430 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L431" class="LineNr">431 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L432" class="LineNr">432 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L433" class="LineNr">433 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L434" class="LineNr">434 </span>    5d/pop-to-ebp
<span id="L435" class="LineNr">435 </span>    c3/return
<span id="L436" class="LineNr">436 </span>
<span id="L437" class="LineNr">437 </span><span class="subxTest">test-parse-array-of-ints-empty</span>:
<span id="L438" class="LineNr">438 </span>    <span class="subxH1Comment"># - empty string = empty array</span>
<span id="L439" class="LineNr">439 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L440" class="LineNr">440 </span>    55/push-ebp
<span id="L441" class="LineNr">441 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L442" class="LineNr">442 </span>    <span class="subxComment"># eax = parse-array-of-ints(Heap, &quot;&quot;)</span>
<span id="L443" class="LineNr">443 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L444" class="LineNr">444 </span>    68/push <span class="Constant">&quot;&quot;</span>/imm32
<span id="L445" class="LineNr">445 </span>    68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L446" class="LineNr">446 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L447" class="LineNr">447 </span>    e8/call <a href='100array-equal.subx.html#L230'>parse-array-of-ints</a>/disp32
<span id="L448" class="LineNr">448 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L449" class="LineNr">449 </span>    81 0/subop/add %esp 8/imm32
<span id="L450" class="LineNr">450 </span>    <span class="subxComment"># check-ints-equal(*eax, 0, msg)</span>
<span id="L451" class="LineNr">451 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L452" class="LineNr">452 </span>    68/push <span class="Constant">&quot;F - test-parse-array-of-ints-empty&quot;</span>/imm32
<span id="L453" class="LineNr">453 </span>    68/push 0/imm32/size
<span id="L454" class="LineNr">454 </span>    ff 6/subop/push *eax
<span id="L455" class="LineNr">455 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L456" class="LineNr">456 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L457" class="LineNr">457 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L458" class="LineNr">458 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L459" class="LineNr">459 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L460" class="LineNr">460 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L461" class="LineNr">461 </span>    5d/pop-to-ebp
<span id="L462" class="LineNr">462 </span>    c3/return
<span id="L463" class="LineNr">463 </span>
<span id="L464" class="LineNr">464 </span><span class="subxTest">test-parse-array-of-ints-just-whitespace</span>:
<span id="L465" class="LineNr">465 </span>    <span class="subxH1Comment"># - just whitespace = empty array</span>
<span id="L466" class="LineNr">466 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L467" class="LineNr">467 </span>    55/push-ebp
<span id="L468" class="LineNr">468 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L469" class="LineNr">469 </span>    <span class="subxComment"># eax = parse-array-of-ints(Heap, &quot; &quot;)</span>
<span id="L470" class="LineNr">470 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L471" class="LineNr">471 </span>    68/push <span class="SpecialChar"><a href='051test.subx.html#L94'>Space</a></span>/imm32
<span id="L472" class="LineNr">472 </span>    68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L473" class="LineNr">473 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L474" class="LineNr">474 </span>    e8/call <a href='100array-equal.subx.html#L230'>parse-array-of-ints</a>/disp32
<span id="L475" class="LineNr">475 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L476" class="LineNr">476 </span>    81 0/subop/add %esp 8/imm32
<span id="L477" class="LineNr">477 </span>    <span class="subxComment"># check-ints-equal(*eax, 0, msg)</span>
<span id="L478" class="LineNr">478 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L479" class="LineNr">479 </span>    68/push <span class="Constant">&quot;F - test-parse-array-of-ints-empty&quot;</span>/imm32
<span id="L480" class="LineNr">480 </span>    68/push 0/imm32/size
<span id="L481" class="LineNr">481 </span>    ff 6/subop/push *eax
<span id="L482" class="LineNr">482 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L483" class="LineNr">483 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L484" class="LineNr">484 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L485" class="LineNr">485 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L486" class="LineNr">486 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L487" class="LineNr">487 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L488" class="LineNr">488 </span>    5d/pop-to-ebp
<span id="L489" class="LineNr">489 </span>    c3/return
<span id="L490" class="LineNr">490 </span>
<span id="L491" class="LineNr">491 </span><span class="subxTest">test-parse-array-of-ints-extra-whitespace</span>:
<span id="L492" class="LineNr">492 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L493" class="LineNr">493 </span>    55/push-ebp
<span id="L494" class="LineNr">494 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L495" class="LineNr">495 </span>    <span class="subxComment"># var ecx: (array int) = [1, 2, 3]</span>
<span id="L496" class="LineNr">496 </span>    68/push 3/imm32
<span id="L497" class="LineNr">497 </span>    68/push 2/imm32
<span id="L498" class="LineNr">498 </span>    68/push 1/imm32
<span id="L499" class="LineNr">499 </span>    68/push 0xc/imm32/size
<span id="L500" class="LineNr">500 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L501" class="LineNr">501 </span>    <span class="subxComment"># eax = parse-array-of-ints(Heap, &quot; 1 2  3  &quot;)</span>
<span id="L502" class="LineNr">502 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L503" class="LineNr">503 </span>    68/push <span class="Constant">&quot; 1 2  3  &quot;</span>/imm32
<span id="L504" class="LineNr">504 </span>    68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L505" class="LineNr">505 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L506" class="LineNr">506 </span>    e8/call <a href='100array-equal.subx.html#L230'>parse-array-of-ints</a>/disp32
<span id="L507" class="LineNr">507 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L508" class="LineNr">508 </span>    81 0/subop/add %esp 8/imm32
<span id="L509" class="LineNr">509 </span>    <span class="subxComment"># eax = array-equal?(ecx, eax)</span>
<span id="L510" class="LineNr">510 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L511" class="LineNr">511 </span>    50/push-eax
<span id="L512" class="LineNr">512 </span>    51/push-ecx
<span id="L513" class="LineNr">513 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L514" class="LineNr">514 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L515" class="LineNr">515 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L516" class="LineNr">516 </span>    81 0/subop/add %esp 8/imm32
<span id="L517" class="LineNr">517 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L518" class="LineNr">518 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L519" class="LineNr">519 </span>    68/push <span class="Constant">&quot;F - test-parse-array-of-ints-extra-whitespace&quot;</span>/imm32
<span id="L520" class="LineNr">520 </span>    68/push 1/imm32/true
<span id="L521" class="LineNr">521 </span>    50/push-eax
<span id="L522" class="LineNr">522 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L523" class="LineNr">523 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L524" class="LineNr">524 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L525" class="LineNr">525 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L526" class="LineNr">526 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L527" class="LineNr">527 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L528" class="LineNr">528 </span>    5d/pop-to-ebp
<span id="L529" class="LineNr">529 </span>    c3/return
<span id="L530" class="LineNr">530 </span>
<span id="L531" class="LineNr">531 </span><span class="subxComment"># helper for later tests</span>
<span id="L532" class="LineNr">532 </span><span class="subxComment"># compare an array with a string representation of an array literal</span>
<span id="L533" class="LineNr">533 </span><span class="subxFunction">check-array-equal</span>:  <span class="subxComment"># a: (addr array int), expected: (addr string), msg: (addr string)</span>
<span id="L534" class="LineNr">534 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L535" class="LineNr">535 </span>    55/push-ebp
<span id="L536" class="LineNr">536 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L537" class="LineNr">537 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L538" class="LineNr">538 </span>    50/push-eax
<span id="L539" class="LineNr">539 </span>    <span class="subxComment"># var b/ecx: (handle array int) = parse-array-of-ints(Heap, expected)</span>
<span id="L540" class="LineNr">540 </span>    <span class="subxS1Comment"># . eax = parse-array-of-ints(Heap, expected)</span>
<span id="L541" class="LineNr">541 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L542" class="LineNr">542 </span>    ff 6/subop/push *(ebp+0xc)
<span id="L543" class="LineNr">543 </span>    68/push <span class="SpecialChar"><a href='069allocate.subx.html#L22'>Heap</a></span>/imm32
<span id="L544" class="LineNr">544 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L545" class="LineNr">545 </span>    e8/call <a href='100array-equal.subx.html#L230'>parse-array-of-ints</a>/disp32
<span id="L546" class="LineNr">546 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L547" class="LineNr">547 </span>    81 0/subop/add %esp 8/imm32
<span id="L548" class="LineNr">548 </span>    <span class="subxS1Comment"># . b = eax</span>
<span id="L549" class="LineNr">549 </span>    89/&lt;- %ecx 0/r32/eax
<span id="L550" class="LineNr">550 </span>    <span class="subxComment"># eax = array-equal?(a, b)</span>
<span id="L551" class="LineNr">551 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L552" class="LineNr">552 </span>    51/push-ecx
<span id="L553" class="LineNr">553 </span>    ff 6/subop/push *(ebp+8)
<span id="L554" class="LineNr">554 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L555" class="LineNr">555 </span>    e8/call <a href='100array-equal.subx.html#L5'>array-equal?</a>/disp32
<span id="L556" class="LineNr">556 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L557" class="LineNr">557 </span>    81 0/subop/add %esp 8/imm32
<span id="L558" class="LineNr">558 </span>    <span class="subxComment"># check-ints-equal(eax, 1, msg)</span>
<span id="L559" class="LineNr">559 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L560" class="LineNr">560 </span>    ff 6/subop/push *(ebp+0x10)
<span id="L561" class="LineNr">561 </span>    68/push 1/imm32
<span id="L562" class="LineNr">562 </span>    50/push-eax
<span id="L563" class="LineNr">563 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L564" class="LineNr">564 </span>    e8/call <a href='051test.subx.html#L24'>check-ints-equal</a>/disp32
<span id="L565" class="LineNr">565 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L566" class="LineNr">566 </span>    81 0/subop/add %esp 0xc/imm32
<span id="L567" class="LineNr">567 </span><span class="Constant">$check-array-equal:end</span>:
<span id="L568" class="LineNr">568 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L569" class="LineNr">569 </span>    58/pop-to-eax
<span id="L570" class="LineNr">570 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L571" class="LineNr">571 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L572" class="LineNr">572 </span>    5d/pop-to-ebp
<span id="L573" class="LineNr">573 </span>    c3/return
<span id="L574" class="LineNr">574 </span>
<span id="L575" class="LineNr">575 </span><span class="subxTest">test-check-array-equal</span>:
<span id="L576" class="LineNr">576 </span>    <span class="subxS1Comment"># . prologue</span>
<span id="L577" class="LineNr">577 </span>    55/push-ebp
<span id="L578" class="LineNr">578 </span>    89/&lt;- %ebp 4/r32/esp
<span id="L579" class="LineNr">579 </span>    <span class="subxComment"># var ecx: (array int) = [1, 2, 3]</span>
<span id="L580" class="LineNr">580 </span>    68/push 3/imm32
<span id="L581" class="LineNr">581 </span>    68/push 2/imm32
<span id="L582" class="LineNr">582 </span>    68/push 1/imm32
<span id="L583" class="LineNr">583 </span>    68/push 0xc/imm32/size
<span id="L584" class="LineNr">584 </span>    89/&lt;- %ecx 4/r32/esp
<span id="L585" class="LineNr">585 </span>    <span class="subxComment"># check-array-equal(ecx, &quot;1 2 3&quot;, &quot;msg&quot;)</span>
<span id="L586" class="LineNr">586 </span>    <span class="subxS2Comment"># . . push args</span>
<span id="L587" class="LineNr">587 </span>    68/push <span class="Constant">&quot;F - test-check-array-equal&quot;</span>/imm32
<span id="L588" class="LineNr">588 </span>    68/push <span class="Constant">&quot;1 2 3&quot;</span>/imm32
<span id="L589" class="LineNr">589 </span>    51/push-ecx
<span id="L590" class="LineNr">590 </span>    <span class="subxS2Comment"># . . call</span>
<span id="L591" class="LineNr">591 </span>    e8/call <a href='100array-equal.subx.html#L533'>check-array-equal</a>/disp32
<span id="L592" class="LineNr">592 </span>    <span class="subxS2Comment"># . . discard args</span>
<span id="L593" class="LineNr">593 </span>    81 0/subop/add %esp 8/imm32
<span id="L594" class="LineNr">594 </span>    <span class="subxS1Comment"># . epilogue</span>
<span id="L595" class="LineNr">595 </span>    89/&lt;- %esp 5/r32/ebp
<span id="L596" class="LineNr">596 </span>    5d/pop-to-ebp
<span id="L597" class="LineNr">597 </span>    c3/return
<span id="L598" class="LineNr">598 </span>
<span id="L599" class="LineNr">599 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->