about summary refs log tree commit diff stats
path: root/init.soso
blob: 8753b4121a7b548fcd5735cf78ba09931eb3ffa9 (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
# Some OS-specific preliminaries for Soso.

# Memory layout
#
# 0x40000000 - 0x40001ffff - for ELF code+data
# 0x40002000 - 0x401ffffff - for heap
== code 0x40000000
== data 0x40001000

# Syscalls
#
# We don't have libc, so we need to know Soso's precise syscall layout.
# https://github.com/ozkl/soso/blob/master/kernel/syscalltable.h
== code

syscall_exit:  # status/ebx : int
    b8/copy-to-eax 8/imm32
    cd/syscall 0x80/imm8

syscall_read:  # fd/ebx : int, buf/ecx : addr, size/edx : int -> nbytes-or-error/eax : int
    b8/copy-to-eax 2/imm32
    cd/syscall 0x80/imm8
    c3/return

syscall_write:  # fd/ebx : int, buf/ecx : addr, size/edx : int -> nbytes-or-error/eax : int
    b8/copy-to-eax 3/imm32
    cd/syscall 0x80/imm8
    c3/return

syscall_open:  # filename/ebx : (addr kernel-string), flags/ecx : int -> fd-or-error/eax : int
    b8/copy-to-eax 0/imm32
    cd/syscall 0x80/imm8
    c3/return

syscall_close:  # fd/ebx : int -> status/eax
    b8/copy-to-eax 1/imm32
    cd/syscall 0x80/imm8
    c3/return

# anonymous mmap not implemented
#n225'>225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 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 297 298 299 300 301 302 303 304
<!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 - baremetal/shell/value-stack.mu</title>
<meta name="Generator" content="Vim/8.1">
<meta name="plugin-version" content="vim8.1_v1">
<meta name="syntax" content="none">
<meta name="settings" content="number_lines,use_css,pre_wrap,no_foldcolumn,expand_tabs,line_ids,prevent_copy=">
<meta name="colorscheme" content="minimal-light">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #000000; background-color: #c6c6c6; }
body { font-size:12pt; font-family: monospace; color: #000000; background-color: #c6c6c6; }
a { color:inherit; }
* { font-size:12pt; font-size: 1em; }
.PreProc { color: #c000c0; }
.LineNr { }
.Constant { color: #008787; }
.SpecialChar { color: #d70000; }
.Delimiter { color: #c000c0; }
.muFunction { color: #af5f00; text-decoration: underline; }
.muTest { color: #5f8700; }
.muComment { color: #005faf; }
-->
</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/main/baremetal/shell/value-stack.mu'>https://github.com/akkartik/mu/blob/main/baremetal/shell/value-stack.mu</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="muComment"># value stacks encode the result of a program at a single point in time</span>
<span id="L2" class="LineNr">  2 </span><span class="muComment"># they are typically rendered vertically</span>
<span id="L3" class="LineNr">  3 </span>
<span id="L4" class="LineNr">  4 </span><span class="PreProc">type</span> <a href='value-stack.mu.html#L4'>value-stack</a> <span class="Delimiter">{</span>
<span id="L5" class="LineNr">  5 </span>  data: (handle array <a href='value.mu.html#L2'>value</a>)
<span id="L6" class="LineNr">  6 </span>  <a href='../../203stack.subx.html#L338'>top</a>: int
<span id="L7" class="LineNr">  7 </span><span class="Delimiter">}</span>
<span id="L8" class="LineNr">  8 </span>
<span id="L9" class="LineNr">  9 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L9'>initialize-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), n: int <span class="Delimiter">{</span>
<span id="L10" class="LineNr"> 10 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L11" class="LineNr"> 11 </span>  <span class="PreProc">var</span> d/<span class="Constant">edi</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L12" class="LineNr"> 12 </span>  populate d, n
<span id="L13" class="LineNr"> 13 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L14" class="LineNr"> 14 </span>  copy-to *top, <span class="Constant">0</span>
<span id="L15" class="LineNr"> 15 </span><span class="Delimiter">}</span>
<span id="L16" class="LineNr"> 16 </span>
<span id="L17" class="LineNr"> 17 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L17'>clear-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="Delimiter">{</span>
<span id="L18" class="LineNr"> 18 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L19" class="LineNr"> 19 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L20" class="LineNr"> 20 </span>  copy-to *top, <span class="Constant">0</span>
<span id="L21" class="LineNr"> 21 </span><span class="Delimiter">}</span>
<span id="L22" class="LineNr"> 22 </span>
<span id="L23" class="LineNr"> 23 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L23'>push-number-to-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), _val: float <span class="Delimiter">{</span>
<span id="L24" class="LineNr"> 24 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L25" class="LineNr"> 25 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L26" class="LineNr"> 26 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L27" class="LineNr"> 27 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L28" class="LineNr"> 28 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L29" class="LineNr"> 29 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L30" class="LineNr"> 30 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L31" class="LineNr"> 31 </span>  <span class="PreProc">var</span> dest-addr2/<span class="Constant">eax</span>: (addr float) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, number-data
<span id="L32" class="LineNr"> 32 </span>  <span class="PreProc">var</span> val/<span class="Constant">xmm0</span>: float <span class="SpecialChar">&lt;-</span> copy _val
<span id="L33" class="LineNr"> 33 </span>  copy-to *dest-addr2, val
<span id="L34" class="LineNr"> 34 </span>  increment *top-addr
<span id="L35" class="LineNr"> 35 </span>  <span class="PreProc">var</span> type-addr/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, <span class="PreProc">type</span>
<span id="L36" class="LineNr"> 36 </span>  copy-to *type-addr, <span class="Constant">0</span>/number
<span id="L37" class="LineNr"> 37 </span><span class="Delimiter">}</span>
<span id="L38" class="LineNr"> 38 </span>
<span id="L39" class="LineNr"> 39 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L39'>push-int-to-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), _val: int <span class="Delimiter">{</span>
<span id="L40" class="LineNr"> 40 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L41" class="LineNr"> 41 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L42" class="LineNr"> 42 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L43" class="LineNr"> 43 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L44" class="LineNr"> 44 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L45" class="LineNr"> 45 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L46" class="LineNr"> 46 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L47" class="LineNr"> 47 </span>  <span class="PreProc">var</span> dest-addr2/<span class="Constant">eax</span>: (addr float) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, number-data
<span id="L48" class="LineNr"> 48 </span>  <span class="PreProc">var</span> val/<span class="Constant">xmm0</span>: float <span class="SpecialChar">&lt;-</span> convert _val
<span id="L49" class="LineNr"> 49 </span>  copy-to *dest-addr2, val
<span id="L50" class="LineNr"> 50 </span>  increment *top-addr
<span id="L51" class="LineNr"> 51 </span>  <span class="PreProc">var</span> type-addr/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, <span class="PreProc">type</span>
<span id="L52" class="LineNr"> 52 </span>  copy-to *type-addr, <span class="Constant">0</span>/number
<span id="L53" class="LineNr"> 53 </span><span class="Delimiter">}</span>
<span id="L54" class="LineNr"> 54 </span>
<span id="L55" class="LineNr"> 55 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L55'>push-string-to-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), val: (handle array byte) <span class="Delimiter">{</span>
<span id="L56" class="LineNr"> 56 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L57" class="LineNr"> 57 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L58" class="LineNr"> 58 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L59" class="LineNr"> 59 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L60" class="LineNr"> 60 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L61" class="LineNr"> 61 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L62" class="LineNr"> 62 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L63" class="LineNr"> 63 </span>  <span class="PreProc">var</span> dest-addr2/<span class="Constant">eax</span>: (addr handle array byte) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, text-data
<span id="L64" class="LineNr"> 64 </span>  <a href='../../120allocate.subx.html#L497'>copy-handle</a> val, dest-addr2
<span id="L65" class="LineNr"> 65 </span>  <span class="PreProc">var</span> dest-addr3/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, <span class="PreProc">type</span>
<span id="L66" class="LineNr"> 66 </span>  copy-to *dest-addr3, <span class="Constant">1</span>/string
<span id="L67" class="LineNr"> 67 </span>  increment *top-addr
<span id="L68" class="LineNr"> 68 </span><span class="Delimiter">}</span>
<span id="L69" class="LineNr"> 69 </span>
<span id="L70" class="LineNr"> 70 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L70'>push-array-to-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), val: (handle array <a href='value.mu.html#L2'>value</a>) <span class="Delimiter">{</span>
<span id="L71" class="LineNr"> 71 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L72" class="LineNr"> 72 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L73" class="LineNr"> 73 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L74" class="LineNr"> 74 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L75" class="LineNr"> 75 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L76" class="LineNr"> 76 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L77" class="LineNr"> 77 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L78" class="LineNr"> 78 </span>  <span class="PreProc">var</span> dest-addr2/<span class="Constant">eax</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, array-data
<span id="L79" class="LineNr"> 79 </span>  <a href='../../120allocate.subx.html#L497'>copy-handle</a> val, dest-addr2
<span id="L80" class="LineNr"> 80 </span>  <span class="muComment"># update type</span>
<span id="L81" class="LineNr"> 81 </span>  <span class="PreProc">var</span> dest-addr3/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, <span class="PreProc">type</span>
<span id="L82" class="LineNr"> 82 </span>  copy-to *dest-addr3, <span class="Constant">2</span>/array
<span id="L83" class="LineNr"> 83 </span>  increment *top-addr
<span id="L84" class="LineNr"> 84 </span><span class="Delimiter">}</span>
<span id="L85" class="LineNr"> 85 </span>
<span id="L86" class="LineNr"> 86 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L86'>push-boolean-to-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), _val: boolean <span class="Delimiter">{</span>
<span id="L87" class="LineNr"> 87 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L88" class="LineNr"> 88 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L89" class="LineNr"> 89 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L90" class="LineNr"> 90 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L91" class="LineNr"> 91 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L92" class="LineNr"> 92 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L93" class="LineNr"> 93 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L94" class="LineNr"> 94 </span>  <span class="PreProc">var</span> dest-addr2/<span class="Constant">eax</span>: (addr boolean) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, boolean-data
<span id="L95" class="LineNr"> 95 </span>  <span class="PreProc">var</span> val/<span class="Constant">esi</span>: boolean <span class="SpecialChar">&lt;-</span> copy _val
<span id="L96" class="LineNr"> 96 </span>  copy-to *dest-addr2, val
<span id="L97" class="LineNr"> 97 </span>  increment *top-addr
<span id="L98" class="LineNr"> 98 </span>  <span class="PreProc">var</span> type-addr/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> dest-addr, <span class="PreProc">type</span>
<span id="L99" class="LineNr"> 99 </span>  copy-to *type-addr, <span class="Constant">3</span>/boolean
<span id="L100" class="LineNr">100 </span><span class="Delimiter">}</span>
<span id="L101" class="LineNr">101 </span>
<span id="L102" class="LineNr">102 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L102'>push-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), val: (addr <a href='value.mu.html#L2'>value</a>) <span class="Delimiter">{</span>
<span id="L103" class="LineNr">103 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L104" class="LineNr">104 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L105" class="LineNr">105 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L106" class="LineNr">106 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L107" class="LineNr">107 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L108" class="LineNr">108 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L109" class="LineNr">109 </span>  <span class="PreProc">var</span> dest-addr/<span class="Constant">edx</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L110" class="LineNr">110 </span>  copy-object val, dest-addr
<span id="L111" class="LineNr">111 </span>  increment *top-addr
<span id="L112" class="LineNr">112 </span><span class="Delimiter">}</span>
<span id="L113" class="LineNr">113 </span>
<span id="L114" class="LineNr">114 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L114'>pop-number-from-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>)<span class="PreProc"> -&gt; </span>_/<span class="Constant">xmm0</span>: float <span class="Delimiter">{</span>
<span id="L115" class="LineNr">115 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L116" class="LineNr">116 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L117" class="LineNr">117 </span>  <span class="Delimiter">{</span>
<span id="L118" class="LineNr">118 </span>    compare *top-addr, <span class="Constant">0</span>
<span id="L119" class="LineNr">119 </span>    <span class="PreProc">break-if-&gt;</span>
<span id="L120" class="LineNr">120 </span>    abort <span class="Constant">&quot;pop number: empty stack&quot;</span>
<span id="L121" class="LineNr">121 </span>  <span class="Delimiter">}</span>
<span id="L122" class="LineNr">122 </span>  decrement *top-addr
<span id="L123" class="LineNr">123 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L124" class="LineNr">124 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L125" class="LineNr">125 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L126" class="LineNr">126 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L127" class="LineNr">127 </span>  <span class="PreProc">var</span> result-addr/<span class="Constant">eax</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L128" class="LineNr">128 </span>  <span class="PreProc">var</span> result-addr2/<span class="Constant">eax</span>: (addr float) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> result-addr, number-data
<span id="L129" class="LineNr">129 </span>  <span class="PreProc">return</span> *result-addr2
<span id="L130" class="LineNr">130 </span><span class="Delimiter">}</span>
<span id="L131" class="LineNr">131 </span>
<span id="L132" class="LineNr">132 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L132'>pop-boolean-from-value-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>)<span class="PreProc"> -&gt; </span>_/<span class="Constant">eax</span>: boolean <span class="Delimiter">{</span>
<span id="L133" class="LineNr">133 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L134" class="LineNr">134 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L135" class="LineNr">135 </span>  <span class="Delimiter">{</span>
<span id="L136" class="LineNr">136 </span>    compare *top-addr, <span class="Constant">0</span>
<span id="L137" class="LineNr">137 </span>    <span class="PreProc">break-if-&gt;</span>
<span id="L138" class="LineNr">138 </span>    abort <span class="Constant">&quot;pop boolean: empty stack&quot;</span>
<span id="L139" class="LineNr">139 </span>  <span class="Delimiter">}</span>
<span id="L140" class="LineNr">140 </span>  decrement *top-addr
<span id="L141" class="LineNr">141 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">edx</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L142" class="LineNr">142 </span>  <span class="PreProc">var</span> data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L143" class="LineNr">143 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L144" class="LineNr">144 </span>  <span class="PreProc">var</span> dest-offset/<span class="Constant">edx</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L145" class="LineNr">145 </span>  <span class="PreProc">var</span> result-addr/<span class="Constant">eax</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L146" class="LineNr">146 </span>  <span class="PreProc">var</span> result-addr2/<span class="Constant">eax</span>: (addr boolean) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> result-addr, boolean-data
<span id="L147" class="LineNr">147 </span>  <span class="PreProc">return</span> *result-addr2
<span id="L148" class="LineNr">148 </span><span class="Delimiter">}</span>
<span id="L149" class="LineNr">149 </span>
<span id="L150" class="LineNr">150 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L150'>value-stack-empty?</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>)<span class="PreProc"> -&gt; </span>_/<span class="Constant">eax</span>: boolean <span class="Delimiter">{</span>
<span id="L151" class="LineNr">151 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L152" class="LineNr">152 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L153" class="LineNr">153 </span>  compare *top, <span class="Constant">0</span>
<span id="L154" class="LineNr">154 </span>  <span class="Delimiter">{</span>
<span id="L155" class="LineNr">155 </span>    <span class="PreProc">break-if-!=</span>
<span id="L156" class="LineNr">156 </span>    <span class="PreProc">return</span> <span class="Constant">1</span>/true
<span id="L157" class="LineNr">157 </span>  <span class="Delimiter">}</span>
<span id="L158" class="LineNr">158 </span>  <span class="PreProc">return</span> <span class="Constant">0</span>/false
<span id="L159" class="LineNr">159 </span><span class="Delimiter">}</span>
<span id="L160" class="LineNr">160 </span>
<span id="L161" class="LineNr">161 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L161'>value-stack-length</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>)<span class="PreProc"> -&gt; </span>_/<span class="Constant">eax</span>: int <span class="Delimiter">{</span>
<span id="L162" class="LineNr">162 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L163" class="LineNr">163 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L164" class="LineNr">164 </span>  <span class="PreProc">return</span> *top-addr
<span id="L165" class="LineNr">165 </span><span class="Delimiter">}</span>
<span id="L166" class="LineNr">166 </span>
<span id="L167" class="LineNr">167 </span><span class="PreProc">fn</span> <span class="muTest"><a href='value-stack.mu.html#L167'>test-boolean</a></span> <span class="Delimiter">{</span>
<span id="L168" class="LineNr">168 </span>  <span class="PreProc">var</span> stack-storage: <a href='value-stack.mu.html#L4'>value-stack</a>
<span id="L169" class="LineNr">169 </span>  <span class="PreProc">var</span> stack/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> address stack-storage
<span id="L170" class="LineNr">170 </span>  <a href='value-stack.mu.html#L86'>push-boolean-to-value-stack</a> stack, <span class="Constant">0</span>/false
<span id="L171" class="LineNr">171 </span>  <span class="PreProc">var</span> result/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='value-stack.mu.html#L132'>pop-boolean-from-value-stack</a> stack
<span id="L172" class="LineNr">172 </span>  check-not result, <span class="Constant">&quot;F - <a href='value-stack.mu.html#L167'>test-boolean</a>/false&quot;</span>
<span id="L173" class="LineNr">173 </span>  <a href='value-stack.mu.html#L86'>push-boolean-to-value-stack</a> stack, <span class="Constant">1</span>/true
<span id="L174" class="LineNr">174 </span>  <span class="PreProc">var</span> result/<span class="Constant">eax</span>: boolean <span class="SpecialChar">&lt;-</span> <a href='value-stack.mu.html#L132'>pop-boolean-from-value-stack</a> stack
<span id="L175" class="LineNr">175 </span>  check result, <span class="Constant">&quot;F - <a href='value-stack.mu.html#L167'>test-boolean</a>/true&quot;</span>
<span id="L176" class="LineNr">176 </span><span class="Delimiter">}</span>
<span id="L177" class="LineNr">177 </span>
<span id="L178" class="LineNr">178 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L178'>dump-stack</a></span> _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="Delimiter">{</span>
<span id="L179" class="LineNr">179 </span>  <span class="PreProc">var</span> self/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L180" class="LineNr">180 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">eax</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L181" class="LineNr">181 </span>  <span class="PreProc">var</span> _data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L182" class="LineNr">182 </span>  <span class="PreProc">var</span> data/<span class="Constant">edi</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> copy _data
<span id="L183" class="LineNr">183 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">ecx</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L184" class="LineNr">184 </span>  <span class="PreProc">var</span> <a href='../../203stack.subx.html#L338'>top</a>/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L185" class="LineNr">185 </span>  <a href='../../203stack.subx.html#L338'>top</a> <span class="SpecialChar">&lt;-</span> decrement
<span id="L186" class="LineNr">186 </span>  <span class="PreProc">var</span> y/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0xa</span>
<span id="L187" class="LineNr">187 </span>  <span class="PreProc">var</span> dummy/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> draw-text-rightward-over-full-screen <span class="Constant">0</span>/screen, <span class="Constant">&quot;==&quot;</span>, <span class="Constant">0</span>/x, <span class="Constant">9</span>/y, <span class="Constant">0xc</span>/red, <span class="Constant">0</span>/bg
<span id="L188" class="LineNr">188 </span>  <span class="Delimiter">{</span>
<span id="L189" class="LineNr">189 </span>    compare <a href='../../203stack.subx.html#L338'>top</a>, <span class="Constant">0</span>
<span id="L190" class="LineNr">190 </span>    <span class="PreProc">break-if-&lt;</span>
<span id="L191" class="LineNr">191 </span>    <span class="PreProc">var</span> dest-offset/<span class="Constant">eax</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L192" class="LineNr">192 </span>    <span class="PreProc">var</span> curr/<span class="Constant">eax</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L193" class="LineNr">193 </span>    <span class="PreProc">var</span> dummy/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='value.mu.html#L12'>render-value</a> <span class="Constant">0</span>/screen, curr, <span class="Constant">0</span>/x, y, <span class="Constant">0</span>/no-color
<span id="L194" class="LineNr">194 </span>    <a href='../../203stack.subx.html#L338'>top</a> <span class="SpecialChar">&lt;-</span> decrement
<span id="L195" class="LineNr">195 </span>    y <span class="SpecialChar">&lt;-</span> increment
<span id="L196" class="LineNr">196 </span>    <span class="PreProc">loop</span>
<span id="L197" class="LineNr">197 </span>  <span class="Delimiter">}</span>
<span id="L198" class="LineNr">198 </span><span class="Delimiter">}</span>
<span id="L199" class="LineNr">199 </span>
<span id="L200" class="LineNr">200 </span><span class="PreProc">fn</span> <span class="muFunction"><a href='value-stack.mu.html#L200'>render-value-stack</a></span> <a href='../../405screen.mu.html#L9'>screen</a>: (addr <a href='../../405screen.mu.html#L9'>screen</a>), _self: (addr <a href='value-stack.mu.html#L4'>value-stack</a>), x: int, y: int<span class="PreProc"> -&gt; </span>_/<span class="Constant">eax</span>: int, _/<span class="Constant">ecx</span>: int <span class="Delimiter">{</span>
<span id="L201" class="LineNr">201 </span>  <span class="PreProc">var</span> self/<span class="Constant">ecx</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> copy _self
<span id="L202" class="LineNr">202 </span>  <span class="PreProc">var</span> data-ah/<span class="Constant">eax</span>: (addr handle array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, data
<span id="L203" class="LineNr">203 </span>  <span class="PreProc">var</span> _data/<span class="Constant">eax</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> <a href='../../120allocate.subx.html#L258'>lookup</a> *data-ah
<span id="L204" class="LineNr">204 </span>  <span class="PreProc">var</span> data/<span class="Constant">edi</span>: (addr array <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> copy _data
<span id="L205" class="LineNr">205 </span>  <span class="PreProc">var</span> top-addr/<span class="Constant">eax</span>: (addr int) <span class="SpecialChar">&lt;-</span> <a href='../../131table.subx.html#L26'>get</a> self, <a href='../../203stack.subx.html#L338'>top</a>
<span id="L206" class="LineNr">206 </span>  <span class="PreProc">var</span> curr-idx/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy *top-addr
<span id="L207" class="LineNr">207 </span>  curr-idx <span class="SpecialChar">&lt;-</span> decrement
<span id="L208" class="LineNr">208 </span>  <span class="PreProc">var</span> new-x/<span class="Constant">edx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L209" class="LineNr">209 </span>  <span class="Delimiter">{</span>
<span id="L210" class="LineNr">210 </span>    compare curr-idx, <span class="Constant">0</span>
<span id="L211" class="LineNr">211 </span>    <span class="PreProc">break-if-&lt;</span>
<span id="L212" class="LineNr">212 </span>    <span class="PreProc">var</span> dest-offset/<span class="Constant">eax</span>: (offset <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> compute-offset data, curr-idx
<span id="L213" class="LineNr">213 </span>    <span class="PreProc">var</span> curr/<span class="Constant">eax</span>: (addr <a href='value.mu.html#L2'>value</a>) <span class="SpecialChar">&lt;-</span> index data, dest-offset
<span id="L214" class="LineNr">214 </span>    <span class="PreProc">var</span> curr-x/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> <a href='value.mu.html#L12'>render-value</a> <a href='../../405screen.mu.html#L9'>screen</a>, curr, x, y, <span class="Constant">1</span>/top-level
<span id="L215" class="LineNr">215 </span>    <span class="Delimiter">{</span>
<span id="L216" class="LineNr">216 </span>      compare curr-x, new-x
<span id="L217" class="LineNr">217 </span>      <span class="PreProc">break-if-&lt;=</span>
<span id="L218" class="LineNr">218 </span>      new-x <span class="SpecialChar">&lt;-</span> copy curr-x
<span id="L219" class="LineNr">219 </span>    <span class="Delimiter">}</span>
<span id="L220" class="LineNr">220 </span>    curr-idx <span class="SpecialChar">&lt;-</span> decrement
<span id="L221" class="LineNr">221 </span>    increment y
<span id="L222" class="LineNr">222 </span>    <span class="PreProc">loop</span>
<span id="L223" class="LineNr">223 </span>  <span class="Delimiter">}</span>
<span id="L224" class="LineNr">224 </span>  <span class="PreProc">return</span> new-x, y
<span id="L225" class="LineNr">225 </span><span class="Delimiter">}</span>
<span id="L226" class="LineNr">226 </span>
<span id="L227" class="LineNr">227 </span><span class="PreProc">fn</span> <span class="muTest"><a href='value-stack.mu.html#L227'>test-render-value-stack</a></span> <span class="Delimiter">{</span>
<span id="L228" class="LineNr">228 </span>  <span class="PreProc">var</span> stack-storage: <a href='value-stack.mu.html#L4'>value-stack</a>
<span id="L229" class="LineNr">229 </span>  <span class="PreProc">var</span> stack/<span class="Constant">esi</span>: (addr <a href='value-stack.mu.html#L4'>value-stack</a>) <span class="SpecialChar">&lt;-</span> address stack-storage
<span id="L230" class="LineNr">230 </span>  <a href='value-stack.mu.html#L39'>push-int-to-value-stack</a> stack, <span class="Constant">3</span>
<span id="L231" class="LineNr">231 </span>  <span class="muComment"># setup: screen</span>
<span id="L232" class="LineNr">232 </span>  <span class="PreProc">var</span> screen-on-stack: <a href='../../405screen.mu.html#L9'>screen</a>
<span id="L233" class="LineNr">233 </span>  <span class="PreProc">var</span> <a href='../../405screen.mu.html#L9'>screen</a>/<span class="Constant">edi</span>: (addr <a href='../../405screen.mu.html#L9'>screen</a>) <span class="SpecialChar">&lt;-</span> address screen-on-stack
<span id="L234" class="LineNr">234 </span>  <a href='../../405screen.mu.html#L30'>initialize-screen</a> <a href='../../405screen.mu.html#L9'>screen</a>, <span class="Constant">0x20</span>, <span class="Constant">4</span>
<span id="L235" class="LineNr">235 </span>  <span class="muComment">#</span>
<span id="L236" class="LineNr">236 </span>  <span class="PreProc">var</span> final-x/<span class="Constant">eax</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L237" class="LineNr">237 </span>  <span class="PreProc">var</span> final-y/<span class="Constant">ecx</span>: int <span class="SpecialChar">&lt;-</span> copy <span class="Constant">0</span>
<span id="L238" class="LineNr">238 </span>  final-x, final-y <span class="SpecialChar">&lt;-</span> <a href='value-stack.mu.html#L200'>render-value-stack</a> <a href='../../405screen.mu.html#L9'>screen</a>, stack, <span class="Constant">0</span>/x, <span class="Constant">0</span>/y
<span id="L239" class="LineNr">239 </span>  <a href='../../102test.subx.html#L23'>check-ints-equal</a> final-y, <span class="Constant">1</span>, <span class="Constant">&quot;F - <a href='value-stack.mu.html#L227'>test-render-value-stack</a> y&quot;</span>
<span id="L240" class="LineNr">240 </span>  <a href='../../102test.subx.html#L23'>check-ints-equal</a> final-x, <span class="Constant">3</span>, <span class="Constant">&quot;F - <a href='value-stack.mu.html#L227'>test-render-value-stack</a> x&quot;</span>
<span id="L241" class="LineNr">241 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->