about summary refs log tree commit diff stats
path: root/html/subx/055stream.subx.html
blob: 0ab5f47f11b9bef1b6d37b88a33983ec0f0a1a07 (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
<!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 - subx/055stream.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; }
.subxS1Comment { color: #0000af; }
.LineNr { }
.Normal { color: #000000; background-color: #c6c6c6; padding-bottom: 1px; }
.subxFunction { color: #af5f00; text-decoration: underline; }
.Constant { color: #008787; }
.subxS2Comment { color: #8a8a8a; }
-->
</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/subx/055stream.subx'>https://github.com/akkartik/mu/blob/master/subx/055stream.subx</a>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr"> 1 </span><span class="subxComment"># streams: data structure for operating on arrays in a stateful manner</span>
<span id="L2" class="LineNr"> 2 </span><span class="subxComment">#</span>
<span id="L3" class="LineNr"> 3 </span><span class="subxComment"># A stream looks like this:</span>
<span id="L4" class="LineNr"> 4 </span><span class="subxComment">#   write : int  # index at which writes go</span>
<span id="L5" class="LineNr"> 5 </span><span class="subxComment">#   read : int  # index that we've read until</span>
<span id="L6" class="LineNr"> 6 </span><span class="subxComment">#   data : (array byte)  # prefixed by length as usual</span>
<span id="L7" class="LineNr"> 7 </span><span class="subxComment">#</span>
<span id="L8" class="LineNr"> 8 </span><span class="subxComment"># some primitives for operating on streams:</span>
<span id="L9" class="LineNr"> 9 </span><span class="subxComment">#   - clear-stream (clears everything but the data length)</span>
<span id="L10" class="LineNr">10 </span><span class="subxComment">#   - rewind-stream (resets read pointer)</span>
<span id="L11" class="LineNr">11 </span>
<span id="L12" class="LineNr">12 </span>== code
<span id="L13" class="LineNr">13 </span><span class="subxComment">#   instruction                     effective address                                                   register    displacement    immediate</span>
<span id="L14" class="LineNr">14 </span><span class="subxS1Comment"># . op          subop               mod             rm32          base        index         scale       r32</span>
<span id="L15" class="LineNr">15 </span><span class="subxS1Comment"># . 1-3 bytes   3 bits              2 bits          3 bits        3 bits      3 bits        2 bits      2 bits      0/1/2/4 bytes   0/1/2/4 bytes</span>
<span id="L16" class="LineNr">16 </span>
<span id="L17" class="LineNr">17 </span><span class="subxFunction">clear-stream</span>:  <span class="subxComment"># f : (address stream) -&gt; &lt;void&gt;</span>
<span id="L18" class="LineNr">18 </span>    <span class="subxS1Comment"># . prolog</span>
<span id="L19" class="LineNr">19 </span>    55/push-EBP
<span id="L20" class="LineNr">20 </span>    89/copy                         3/mod/direct    5/rm32/EBP   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          4/r32/ESP  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy ESP to EBP</span>
<span id="L21" class="LineNr">21 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L22" class="LineNr">22 </span>    50/push-EAX
<span id="L23" class="LineNr">23 </span>    51/push-ECX
<span id="L24" class="LineNr">24 </span>    <span class="subxComment"># EAX = f</span>
<span id="L25" class="LineNr">25 </span>    8b/copy                         1/mod/*+disp8   5/rm32/EBP   <span class="Normal"> . </span>         <span class="Normal"> . </span>                        0/r32/EAX   8/disp8        <span class="Normal"> . </span>                <span class="subxComment"># copy *(EBP+8) to EAX</span>
<span id="L26" class="LineNr">26 </span>    <span class="subxComment"># ECX = f-&gt;length</span>
<span id="L27" class="LineNr">27 </span>    8b/copy                         1/mod/*+disp8   0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          1/r32/ECX   8/disp8        <span class="Normal"> . </span>                <span class="subxComment"># copy *(EAX+8) to ECX</span>
<span id="L28" class="LineNr">28 </span>    <span class="subxComment"># ECX = &amp;f-&gt;data[f-&gt;length]</span>
<span id="L29" class="LineNr">29 </span>    8d/copy-address                 1/mod/*+disp8   4/rm32/sib    0/base/EAX  1/index/ECX  <span class="Normal"> . </span>          1/r32/ECX   0xc/disp8      <span class="Normal"> . </span>                <span class="subxComment"># copy EAX+ECX+12 to ECX</span>
<span id="L30" class="LineNr">30 </span>    <span class="subxComment"># f-&gt;write = 0</span>
<span id="L31" class="LineNr">31 </span>    c7          0/subop/copy        0/mod/direct    0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              0/imm32           <span class="subxComment"># copy to *EAX</span>
<span id="L32" class="LineNr">32 </span>    <span class="subxComment"># f-&gt;read = 0</span>
<span id="L33" class="LineNr">33 </span>    c7          0/subop/copy        1/mod/*+disp8   0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>          4/disp8         0/imm32           <span class="subxComment"># copy to *(EAX+4)</span>
<span id="L34" class="LineNr">34 </span>    <span class="subxComment"># EAX = f-&gt;data</span>
<span id="L35" class="LineNr">35 </span>    81          0/subop/add         3/mod/direct    0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              0xc/imm32         <span class="subxComment"># add to EAX</span>
<span id="L36" class="LineNr">36 </span>    <span class="subxComment"># while (true)</span>
<span id="L37" class="LineNr">37 </span><span class="Constant">$clear-stream:loop</span>:
<span id="L38" class="LineNr">38 </span>    <span class="subxComment"># if (EAX &gt;= ECX) break</span>
<span id="L39" class="LineNr">39 </span>    39/compare                      3/mod/direct    0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          1/r32/ECX  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># compare EAX with ECX</span>
<span id="L40" class="LineNr">40 </span>    73/jump-if-greater-or-equal-unsigned  $clear-stream:end/disp8
<span id="L41" class="LineNr">41 </span>    <span class="subxComment"># *EAX = 0</span>
<span id="L42" class="LineNr">42 </span>    c6          0/subop/copy        0/mod/direct    0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>         <span class="Normal"> . </span>              0/imm8            <span class="subxComment"># copy byte to *EAX</span>
<span id="L43" class="LineNr">43 </span>    <span class="subxComment"># ++EAX</span>
<span id="L44" class="LineNr">44 </span>    40/increment-EAX
<span id="L45" class="LineNr">45 </span>    eb/jump  $clear-stream:loop/disp8
<span id="L46" class="LineNr">46 </span><span class="Constant">$clear-stream:end</span>:
<span id="L47" class="LineNr">47 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L48" class="LineNr">48 </span>    59/pop-to-ECX
<span id="L49" class="LineNr">49 </span>    58/pop-to-EAX
<span id="L50" class="LineNr">50 </span>    <span class="subxS1Comment"># . epilog</span>
<span id="L51" class="LineNr">51 </span>    89/copy                         3/mod/direct    4/rm32/ESP   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          5/r32/EBP  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy EBP to ESP</span>
<span id="L52" class="LineNr">52 </span>    5d/pop-to-EBP
<span id="L53" class="LineNr">53 </span>    c3/return
<span id="L54" class="LineNr">54 </span>
<span id="L55" class="LineNr">55 </span><span class="subxFunction">rewind-stream</span>:  <span class="subxComment"># f : (address stream) -&gt; &lt;void&gt;</span>
<span id="L56" class="LineNr">56 </span>    <span class="subxS1Comment"># . prolog</span>
<span id="L57" class="LineNr">57 </span>    55/push-EBP
<span id="L58" class="LineNr">58 </span>    89/copy                         3/mod/direct    5/rm32/EBP   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          4/r32/ESP  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy ESP to EBP</span>
<span id="L59" class="LineNr">59 </span>    <span class="subxS1Comment"># . save registers</span>
<span id="L60" class="LineNr">60 </span>    50/push-EAX
<span id="L61" class="LineNr">61 </span>    <span class="subxComment"># EAX = f</span>
<span id="L62" class="LineNr">62 </span>    8b/copy                         1/mod/*+disp8   5/rm32/EBP   <span class="Normal"> . </span>         <span class="Normal"> . </span>                        0/r32/EAX   8/disp8        <span class="Normal"> . </span>                <span class="subxComment"># copy *(EBP+8) to EAX</span>
<span id="L63" class="LineNr">63 </span>    <span class="subxComment"># f-&gt;read = 0</span>
<span id="L64" class="LineNr">64 </span>    c7          0/subop/copy        1/mod/*+disp8   0/rm32/EAX   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>         <span class="Normal"> . </span>          4/disp8         0/imm32           <span class="subxComment"># copy to *(EAX+4)</span>
<span id="L65" class="LineNr">65 </span><span class="Constant">$rewind-stream:end</span>:
<span id="L66" class="LineNr">66 </span>    <span class="subxS1Comment"># . restore registers</span>
<span id="L67" class="LineNr">67 </span>    58/pop-to-EAX
<span id="L68" class="LineNr">68 </span>    <span class="subxS1Comment"># . epilog</span>
<span id="L69" class="LineNr">69 </span>    89/copy                         3/mod/direct    4/rm32/ESP   <span class="Normal"> . </span>         <span class="Normal"> . </span>           <span class="Normal"> . </span>          5/r32/EBP  <span class="Normal"> . </span>             <span class="Normal"> . </span>                <span class="subxComment"># copy EBP to ESP</span>
<span id="L70" class="LineNr">70 </span>    5d/pop-to-EBP
<span id="L71" class="LineNr">71 </span>    c3/return
<span id="L72" class="LineNr">72 </span>
<span id="L73" class="LineNr">73 </span><span class="subxS2Comment"># . . vim&#0058;nowrap:textwidth=0</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->
class="s">"L41" class="LineNr"> 41 </span> <span class="Comment">// End instruction Fields</span> <span id="L42" class="LineNr"> 42 </span> <a href='010vm.cc.html#L33'>instruction</a><span class="Delimiter">();</span> <span id="L43" class="LineNr"> 43 </span> <span class="Normal">void</span> <a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L44" class="LineNr"> 44 </span> <span class="Normal">bool</span> is_empty<span class="Delimiter">();</span> <span id="L45" class="LineNr"> 45 </span><span class="Delimiter">};</span> <span id="L46" class="LineNr"> 46 </span> <span id="L47" class="LineNr"> 47 </span><span class="Delimiter">:(before &quot;struct instruction&quot;)</span> <span id="L48" class="LineNr"> 48 </span><span class="Comment">// Ingredients and products are a single species -- a reagent. Reagents refer</span> <span id="L49" class="LineNr"> 49 </span><span class="Comment">// either to numbers or to locations in memory along with 'type' tags telling</span> <span id="L50" class="LineNr"> 50 </span><span class="Comment">// us how to interpret them. They also can contain arbitrary other lists of</span> <span id="L51" class="LineNr"> 51 </span><span class="Comment">// properties besides types, but we're getting ahead of ourselves.</span> <span id="L52" class="LineNr"> 52 </span><span class="Normal">struct</span> reagent <span class="Delimiter">{</span> <span id="L53" class="LineNr"> 53 </span> string original_string<span class="Delimiter">;</span> <span id="L54" class="LineNr"> 54 </span> string name<span class="Delimiter">;</span> <span id="L55" class="LineNr"> 55 </span> type_tree* type<span class="Delimiter">;</span> <span id="L56" class="LineNr"> 56 </span> vector&lt;pair&lt;string<span class="Delimiter">,</span> string_tree*&gt; &gt; properties<span class="Delimiter">;</span> <span class="Comment">// can't be a map because the string_tree sometimes needs to be NULL, which can be confusing</span> <span id="L57" class="LineNr"> 57 </span> <span class="Normal">double</span> value<span class="Delimiter">;</span> <span id="L58" class="LineNr"> 58 </span> <span class="Normal">bool</span> initialized<span class="Delimiter">;</span> <span id="L59" class="LineNr"> 59 </span> <span class="Comment">// End reagent Fields</span> <span id="L60" class="LineNr"> 60 </span> reagent<span class="Delimiter">(</span><span class="Normal">const</span> string&amp; s<span class="Delimiter">);</span> <span id="L61" class="LineNr"> 61 </span> reagent<span class="Delimiter">()</span> :type<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">),</span> value<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">),</span> initialized<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L62" class="LineNr"> 62 </span> reagent<span class="Delimiter">(</span>type_tree* t<span class="Delimiter">)</span> :type<span class="Delimiter">(</span>t<span class="Delimiter">),</span> value<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">),</span> initialized<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L63" class="LineNr"> 63 </span> ~reagent<span class="Delimiter">();</span> <span id="L64" class="LineNr"> 64 </span> <span class="Normal">void</span> <a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L65" class="LineNr"> 65 </span> reagent<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; original<span class="Delimiter">);</span> <span id="L66" class="LineNr"> 66 </span> reagent&amp; <span class="Normal">operator</span>=<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; original<span class="Delimiter">);</span> <span id="L67" class="LineNr"> 67 </span> <span class="Normal">void</span> <a href='010vm.cc.html#L67'>set_value</a><span class="Delimiter">(</span><span class="Normal">double</span> v<span class="Delimiter">)</span> <span class="Delimiter">{</span> value = v<span class="Delimiter">;</span> initialized =<span class="Constant"> true</span><span class="Delimiter">;</span> <span class="Delimiter">}</span> <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="Delimiter">:(before &quot;struct reagent&quot;)</span> <span id="L71" class="LineNr"> 71 </span><span class="Comment">// Types can range from a simple type ordinal, to arbitrarily complex trees of</span> <span id="L72" class="LineNr"> 72 </span><span class="Comment">// type parameters, like (map (address array character) (list number))</span> <span id="L73" class="LineNr"> 73 </span><span class="Normal">struct</span> type_tree <span class="Delimiter">{</span> <span id="L74" class="LineNr"> 74 </span> <span class="Normal">bool</span> atom<span class="Delimiter">;</span> <span id="L75" class="LineNr"> 75 </span> string name<span class="Delimiter">;</span> <span class="Comment">// only if atom</span> <span id="L76" class="LineNr"> 76 </span> <a href='010vm.cc.html#L125'>type_ordinal</a> value<span class="Delimiter">;</span> <span class="Comment">// only if atom</span> <span id="L77" class="LineNr"> 77 </span> type_tree* left<span class="Delimiter">;</span> <span class="Comment">// only if !atom</span> <span id="L78" class="LineNr"> 78 </span> type_tree* right<span class="Delimiter">;</span> <span class="Comment">// only if !atom</span> <span id="L79" class="LineNr"> 79 </span> ~type_tree<span class="Delimiter">();</span> <span id="L80" class="LineNr"> 80 </span> type_tree<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; original<span class="Delimiter">);</span> <span id="L81" class="LineNr"> 81 </span> <span class="Comment">// atomic type ordinal</span> <span id="L82" class="LineNr"> 82 </span> <span class="Normal">explicit</span> type_tree<span class="Delimiter">(</span>string name<span class="Delimiter">);</span> <span id="L83" class="LineNr"> 83 </span> type_tree<span class="Delimiter">(</span>string name<span class="Delimiter">,</span> <a href='010vm.cc.html#L125'>type_ordinal</a> v<span class="Delimiter">)</span> :atom<span class="Delimiter">(</span><span class="Constant">true</span><span class="Delimiter">),</span> name<span class="Delimiter">(</span>name<span class="Delimiter">),</span> value<span class="Delimiter">(</span>v<span class="Delimiter">),</span> left<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">),</span> right<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L84" class="LineNr"> 84 </span> <span class="Comment">// tree of type ordinals</span> <span id="L85" class="LineNr"> 85 </span> type_tree<span class="Delimiter">(</span>type_tree* l<span class="Delimiter">,</span> type_tree* r<span class="Delimiter">)</span> :atom<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">),</span> value<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">),</span> left<span class="Delimiter">(</span>l<span class="Delimiter">),</span> right<span class="Delimiter">(</span>r<span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L86" class="LineNr"> 86 </span> type_tree&amp; <span class="Normal">operator</span>=<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; original<span class="Delimiter">);</span> <span id="L87" class="LineNr"> 87 </span> <span class="Normal">bool</span> <span class="Normal">operator</span>==<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span><span class="Delimiter">;</span> <span id="L88" class="LineNr"> 88 </span> <span class="Normal">bool</span> <span class="Normal">operator</span>!=<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span> <span class="Delimiter">{</span> <span class="Identifier">return</span> !<span class="Normal">operator</span>==<span class="Delimiter">(</span>other<span class="Delimiter">);</span> <span class="Delimiter">}</span> <span id="L89" class="LineNr"> 89 </span> <span class="Normal">bool</span> <span class="Normal">operator</span>&lt;<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span><span class="Delimiter">;</span> <span id="L90" class="LineNr"> 90 </span> <span class="Normal">bool</span> <span class="Normal">operator</span>&gt;<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span> <span class="Delimiter">{</span> <span class="Identifier">return</span> other<span class="Delimiter">.</span><span class="Normal">operator</span>&lt;<span class="Delimiter">(</span>*<span class="Normal">this</span><span class="Delimiter">);</span> <span class="Delimiter">}</span> <span id="L91" class="LineNr"> 91 </span><span class="Delimiter">};</span> <span id="L92" class="LineNr"> 92 </span> <span id="L93" class="LineNr"> 93 </span><span class="Normal">struct</span> string_tree <span class="Delimiter">{</span> <span id="L94" class="LineNr"> 94 </span> <span class="Normal">bool</span> atom<span class="Delimiter">;</span> <span id="L95" class="LineNr"> 95 </span> string value<span class="Delimiter">;</span> <span class="Comment">// only if atom</span> <span id="L96" class="LineNr"> 96 </span> string_tree* left<span class="Delimiter">;</span> <span class="Comment">// only if !atom</span> <span id="L97" class="LineNr"> 97 </span> string_tree* right<span class="Delimiter">;</span> <span class="Comment">// only if !atom</span> <span id="L98" class="LineNr"> 98 </span> ~string_tree<span class="Delimiter">();</span> <span id="L99" class="LineNr"> 99 </span> string_tree<span class="Delimiter">(</span><span class="Normal">const</span> string_tree&amp; original<span class="Delimiter">);</span> <span id="L100" class="LineNr">100 </span> <span class="Comment">// atomic string</span> <span id="L101" class="LineNr">101 </span> <span class="Normal">explicit</span> string_tree<span class="Delimiter">(</span>string v<span class="Delimiter">)</span> :atom<span class="Delimiter">(</span><span class="Constant">true</span><span class="Delimiter">),</span> value<span class="Delimiter">(</span>v<span class="Delimiter">),</span> left<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">),</span> right<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L102" class="LineNr">102 </span> <span class="Comment">// tree of strings</span> <span id="L103" class="LineNr">103 </span> string_tree<span class="Delimiter">(</span>string_tree* l<span class="Delimiter">,</span> string_tree* r<span class="Delimiter">)</span> :atom<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">),</span> left<span class="Delimiter">(</span>l<span class="Delimiter">),</span> right<span class="Delimiter">(</span>r<span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L104" class="LineNr">104 </span><span class="Delimiter">};</span> <span id="L105" class="LineNr">105 </span> <span id="L106" class="LineNr">106 </span><span class="Comment">// End type_tree Definition</span> <span id="L107" class="LineNr">107 </span><span class="Delimiter">:(code)</span> <span id="L108" class="LineNr">108 </span>type_tree::type_tree<span class="Delimiter">(</span>string name<span class="Delimiter">)</span> :atom<span class="Delimiter">(</span><span class="Constant">true</span><span class="Delimiter">),</span> name<span class="Delimiter">(</span>name<span class="Delimiter">),</span> value<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> name<span class="Delimiter">)),</span> left<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">),</span> right<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L109" class="LineNr">109 </span> <span id="L110" class="LineNr">110 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span> <span id="L111" class="LineNr">111 </span><span class="Comment">// Locations refer to a common 'memory'. Each location can store a number.</span> <span id="L112" class="LineNr">112 </span>map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">double</span>&gt; Memory<span class="Delimiter">;</span> <span id="L113" class="LineNr">113 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span> <span id="L114" class="LineNr">114 </span>Memory<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L115" class="LineNr">115 </span> <span id="L116" class="LineNr">116 </span><span class="Delimiter">:(after &quot;Types&quot;)</span> <span id="L117" class="LineNr">117 </span><span class="Comment">// Mu types encode how the numbers stored in different parts of memory are</span> <span id="L118" class="LineNr">118 </span><span class="Comment">// interpreted. A location tagged as a 'character' type will interpret the</span> <span id="L119" class="LineNr">119 </span><span class="Comment">// value 97 as the letter 'a', while a different location of type 'number'</span> <span id="L120" class="LineNr">120 </span><span class="Comment">// would not.</span> <span id="L121" class="LineNr">121 </span><span class="Comment">//</span> <span id="L122" class="LineNr">122 </span><span class="Comment">// Unlike most computers today, Mu stores types in a single big table, shared</span> <span id="L123" class="LineNr">123 </span><span class="Comment">// by all the Mu programs on the computer. This is useful in providing a</span> <span id="L124" class="LineNr">124 </span><span class="Comment">// seamless experience to help understand arbitrary Mu programs.</span> <span id="L125" class="LineNr">125 </span><span class="Normal">typedef</span> <span class="Normal">int</span> <a href='010vm.cc.html#L125'>type_ordinal</a><span class="Delimiter">;</span> <span id="L126" class="LineNr">126 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span> <span id="L127" class="LineNr">127 </span>map&lt;string<span class="Delimiter">,</span> type_ordinal&gt; Type_ordinal<span class="Delimiter">;</span> <span id="L128" class="LineNr">128 </span>map&lt;type_ordinal<span class="Delimiter">,</span> type_info&gt; Type<span class="Delimiter">;</span> <span id="L129" class="LineNr">129 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Next_type_ordinal = <span class="Constant">1</span><span class="Delimiter">;</span> <span id="L130" class="LineNr">130 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Number_type_ordinal = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L131" class="LineNr">131 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Boolean_type_ordinal = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L132" class="LineNr">132 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Character_type_ordinal = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L133" class="LineNr">133 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Address_type_ordinal = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L134" class="LineNr">134 </span><a href='010vm.cc.html#L125'>type_ordinal</a> Array_type_ordinal = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L135" class="LineNr">135 </span><span class="Delimiter">:(code)</span> <span id="L136" class="LineNr">136 </span><span class="Normal">void</span> <a href='010vm.cc.html#L136'>setup_types</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L137" class="LineNr">137 </span> Type<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> Type_ordinal<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L138" class="LineNr">138 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;literal&quot;</span><span class="Delimiter">,</span> <span class="Constant">0</span><span class="Delimiter">);</span> <span id="L139" class="LineNr">139 </span> Next_type_ordinal = <span class="Constant">1</span><span class="Delimiter">;</span> <span id="L140" class="LineNr">140 </span> <span class="Comment">// Mu Types Initialization</span> <span id="L141" class="LineNr">141 </span> Number_type_ordinal = <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;number&quot;</span><span class="Delimiter">,</span> Next_type_ordinal++<span class="Delimiter">);</span> <span id="L142" class="LineNr">142 </span> <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Number_type_ordinal<span class="Delimiter">).</span>name = <span class="Constant">&quot;number&quot;</span><span class="Delimiter">;</span> <span id="L143" class="LineNr">143 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;location&quot;</span><span class="Delimiter">,</span> Number_type_ordinal<span class="Delimiter">);</span> <span class="Comment">// synonym of number for addresses we'll never look up</span> <span id="L144" class="LineNr">144 </span> Address_type_ordinal = <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;address&quot;</span><span class="Delimiter">,</span> Next_type_ordinal++<span class="Delimiter">);</span> <span id="L145" class="LineNr">145 </span> <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Address_type_ordinal<span class="Delimiter">).</span>name = <span class="Constant">&quot;address&quot;</span><span class="Delimiter">;</span> <span id="L146" class="LineNr">146 </span> Boolean_type_ordinal = <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;boolean&quot;</span><span class="Delimiter">,</span> Next_type_ordinal++<span class="Delimiter">);</span> <span id="L147" class="LineNr">147 </span> <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Boolean_type_ordinal<span class="Delimiter">).</span>name = <span class="Constant">&quot;boolean&quot;</span><span class="Delimiter">;</span> <span id="L148" class="LineNr">148 </span> Character_type_ordinal = <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;character&quot;</span><span class="Delimiter">,</span> Next_type_ordinal++<span class="Delimiter">);</span> <span id="L149" class="LineNr">149 </span> <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Character_type_ordinal<span class="Delimiter">).</span>name = <span class="Constant">&quot;character&quot;</span><span class="Delimiter">;</span> <span id="L150" class="LineNr">150 </span> <span class="Comment">// Array types are a special modifier to any other type. For example,</span> <span id="L151" class="LineNr">151 </span> <span class="Comment">// array:number or array:address:boolean.</span> <span id="L152" class="LineNr">152 </span> Array_type_ordinal = <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;array&quot;</span><span class="Delimiter">,</span> Next_type_ordinal++<span class="Delimiter">);</span> <span id="L153" class="LineNr">153 </span> <a href='001help.cc.html#L229'>get_or_insert</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> Array_type_ordinal<span class="Delimiter">).</span>name = <span class="Constant">&quot;array&quot;</span><span class="Delimiter">;</span> <span id="L154" class="LineNr">154 </span> <span class="Comment">// End Mu Types Initialization</span> <span id="L155" class="LineNr">155 </span><span class="Delimiter">}</span> <span id="L156" class="LineNr">156 </span><span class="Normal">void</span> <a href='010vm.cc.html#L156'>teardown_types</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L157" class="LineNr">157 </span> <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;type_ordinal<span class="Delimiter">,</span> type_info&gt;::iterator p = Type<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Type<span class="Delimiter">.</span><a href='003trace.cc.html#L225'>end</a><span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L158" class="LineNr">158 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">.</span>elements<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L159" class="LineNr">159 </span> p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">.</span>elements<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L160" class="LineNr">160 </span> <span class="Delimiter">}</span> <span id="L161" class="LineNr">161 </span> Type_ordinal<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L162" class="LineNr">162 </span><span class="Delimiter">}</span> <span id="L163" class="LineNr">163 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span> <span id="L164" class="LineNr">164 </span><a href='010vm.cc.html#L136'>setup_types</a><span class="Delimiter">();</span> <span id="L165" class="LineNr">165 </span>atexit<span class="Delimiter">(</span><a href='010vm.cc.html#L156'>teardown_types</a><span class="Delimiter">);</span> <span id="L166" class="LineNr">166 </span> <span id="L167" class="LineNr">167 </span><span class="Delimiter">:(before &quot;End Types&quot;)</span> <span id="L168" class="LineNr">168 </span><span class="Comment">// You can construct arbitrary new types. New types are either 'containers'</span> <span id="L169" class="LineNr">169 </span><span class="Comment">// with multiple 'elements' of other types, or 'exclusive containers' containing</span> <span id="L170" class="LineNr">170 </span><span class="Comment">// one of multiple 'variants'. (These are similar to C structs and unions,</span> <span id="L171" class="LineNr">171 </span><span class="Comment">// respectively, though exclusive containers implicitly include a tag element</span> <span id="L172" class="LineNr">172 </span><span class="Comment">// recording which variant they should be interpreted as.)</span> <span id="L173" class="LineNr">173 </span><span class="Comment">//</span> <span id="L174" class="LineNr">174 </span><span class="Comment">// For example, storing bank balance and name for an account might require a</span> <span id="L175" class="LineNr">175 </span><span class="Comment">// container, but if bank accounts may be either for individuals or groups,</span> <span id="L176" class="LineNr">176 </span><span class="Comment">// with different properties for each, that may require an exclusive container</span> <span id="L177" class="LineNr">177 </span><span class="Comment">// whose variants are individual-account and joint-account containers.</span> <span id="L178" class="LineNr">178 </span><span class="Normal">enum</span> <a href='010vm.cc.html#L178'>kind_of_type</a> <span class="Delimiter">{</span> <span id="L179" class="LineNr">179 </span> <a href='010vm.cc.html#L179'>PRIMITIVE</a><span class="Delimiter">,</span> <span id="L180" class="LineNr">180 </span> <a href='010vm.cc.html#L180'>CONTAINER</a><span class="Delimiter">,</span> <span id="L181" class="LineNr">181 </span> <a href='010vm.cc.html#L181'>EXCLUSIVE_CONTAINER</a> <span id="L182" class="LineNr">182 </span><span class="Delimiter">};</span> <span id="L183" class="LineNr">183 </span> <span id="L184" class="LineNr">184 </span><span class="Normal">struct</span> type_info <span class="Delimiter">{</span> <span id="L185" class="LineNr">185 </span> string name<span class="Delimiter">;</span> <span id="L186" class="LineNr">186 </span> <a href='010vm.cc.html#L178'>kind_of_type</a> kind<span class="Delimiter">;</span> <span id="L187" class="LineNr">187 </span> vector&lt;reagent&gt; elements<span class="Delimiter">;</span> <span id="L188" class="LineNr">188 </span> <span class="Comment">// End type_info Fields</span> <span id="L189" class="LineNr">189 </span> type_info<span class="Delimiter">()</span> :kind<span class="Delimiter">(</span><a href='010vm.cc.html#L179'>PRIMITIVE</a><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L190" class="LineNr">190 </span> <span class="Comment">// End type_info Constructor</span> <span id="L191" class="LineNr">191 </span> <span class="Delimiter">}</span> <span id="L192" class="LineNr">192 </span><span class="Delimiter">};</span> <span id="L193" class="LineNr">193 </span> <span id="L194" class="LineNr">194 </span><span class="Normal">enum</span> <a href='010vm.cc.html#L194'>primitive_recipes</a> <span class="Delimiter">{</span> <span id="L195" class="LineNr">195 </span> <a href='010vm.cc.html#L195'>IDLE</a> = <span class="Constant">0</span><span class="Delimiter">,</span> <span id="L196" class="LineNr">196 </span> <a href='010vm.cc.html#L196'>COPY</a><span class="Delimiter">,</span> <span id="L197" class="LineNr">197 </span> <span class="Comment">// End Primitive Recipe Declarations</span> <span id="L198" class="LineNr">198 </span> <a href='010vm.cc.html#L198'>MAX_PRIMITIVE_RECIPES</a><span class="Delimiter">,</span> <span id="L199" class="LineNr">199 </span><span class="Delimiter">};</span> <span id="L200" class="LineNr">200 </span><span class="Delimiter">:(code)</span> <span id="L201" class="LineNr">201 </span><span class="Comment">//: It's all very well to construct recipes out of other recipes, but we need</span> <span id="L202" class="LineNr">202 </span><span class="Comment">//: to know how to do *something* out of the box. For the following</span> <span id="L203" class="LineNr">203 </span><span class="Comment">//: recipes there are only codes, no entries in the book, because Mu just knows</span> <span id="L204" class="LineNr">204 </span><span class="Comment">//: what to do for them.</span> <span id="L205" class="LineNr">205 </span><span class="Normal">void</span> <a href='010vm.cc.html#L205'>setup_recipes</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L206" class="LineNr">206 </span> Recipe<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> Recipe_ordinal<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L207" class="LineNr">207 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;idle&quot;</span><span class="Delimiter">,</span> <a href='010vm.cc.html#L195'>IDLE</a><span class="Delimiter">);</span> <span id="L208" class="LineNr">208 </span> <span class="Comment">// Primitive Recipe Numbers</span> <span id="L209" class="LineNr">209 </span> <a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;copy&quot;</span><span class="Delimiter">,</span> <a href='010vm.cc.html#L196'>COPY</a><span class="Delimiter">);</span> <span id="L210" class="LineNr">210 </span> <span class="Comment">// End Primitive Recipe Numbers</span> <span id="L211" class="LineNr">211 </span><span class="Delimiter">}</span> <span id="L212" class="LineNr">212 </span><span class="Comment">//: We could just reset the recipe table after every test, but that gets slow</span> <span id="L213" class="LineNr">213 </span><span class="Comment">//: all too quickly. Instead, initialize the common stuff just once at</span> <span id="L214" class="LineNr">214 </span><span class="Comment">//: startup. Later layers will carefully undo each test's additions after</span> <span id="L215" class="LineNr">215 </span><span class="Comment">//: itself.</span> <span id="L216" class="LineNr">216 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span> <span id="L217" class="LineNr">217 </span><a href='010vm.cc.html#L205'>setup_recipes</a><span class="Delimiter">();</span> <span id="L218" class="LineNr">218 </span>assert<span class="Delimiter">(</span><a href='010vm.cc.html#L198'>MAX_PRIMITIVE_RECIPES</a> &lt; <span class="Constant">200</span><span class="Delimiter">);</span> <span class="Comment">// level 0 is primitives; until 199</span> <span id="L219" class="LineNr">219 </span>Next_recipe_ordinal = <span class="Constant">200</span><span class="Delimiter">;</span> <span id="L220" class="LineNr">220 </span><a href='001help.cc.html#L221'>put</a><span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;main&quot;</span><span class="Delimiter">,</span> Next_recipe_ordinal++<span class="Delimiter">);</span> <span id="L221" class="LineNr">221 </span><span class="Comment">// Load Mu Prelude</span> <span id="L222" class="LineNr">222 </span><span class="Comment">// End Mu Prelude</span> <span id="L223" class="LineNr">223 </span><span class="Delimiter">:(before &quot;End Commandline Parsing&quot;)</span> <span id="L224" class="LineNr">224 </span>assert<span class="Delimiter">(</span>Next_recipe_ordinal &lt; <span class="Constant">1000</span><span class="Delimiter">);</span> <span class="Comment">// recipes being tested didn't overflow into test space</span> <span id="L225" class="LineNr">225 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span> <span id="L226" class="LineNr">226 </span>Next_recipe_ordinal = <span class="Constant">1000</span><span class="Delimiter">;</span> <span class="Comment">// consistent new numbers for each test</span> <span id="L227" class="LineNr">227 </span> <span id="L228" class="LineNr">228 </span><span class="Comment">//: One final detail: tests can modify our global tables of recipes and types,</span> <span id="L229" class="LineNr">229 </span><span class="Comment">//: so we need some way to clean up after each test is done so it doesn't</span> <span id="L230" class="LineNr">230 </span><span class="Comment">//: influence later ones.</span> <span id="L231" class="LineNr">231 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span> <span id="L232" class="LineNr">232 </span>map&lt;string<span class="Delimiter">,</span> recipe_ordinal&gt; Recipe_ordinal_snapshot<span class="Delimiter">;</span> <span id="L233" class="LineNr">233 </span>map&lt;recipe_ordinal<span class="Delimiter">,</span> recipe&gt; Recipe_snapshot<span class="Delimiter">;</span> <span id="L234" class="LineNr">234 </span>map&lt;string<span class="Delimiter">,</span> type_ordinal&gt; Type_ordinal_snapshot<span class="Delimiter">;</span> <span id="L235" class="LineNr">235 </span>map&lt;type_ordinal<span class="Delimiter">,</span> type_info&gt; Type_snapshot<span class="Delimiter">;</span> <span id="L236" class="LineNr">236 </span><span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span> <span id="L237" class="LineNr">237 </span>save_snapshots<span class="Delimiter">();</span> <span id="L238" class="LineNr">238 </span><span class="Delimiter">:(before &quot;End Reset&quot;)</span> <span id="L239" class="LineNr">239 </span>restore_snapshots<span class="Delimiter">();</span> <span id="L240" class="LineNr">240 </span> <span id="L241" class="LineNr">241 </span><span class="Delimiter">:(code)</span> <span id="L242" class="LineNr">242 </span><span class="Normal">void</span> save_snapshots<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L243" class="LineNr">243 </span> Recipe_ordinal_snapshot = Recipe_ordinal<span class="Delimiter">;</span> <span id="L244" class="LineNr">244 </span> Recipe_snapshot = Recipe<span class="Delimiter">;</span> <span id="L245" class="LineNr">245 </span> Type_ordinal_snapshot = Type_ordinal<span class="Delimiter">;</span> <span id="L246" class="LineNr">246 </span> Type_snapshot = Type<span class="Delimiter">;</span> <span id="L247" class="LineNr">247 </span> <span class="Comment">// End save_snapshots</span> <span id="L248" class="LineNr">248 </span><span class="Delimiter">}</span> <span id="L249" class="LineNr">249 </span> <span id="L250" class="LineNr">250 </span><span class="Normal">void</span> restore_snapshots<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L251" class="LineNr">251 </span> Recipe = Recipe_snapshot<span class="Delimiter">;</span> <span id="L252" class="LineNr">252 </span> Recipe_ordinal = Recipe_ordinal_snapshot<span class="Delimiter">;</span> <span id="L253" class="LineNr">253 </span> restore_non_recipe_snapshots<span class="Delimiter">();</span> <span id="L254" class="LineNr">254 </span><span class="Delimiter">}</span> <span id="L255" class="LineNr">255 </span><span class="Comment">// when running sandboxes in the edit/ app we'll want to restore everything except recipes defined in the app</span> <span id="L256" class="LineNr">256 </span><span class="Normal">void</span> restore_non_recipe_snapshots<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L257" class="LineNr">257 </span> Type_ordinal = Type_ordinal_snapshot<span class="Delimiter">;</span> <span id="L258" class="LineNr">258 </span> Type = Type_snapshot<span class="Delimiter">;</span> <span id="L259" class="LineNr">259 </span> <span class="Comment">// End restore_snapshots</span> <span id="L260" class="LineNr">260 </span><span class="Delimiter">}</span> <span id="L261" class="LineNr">261 </span> <span id="L262" class="LineNr">262 </span><span class="SalientComment">//:: Helpers</span> <span id="L263" class="LineNr">263 </span> <span id="L264" class="LineNr">264 </span><span class="Delimiter">:(code)</span> <span id="L265" class="LineNr">265 </span><span class="muRecipe"><a href='010vm.cc.html#L19'>recipe</a></span>::<a href='010vm.cc.html#L19'>recipe</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L266" class="LineNr">266 </span> ordinal = -<span class="Constant">1</span><span class="Delimiter">;</span> <span id="L267" class="LineNr">267 </span> <span class="Comment">// End recipe Constructor</span> <span id="L268" class="LineNr">268 </span><span class="Delimiter">}</span> <span id="L269" class="LineNr">269 </span> <span id="L270" class="LineNr">270 </span><a href='010vm.cc.html#L33'>instruction</a>::<a href='010vm.cc.html#L33'>instruction</a><span class="Delimiter">()</span> :is_label<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">),</span> operation<span class="Delimiter">(</span><a href='010vm.cc.html#L195'>IDLE</a><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L271" class="LineNr">271 </span> <span class="Comment">// End instruction Constructor</span> <span id="L272" class="LineNr">272 </span><span class="Delimiter">}</span> <span id="L273" class="LineNr">273 </span><span class="Normal">void</span> <a href='010vm.cc.html#L33'>instruction</a>::<a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L274" class="LineNr">274 </span> is_label=<span class="Constant">false</span><span class="Delimiter">;</span> <span id="L275" class="LineNr">275 </span> label<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L276" class="LineNr">276 </span> name<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L277" class="LineNr">277 </span> operation=IDLE<span class="Delimiter">;</span> <span id="L278" class="LineNr">278 </span> ingredients<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L279" class="LineNr">279 </span> products<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L280" class="LineNr">280 </span> original_string<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L281" class="LineNr">281 </span> <span class="Comment">// End instruction Clear</span> <span id="L282" class="LineNr">282 </span><span class="Delimiter">}</span> <span id="L283" class="LineNr">283 </span><span class="Normal">bool</span> <a href='010vm.cc.html#L33'>instruction</a>::is_empty<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span class="Identifier">return</span> !is_label &amp;&amp; name<span class="Delimiter">.</span>empty<span class="Delimiter">();</span> <span class="Delimiter">}</span> <span id="L284" class="LineNr">284 </span> <span id="L285" class="LineNr">285 </span><span class="Comment">// Reagents have the form &lt;name&gt;:&lt;type&gt;:&lt;type&gt;:.../&lt;property&gt;/&lt;property&gt;/...</span> <span id="L286" class="LineNr">286 </span>reagent::reagent<span class="Delimiter">(</span><span class="Normal">const</span> string&amp; s<span class="Delimiter">)</span> :original_string<span class="Delimiter">(</span>s<span class="Delimiter">),</span> type<span class="Delimiter">(</span><span class="Constant">NULL</span><span class="Delimiter">),</span> value<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">),</span> initialized<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L287" class="LineNr">287 </span> <span class="Comment">// Parsing reagent(string s)</span> <span id="L288" class="LineNr">288 </span> istringstream in<span class="Delimiter">(</span>s<span class="Delimiter">);</span> <span id="L289" class="LineNr">289 </span> in &gt;&gt; std::noskipws<span class="Delimiter">;</span> <span id="L290" class="LineNr">290 </span> <span class="Comment">// name and type</span> <span id="L291" class="LineNr">291 </span> istringstream first_row<span class="Delimiter">(</span>slurp_until<span class="Delimiter">(</span>in<span class="Delimiter">,</span> <span class="Constant">'/'</span><span class="Delimiter">));</span> <span id="L292" class="LineNr">292 </span> first_row &gt;&gt; std::noskipws<span class="Delimiter">;</span> <span id="L293" class="LineNr">293 </span> name = slurp_until<span class="Delimiter">(</span>first_row<span class="Delimiter">,</span> <span class="Constant">':'</span><span class="Delimiter">);</span> <span id="L294" class="LineNr">294 </span> string_tree* type_names = parse_property_list<span class="Delimiter">(</span>first_row<span class="Delimiter">);</span> <span id="L295" class="LineNr">295 </span> <span class="Comment">// End Parsing Reagent Type Property(type_names)</span> <span id="L296" class="LineNr">296 </span> type = <a href='019type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span>type_names<span class="Delimiter">);</span> <span id="L297" class="LineNr">297 </span> <span class="Normal">delete</span> type_names<span class="Delimiter">;</span> <span id="L298" class="LineNr">298 </span> <span class="Comment">// special cases</span> <span id="L299" class="LineNr">299 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span>name<span class="Delimiter">)</span> &amp;&amp; type == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span id="L300" class="LineNr">300 </span> type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Constant">&quot;literal&quot;</span><span class="Delimiter">);</span> <span id="L301" class="LineNr">301 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>name == <span class="Constant">&quot;_&quot;</span> &amp;&amp; type == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span id="L302" class="LineNr">302 </span> type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Constant">&quot;literal&quot;</span><span class="Delimiter">);</span> <span id="L303" class="LineNr">303 </span> <span class="Comment">// other properties</span> <span id="L304" class="LineNr">304 </span> slurp_properties<span class="Delimiter">(</span>in<span class="Delimiter">,</span> properties<span class="Delimiter">);</span> <span id="L305" class="LineNr">305 </span> <span class="Comment">// End Parsing reagent</span> <span id="L306" class="LineNr">306 </span><span class="Delimiter">}</span> <span id="L307" class="LineNr">307 </span> <span id="L308" class="LineNr">308 </span><span class="Normal">void</span> slurp_properties<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> vector&lt;pair&lt;string<span class="Delimiter">,</span> string_tree*&gt; &gt;&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L309" class="LineNr">309 </span> <span class="Normal">while</span> <span class="Delimiter">(</span><a href='001help.cc.html#L239'>has_data</a><span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L310" class="LineNr">310 </span> istringstream row<span class="Delimiter">(</span>slurp_until<span class="Delimiter">(</span>in<span class="Delimiter">,</span> <span class="Constant">'/'</span><span class="Delimiter">));</span> <span id="L311" class="LineNr">311 </span> row &gt;&gt; std::noskipws<span class="Delimiter">;</span> <span id="L312" class="LineNr">312 </span> string key = slurp_until<span class="Delimiter">(</span>row<span class="Delimiter">,</span> <span class="Constant">':'</span><span class="Delimiter">);</span> <span id="L313" class="LineNr">313 </span> string_tree* value = parse_property_list<span class="Delimiter">(</span>row<span class="Delimiter">);</span> <span id="L314" class="LineNr">314 </span> out<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span>key<span class="Delimiter">,</span> value<span class="Delimiter">));</span> <span id="L315" class="LineNr">315 </span> <span class="Delimiter">}</span> <span id="L316" class="LineNr">316 </span><span class="Delimiter">}</span> <span id="L317" class="LineNr">317 </span> <span id="L318" class="LineNr">318 </span>string_tree* parse_property_list<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L319" class="LineNr">319 </span> skip_whitespace_but_not_newline<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L320" class="LineNr">320 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!has_data<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L321" class="LineNr">321 </span> string_tree* first = <span class="Normal">new</span> string_tree<span class="Delimiter">(</span>slurp_until<span class="Delimiter">(</span>in<span class="Delimiter">,</span> <span class="Constant">':'</span><span class="Delimiter">));</span> <span id="L322" class="LineNr">322 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!has_data<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Identifier">return</span> first<span class="Delimiter">;</span> <span id="L323" class="LineNr">323 </span> string_tree* rest = parse_property_list<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L324" class="LineNr">324 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!has_data<span class="Delimiter">(</span>in<span class="Delimiter">)</span> &amp;&amp; rest<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span id="L325" class="LineNr">325 </span> <span class="Identifier">return</span> <span class="Normal">new</span> string_tree<span class="Delimiter">(</span>first<span class="Delimiter">,</span> <span class="Normal">new</span> string_tree<span class="Delimiter">(</span>rest<span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span> <span id="L326" class="LineNr">326 </span> <span class="Identifier">return</span> <span class="Normal">new</span> string_tree<span class="Delimiter">(</span>first<span class="Delimiter">,</span> rest<span class="Delimiter">);</span> <span id="L327" class="LineNr">327 </span><span class="Delimiter">}</span> <span id="L328" class="LineNr">328 </span><span class="Delimiter">:(before &quot;End Unit Tests&quot;)</span> <span id="L329" class="LineNr">329 </span><span class="Normal">void</span> test_parse_property_list_atom<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L330" class="LineNr">330 </span> istringstream in<span class="Delimiter">(</span><span class="Constant">&quot;a&quot;</span><span class="Delimiter">);</span> <span id="L331" class="LineNr">331 </span> string_tree* x = parse_property_list<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L332" class="LineNr">332 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">);</span> <span id="L333" class="LineNr">333 </span> <span class="Normal">delete</span> x<span class="Delimiter">;</span> <span id="L334" class="LineNr">334 </span><span class="Delimiter">}</span> <span id="L335" class="LineNr">335 </span><span class="Normal">void</span> test_parse_property_list_list<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L336" class="LineNr">336 </span> istringstream in<span class="Delimiter">(</span><span class="Constant">&quot;a:b&quot;</span><span class="Delimiter">);</span> <span id="L337" class="LineNr">337 </span> string_tree* x = parse_property_list<span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L338" class="LineNr">338 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">);</span> <span id="L339" class="LineNr">339 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">);</span> <span id="L340" class="LineNr">340 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>value<span class="Delimiter">,</span> <span class="Constant">&quot;a&quot;</span><span class="Delimiter">);</span> <span id="L341" class="LineNr">341 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!x<span class="Delimiter">-&gt;</span>right<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">);</span> <span id="L342" class="LineNr">342 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>right<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">);</span> <span id="L343" class="LineNr">343 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>right<span class="Delimiter">-&gt;</span>left<span class="Delimiter">-&gt;</span>value<span class="Delimiter">,</span> <span class="Constant">&quot;b&quot;</span><span class="Delimiter">);</span> <span id="L344" class="LineNr">344 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>right<span class="Delimiter">-&gt;</span>right == <span class="Constant">NULL</span><span class="Delimiter">);</span> <span id="L345" class="LineNr">345 </span> <span class="Normal">delete</span> x<span class="Delimiter">;</span> <span id="L346" class="LineNr">346 </span><span class="Delimiter">}</span> <span id="L347" class="LineNr">347 </span> <span id="L348" class="LineNr">348 </span><span class="Delimiter">:(code)</span> <span id="L349" class="LineNr">349 </span>type_tree* <a href='019type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span><span class="Normal">const</span> string_tree* properties<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L350" class="LineNr">350 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!properties<span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L351" class="LineNr">351 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>properties<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L352" class="LineNr">352 </span> <span class="Normal">const</span> string&amp; type_name = properties<span class="Delimiter">-&gt;</span>value<span class="Delimiter">;</span> <span id="L353" class="LineNr">353 </span> <span class="Normal">int</span> value = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L354" class="LineNr">354 </span> <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L226'>contains_key</a><span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> type_name<span class="Delimiter">))</span> <span id="L355" class="LineNr">355 </span> value = get<span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">,</span> type_name<span class="Delimiter">);</span> <span id="L356" class="LineNr">356 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span>type_name<span class="Delimiter">))</span> <span class="Comment">// sometimes types will contain literal integers, like for the size of an array</span> <span id="L357" class="LineNr">357 </span> value = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L358" class="LineNr">358 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>properties<span class="Delimiter">-&gt;</span>value == <span class="Constant">&quot;-&gt;&quot;</span><span class="Delimiter">)</span> <span class="Comment">// used in recipe types</span> <span id="L359" class="LineNr">359 </span> value = <span class="Constant">0</span><span class="Delimiter">;</span> <span id="L360" class="LineNr">360 </span> <span class="Normal">else</span> <span id="L361" class="LineNr">361 </span> value = -<span class="Constant">1</span><span class="Delimiter">;</span> <span class="Comment">// should never happen; will trigger errors later</span> <span id="L362" class="LineNr">362 </span> <span class="Identifier">return</span> <span class="Normal">new</span> type_tree<span class="Delimiter">(</span>type_name<span class="Delimiter">,</span> value<span class="Delimiter">);</span> <span id="L363" class="LineNr">363 </span> <span class="Delimiter">}</span> <span id="L364" class="LineNr">364 </span> <span class="Identifier">return</span> <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><a href='019type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span>properties<span class="Delimiter">-&gt;</span>left<span class="Delimiter">),</span> <span id="L365" class="LineNr">365 </span> <a href='019type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span>properties<span class="Delimiter">-&gt;</span>right<span class="Delimiter">));</span> <span id="L366" class="LineNr">366 </span><span class="Delimiter">}</span> <span id="L367" class="LineNr">367 </span> <span id="L368" class="LineNr">368 </span><span class="Comment">//: avoid memory leaks for the type tree</span> <span id="L369" class="LineNr">369 </span> <span id="L370" class="LineNr">370 </span>reagent::reagent<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; other<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L371" class="LineNr">371 </span> original_string = other<span class="Delimiter">.</span>original_string<span class="Delimiter">;</span> <span id="L372" class="LineNr">372 </span> name = other<span class="Delimiter">.</span>name<span class="Delimiter">;</span> <span id="L373" class="LineNr">373 </span> value = other<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L374" class="LineNr">374 </span> initialized = other<span class="Delimiter">.</span>initialized<span class="Delimiter">;</span> <span id="L375" class="LineNr">375 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L376" class="LineNr">376 </span> properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first<span class="Delimiter">,</span> copy<span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)));</span> <span id="L377" class="LineNr">377 </span> <span class="Delimiter">}</span> <span id="L378" class="LineNr">378 </span> type = copy<span class="Delimiter">(</span>other<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L379" class="LineNr">379 </span> <span class="Comment">// End reagent Copy Constructor</span> <span id="L380" class="LineNr">380 </span><span class="Delimiter">}</span> <span id="L381" class="LineNr">381 </span> <span id="L382" class="LineNr">382 </span>type_tree::type_tree<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; original<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L383" class="LineNr">383 </span> atom = original<span class="Delimiter">.</span>atom<span class="Delimiter">;</span> <span id="L384" class="LineNr">384 </span> name = original<span class="Delimiter">.</span>name<span class="Delimiter">;</span> <span id="L385" class="LineNr">385 </span> value = original<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L386" class="LineNr">386 </span> left = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>left<span class="Delimiter">);</span> <span id="L387" class="LineNr">387 </span> right = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>right<span class="Delimiter">);</span> <span id="L388" class="LineNr">388 </span><span class="Delimiter">}</span> <span id="L389" class="LineNr">389 </span> <span id="L390" class="LineNr">390 </span>type_tree&amp; type_tree::<span class="Normal">operator</span>=<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; original<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L391" class="LineNr">391 </span> atom = original<span class="Delimiter">.</span>atom<span class="Delimiter">;</span> <span id="L392" class="LineNr">392 </span> name = original<span class="Delimiter">.</span>name<span class="Delimiter">;</span> <span id="L393" class="LineNr">393 </span> value = original<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L394" class="LineNr">394 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>left<span class="Delimiter">)</span> <span class="Normal">delete</span> left<span class="Delimiter">;</span> <span id="L395" class="LineNr">395 </span> left = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>left<span class="Delimiter">);</span> <span id="L396" class="LineNr">396 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>right<span class="Delimiter">)</span> <span class="Normal">delete</span> right<span class="Delimiter">;</span> <span id="L397" class="LineNr">397 </span> right = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>right<span class="Delimiter">);</span> <span id="L398" class="LineNr">398 </span> <span class="Identifier">return</span> *<span class="Normal">this</span><span class="Delimiter">;</span> <span id="L399" class="LineNr">399 </span><span class="Delimiter">}</span> <span id="L400" class="LineNr">400 </span> <span id="L401" class="LineNr">401 </span><span class="Normal">bool</span> type_tree::<span class="Normal">operator</span>==<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span> <span class="Delimiter">{</span> <span id="L402" class="LineNr">402 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>atom != other<span class="Delimiter">.</span>atom<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> false</span><span class="Delimiter">;</span> <span id="L403" class="LineNr">403 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>atom<span class="Delimiter">)</span> <span id="L404" class="LineNr">404 </span> <span class="Identifier">return</span> name == other<span class="Delimiter">.</span>name &amp;&amp; value == other<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L405" class="LineNr">405 </span> <span class="Identifier">return</span> <span class="Delimiter">(</span>left == other<span class="Delimiter">.</span>left || *left == *other<span class="Delimiter">.</span>left<span class="Delimiter">)</span> <span id="L406" class="LineNr">406 </span> &amp;&amp; <span class="Delimiter">(</span>right == other<span class="Delimiter">.</span>right || *right == *other<span class="Delimiter">.</span>right<span class="Delimiter">);</span> <span id="L407" class="LineNr">407 </span><span class="Delimiter">}</span> <span id="L408" class="LineNr">408 </span> <span id="L409" class="LineNr">409 </span><span class="Comment">// only constraint we care about: if a &lt; b then !(b &lt; a)</span> <span id="L410" class="LineNr">410 </span><span class="Normal">bool</span> type_tree::<span class="Normal">operator</span>&lt;<span class="Delimiter">(</span><span class="Normal">const</span> type_tree&amp; other<span class="Delimiter">)</span> <span class="Normal">const</span> <span class="Delimiter">{</span> <span id="L411" class="LineNr">411 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>atom != other<span class="Delimiter">.</span>atom<span class="Delimiter">)</span> <span class="Identifier">return</span> atom &gt; other<span class="Delimiter">.</span>atom<span class="Delimiter">;</span> <span class="Comment">// atoms before non-atoms</span> <span id="L412" class="LineNr">412 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>atom<span class="Delimiter">)</span> <span class="Identifier">return</span> value &lt; other<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L413" class="LineNr">413 </span> <span class="Comment">// first location in one that's missing in the other makes that side 'smaller'</span> <span id="L414" class="LineNr">414 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>left &amp;&amp; !other<span class="Delimiter">.</span>left<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> false</span><span class="Delimiter">;</span> <span id="L415" class="LineNr">415 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!left &amp;&amp; other<span class="Delimiter">.</span>left<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> true</span><span class="Delimiter">;</span> <span id="L416" class="LineNr">416 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>right &amp;&amp; !other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> false</span><span class="Delimiter">;</span> <span id="L417" class="LineNr">417 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!right &amp;&amp; other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> true</span><span class="Delimiter">;</span> <span id="L418" class="LineNr">418 </span> <span class="Comment">// now if either pointer is unequal neither side can be null</span> <span id="L419" class="LineNr">419 </span> <span class="Comment">// if one side is equal that's easy</span> <span id="L420" class="LineNr">420 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>left == other<span class="Delimiter">.</span>left || *left == *other<span class="Delimiter">.</span>left<span class="Delimiter">)</span> <span class="Identifier">return</span> right &amp;&amp; *right &lt; *other<span class="Delimiter">.</span>right<span class="Delimiter">;</span> <span id="L421" class="LineNr">421 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>right == other<span class="Delimiter">.</span>right || *right == *other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span class="Identifier">return</span> left &amp;&amp; *left &lt; *other<span class="Delimiter">.</span>left<span class="Delimiter">;</span> <span id="L422" class="LineNr">422 </span> <span class="Comment">// if the two sides criss-cross, pick the side with the smaller lhs</span> <span id="L423" class="LineNr">423 </span> <span class="Normal">if</span> <span class="Delimiter">((</span>left == other<span class="Delimiter">.</span>right || *left == *other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span id="L424" class="LineNr">424 </span> &amp;&amp; <span class="Delimiter">(</span>right == other<span class="Delimiter">.</span>left || *right == *other<span class="Delimiter">.</span>left<span class="Delimiter">))</span> <span id="L425" class="LineNr">425 </span> <span class="Identifier">return</span> *left &lt; *other<span class="Delimiter">.</span>left<span class="Delimiter">;</span> <span id="L426" class="LineNr">426 </span> <span class="Comment">// now the hard case: both sides are not equal</span> <span id="L427" class="LineNr">427 </span> <span class="Comment">// make sure we stay consistent between (a &lt; b) and (b &lt; a)</span> <span id="L428" class="LineNr">428 </span> <span class="Comment">// just return the side with the smallest of the 4 branches</span> <span id="L429" class="LineNr">429 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>*left &lt; *other<span class="Delimiter">.</span>left &amp;&amp; *left &lt; *other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> true</span><span class="Delimiter">;</span> <span id="L430" class="LineNr">430 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>*right &lt; *other<span class="Delimiter">.</span>left &amp;&amp; *right &lt; *other<span class="Delimiter">.</span>right<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> true</span><span class="Delimiter">;</span> <span id="L431" class="LineNr">431 </span> <span class="Identifier">return</span><span class="Constant"> false</span><span class="Delimiter">;</span> <span id="L432" class="LineNr">432 </span><span class="Delimiter">}</span> <span id="L433" class="LineNr">433 </span><span class="Delimiter">:(before &quot;End Unit Tests&quot;)</span> <span id="L434" class="LineNr">434 </span><span class="Comment">// These unit tests don't always use valid types.</span> <span id="L435" class="LineNr">435 </span><span class="Normal">void</span> test_compare_atom_types<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L436" class="LineNr">436 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:address&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:boolean&quot;</span><span class="Delimiter">);</span> <span id="L437" class="LineNr">437 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L438" class="LineNr">438 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L439" class="LineNr">439 </span><span class="Delimiter">}</span> <span id="L440" class="LineNr">440 </span><span class="Normal">void</span> test_compare_equal_atom_types<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L441" class="LineNr">441 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:address&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:address&quot;</span><span class="Delimiter">);</span> <span id="L442" class="LineNr">442 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L443" class="LineNr">443 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L444" class="LineNr">444 </span><span class="Delimiter">}</span> <span id="L445" class="LineNr">445 </span><span class="Normal">void</span> test_compare_atom_with_non_atom<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L446" class="LineNr">446 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:<a href='043space.cc.html#L101'>address</a>:number&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:boolean&quot;</span><span class="Delimiter">);</span> <span id="L447" class="LineNr">447 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L448" class="LineNr">448 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L449" class="LineNr">449 </span><span class="Delimiter">}</span> <span id="L450" class="LineNr">450 </span><span class="Normal">void</span> test_compare_lists_with_identical_structure<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L451" class="LineNr">451 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:<a href='043space.cc.html#L101'>address</a>:address&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:<a href='043space.cc.html#L101'>address</a>:boolean&quot;</span><span class="Delimiter">);</span> <span id="L452" class="LineNr">452 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L453" class="LineNr">453 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L454" class="LineNr">454 </span><span class="Delimiter">}</span> <span id="L455" class="LineNr">455 </span><span class="Normal">void</span> test_compare_identical_lists<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L456" class="LineNr">456 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:<a href='043space.cc.html#L101'>address</a>:boolean&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:<a href='043space.cc.html#L101'>address</a>:boolean&quot;</span><span class="Delimiter">);</span> <span id="L457" class="LineNr">457 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L458" class="LineNr">458 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L459" class="LineNr">459 </span><span class="Delimiter">}</span> <span id="L460" class="LineNr">460 </span><span class="Normal">void</span> test_compare_list_with_extra_element<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L461" class="LineNr">461 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:<a href='043space.cc.html#L101'>address</a>:address&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:<a href='043space.cc.html#L101'>address</a>:<a href='043space.cc.html#L101'>address</a>:number&quot;</span><span class="Delimiter">);</span> <span id="L462" class="LineNr">462 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L463" class="LineNr">463 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L464" class="LineNr">464 </span><span class="Delimiter">}</span> <span id="L465" class="LineNr">465 </span><span class="Normal">void</span> test_compare_list_with_smaller_left_but_larger_right<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L466" class="LineNr">466 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:number:character&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:boolean:array&quot;</span><span class="Delimiter">);</span> <span id="L467" class="LineNr">467 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L468" class="LineNr">468 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L469" class="LineNr">469 </span><span class="Delimiter">}</span> <span id="L470" class="LineNr">470 </span><span class="Normal">void</span> test_compare_list_with_smaller_left_but_larger_right_identical_types<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L471" class="LineNr">471 </span> reagent a<span class="Delimiter">(</span><span class="Constant">&quot;a:<a href='043space.cc.html#L101'>address</a>:boolean&quot;</span><span class="Delimiter">),</span> b<span class="Delimiter">(</span><span class="Constant">&quot;b:boolean:address&quot;</span><span class="Delimiter">);</span> <span id="L472" class="LineNr">472 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>*a<span class="Delimiter">.</span>type &lt; *b<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L473" class="LineNr">473 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!<span class="Delimiter">(</span>*b<span class="Delimiter">.</span>type &lt; *a<span class="Delimiter">.</span>type<span class="Delimiter">));</span> <span id="L474" class="LineNr">474 </span><span class="Delimiter">}</span> <span id="L475" class="LineNr">475 </span> <span id="L476" class="LineNr">476 </span><span class="Delimiter">:(code)</span> <span id="L477" class="LineNr">477 </span>string_tree::string_tree<span class="Delimiter">(</span><span class="Normal">const</span> string_tree&amp; original<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L478" class="LineNr">478 </span> atom = original<span class="Delimiter">.</span>atom<span class="Delimiter">;</span> <span id="L479" class="LineNr">479 </span> value = original<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L480" class="LineNr">480 </span> left = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>left<span class="Delimiter">);</span> <span id="L481" class="LineNr">481 </span> right = copy<span class="Delimiter">(</span>original<span class="Delimiter">.</span>right<span class="Delimiter">);</span> <span id="L482" class="LineNr">482 </span><span class="Delimiter">}</span> <span id="L483" class="LineNr">483 </span> <span id="L484" class="LineNr">484 </span>reagent&amp; reagent::<span class="Normal">operator</span>=<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; other<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L485" class="LineNr">485 </span> original_string = other<span class="Delimiter">.</span>original_string<span class="Delimiter">;</span> <span id="L486" class="LineNr">486 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L487" class="LineNr">487 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)</span> <span class="Normal">delete</span> properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">;</span> <span id="L488" class="LineNr">488 </span> properties<span class="Delimiter">.</span><a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L489" class="LineNr">489 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L490" class="LineNr">490 </span> properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first<span class="Delimiter">,</span> copy<span class="Delimiter">(</span>other<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)));</span> <span id="L491" class="LineNr">491 </span> name = other<span class="Delimiter">.</span>name<span class="Delimiter">;</span> <span id="L492" class="LineNr">492 </span> value = other<span class="Delimiter">.</span>value<span class="Delimiter">;</span> <span id="L493" class="LineNr">493 </span> initialized = other<span class="Delimiter">.</span>initialized<span class="Delimiter">;</span> <span id="L494" class="LineNr">494 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>type<span class="Delimiter">)</span> <span class="Normal">delete</span> type<span class="Delimiter">;</span> <span id="L495" class="LineNr">495 </span> type = copy<span class="Delimiter">(</span>other<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L496" class="LineNr">496 </span> <span class="Comment">// End reagent Copy Operator</span> <span id="L497" class="LineNr">497 </span> <span class="Identifier">return</span> *<span class="Normal">this</span><span class="Delimiter">;</span> <span id="L498" class="LineNr">498 </span><span class="Delimiter">}</span> <span id="L499" class="LineNr">499 </span> <span id="L500" class="LineNr">500 </span>reagent::~reagent<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L501" class="LineNr">501 </span> <a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">();</span> <span id="L502" class="LineNr">502 </span><span class="Delimiter">}</span> <span id="L503" class="LineNr">503 </span> <span id="L504" class="LineNr">504 </span><span class="Normal">void</span> reagent::<a href='050scenario.cc.html#L60'>clear</a><span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L505" class="LineNr">505 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L506" class="LineNr">506 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L507" class="LineNr">507 </span> <span class="Normal">delete</span> properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">;</span> <span id="L508" class="LineNr">508 </span> properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second = <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L509" class="LineNr">509 </span> <span class="Delimiter">}</span> <span id="L510" class="LineNr">510 </span> <span class="Delimiter">}</span> <span id="L511" class="LineNr">511 </span> <span class="Normal">delete</span> type<span class="Delimiter">;</span> <span id="L512" class="LineNr">512 </span> type = <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L513" class="LineNr">513 </span><span class="Delimiter">}</span> <span id="L514" class="LineNr">514 </span>type_tree::~type_tree<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L515" class="LineNr">515 </span> <span class="Normal">delete</span> left<span class="Delimiter">;</span> <span id="L516" class="LineNr">516 </span> <span class="Normal">delete</span> right<span class="Delimiter">;</span> <span id="L517" class="LineNr">517 </span><span class="Delimiter">}</span> <span id="L518" class="LineNr">518 </span>string_tree::~string_tree<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L519" class="LineNr">519 </span> <span class="Normal">delete</span> left<span class="Delimiter">;</span> <span id="L520" class="LineNr">520 </span> <span class="Normal">delete</span> right<span class="Delimiter">;</span> <span id="L521" class="LineNr">521 </span><span class="Delimiter">}</span> <span id="L522" class="LineNr">522 </span> <span id="L523" class="LineNr">523 </span><span class="Normal">void</span> append<span class="Delimiter">(</span>type_tree*&amp; base<span class="Delimiter">,</span> type_tree* extra<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L524" class="LineNr">524 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!base<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L525" class="LineNr">525 </span> base = extra<span class="Delimiter">;</span> <span id="L526" class="LineNr">526 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L527" class="LineNr">527 </span> <span class="Delimiter">}</span> <span id="L528" class="LineNr">528 </span> type_tree* curr = base<span class="Delimiter">;</span> <span id="L529" class="LineNr">529 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L530" class="LineNr">530 </span> curr<span class="Delimiter">-&gt;</span>right = extra<span class="Delimiter">;</span> <span id="L531" class="LineNr">531 </span><span class="Delimiter">}</span> <span id="L532" class="LineNr">532 </span> <span id="L533" class="LineNr">533 </span><span class="Normal">void</span> append<span class="Delimiter">(</span>string_tree*&amp; base<span class="Delimiter">,</span> string_tree* extra<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L534" class="LineNr">534 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!base<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L535" class="LineNr">535 </span> base = extra<span class="Delimiter">;</span> <span id="L536" class="LineNr">536 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L537" class="LineNr">537 </span> <span class="Delimiter">}</span> <span id="L538" class="LineNr">538 </span> string_tree* curr = base<span class="Delimiter">;</span> <span id="L539" class="LineNr">539 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L540" class="LineNr">540 </span> curr<span class="Delimiter">-&gt;</span>right = extra<span class="Delimiter">;</span> <span id="L541" class="LineNr">541 </span><span class="Delimiter">}</span> <span id="L542" class="LineNr">542 </span> <span id="L543" class="LineNr">543 </span>string slurp_until<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> <span class="Normal">char</span> delim<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L544" class="LineNr">544 </span> ostringstream out<span class="Delimiter">;</span> <span id="L545" class="LineNr">545 </span> <span class="Normal">char</span> c<span class="Delimiter">;</span> <span id="L546" class="LineNr">546 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>in &gt;&gt; c<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L547" class="LineNr">547 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>c == delim<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L548" class="LineNr">548 </span> <span class="Comment">// drop the delim</span> <span id="L549" class="LineNr">549 </span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L550" class="LineNr">550 </span> <span class="Delimiter">}</span> <span id="L551" class="LineNr">551 </span> out &lt;&lt; c<span class="Delimiter">;</span> <span id="L552" class="LineNr">552 </span> <span class="Delimiter">}</span> <span id="L553" class="LineNr">553 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L554" class="LineNr">554 </span><span class="Delimiter">}</span> <span id="L555" class="LineNr">555 </span> <span id="L556" class="LineNr">556 </span><span class="Normal">bool</span> has_property<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; x<span class="Delimiter">,</span> <span class="Normal">const</span> string&amp; name<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L557" class="LineNr">557 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L558" class="LineNr">558 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first == name<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Constant"> true</span><span class="Delimiter">;</span> <span id="L559" class="LineNr">559 </span> <span class="Delimiter">}</span> <span id="L560" class="LineNr">560 </span> <span class="Identifier">return</span><span class="Constant"> false</span><span class="Delimiter">;</span> <span id="L561" class="LineNr">561 </span><span class="Delimiter">}</span> <span id="L562" class="LineNr">562 </span> <span id="L563" class="LineNr">563 </span>string_tree* property<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">,</span> <span class="Normal">const</span> string&amp; name<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L564" class="LineNr">564 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> p = <span class="Constant">0</span><span class="Delimiter">;</span> p != <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L565" class="LineNr">565 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>p<span class="Delimiter">).</span>first == name<span class="Delimiter">)</span> <span id="L566" class="LineNr">566 </span> <span class="Identifier">return</span> r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>p<span class="Delimiter">).</span>second<span class="Delimiter">;</span> <span id="L567" class="LineNr">567 </span> <span class="Delimiter">}</span> <span id="L568" class="LineNr">568 </span> <span class="Identifier">return</span> <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L569" class="LineNr">569 </span><span class="Delimiter">}</span> <span id="L570" class="LineNr">570 </span> <span id="L571" class="LineNr">571 </span>string_tree* copy<span class="Delimiter">(</span><span class="Normal">const</span> string_tree* x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L572" class="LineNr">572 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L573" class="LineNr">573 </span> <span class="Identifier">return</span> <span class="Normal">new</span> string_tree<span class="Delimiter">(</span>*x<span class="Delimiter">);</span> <span id="L574" class="LineNr">574 </span><span class="Delimiter">}</span> <span id="L575" class="LineNr">575 </span> <span id="L576" class="LineNr">576 </span>type_tree* copy<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L577" class="LineNr">577 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L578" class="LineNr">578 </span> <span class="Identifier">return</span> <span class="Normal">new</span> type_tree<span class="Delimiter">(</span>*x<span class="Delimiter">);</span> <span id="L579" class="LineNr">579 </span><span class="Delimiter">}</span> <span id="L580" class="LineNr">580 </span> <span id="L581" class="LineNr">581 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span> <span id="L582" class="LineNr">582 </span><span class="Normal">extern</span> <span class="Normal">const</span> string Ignore<span class="Delimiter">(</span><span class="Constant">&quot;,&quot;</span><span class="Delimiter">);</span> <span class="Comment">// commas are ignored in Mu except within [] strings</span> <span id="L583" class="LineNr">583 </span><span class="Delimiter">:(code)</span> <span id="L584" class="LineNr">584 </span><span class="Normal">void</span> skip_whitespace_but_not_newline<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L585" class="LineNr">585 </span> <span class="Normal">while</span> <span class="Delimiter">(</span><span class="Constant">true</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L586" class="LineNr">586 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!has_data<span class="Delimiter">(</span>in<span class="Delimiter">))</span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L587" class="LineNr">587 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>in<span class="Delimiter">.</span>peek<span class="Delimiter">()</span> == <span class="cSpecial">'\n'</span><span class="Delimiter">)</span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L588" class="LineNr">588 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>isspace<span class="Delimiter">(</span>in<span class="Delimiter">.</span>peek<span class="Delimiter">()))</span> in<span class="Delimiter">.</span>get<span class="Delimiter">();</span> <span id="L589" class="LineNr">589 </span> <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>Ignore<span class="Delimiter">.</span>find<span class="Delimiter">(</span>in<span class="Delimiter">.</span>peek<span class="Delimiter">())</span> != string::npos<span class="Delimiter">)</span> in<span class="Delimiter">.</span>get<span class="Delimiter">();</span> <span id="L590" class="LineNr">590 </span> <span class="Normal">else</span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L591" class="LineNr">591 </span> <span class="Delimiter">}</span> <span id="L592" class="LineNr">592 </span><span class="Delimiter">}</span> <span id="L593" class="LineNr">593 </span> <span id="L594" class="LineNr">594 </span><span class="Normal">void</span> dump_memory<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L595" class="LineNr">595 </span> <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">double</span>&gt;::iterator p = Memory<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Memory<span class="Delimiter">.</span><a href='003trace.cc.html#L225'>end</a><span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L596" class="LineNr">596 </span> cerr &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; no_scientific<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L597" class="LineNr">597 </span> <span class="Delimiter">}</span> <span id="L598" class="LineNr">598 </span><span class="Delimiter">}</span> <span id="L599" class="LineNr">599 </span> <span id="L600" class="LineNr">600 </span><span class="SalientComment">//:: Helpers for converting various values to string</span> <span id="L601" class="LineNr">601 </span><span class="Comment">//: Use to_string() in trace(), and try to keep it stable from run to run.</span> <span id="L602" class="LineNr">602 </span><span class="Comment">//: Use debug_string() while debugging, and throw everything into it.</span> <span id="L603" class="LineNr">603 </span><span class="Comment">//: Use inspect() only for emitting a canonical format that can be parsed back</span> <span id="L604" class="LineNr">604 </span><span class="Comment">//: into the value.</span> <span id="L605" class="LineNr">605 </span> <span id="L606" class="LineNr">606 </span>string <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L607" class="LineNr">607 </span> ostringstream out<span class="Delimiter">;</span> <span id="L608" class="LineNr">608 </span> out &lt;&lt; <span class="Constant">&quot;recipe &quot;</span> &lt;&lt; r<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; [</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L609" class="LineNr">609 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>steps<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L610" class="LineNr">610 </span> out &lt;&lt; <span class="Constant">&quot; &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L611" class="LineNr">611 </span> out &lt;&lt; <span class="Constant">&quot;]</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L612" class="LineNr">612 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L613" class="LineNr">613 </span><span class="Delimiter">}</span> <span id="L614" class="LineNr">614 </span> <span id="L615" class="LineNr">615 </span>string to_original_string<span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L616" class="LineNr">616 </span> ostringstream out<span class="Delimiter">;</span> <span id="L617" class="LineNr">617 </span> out &lt;&lt; <span class="Constant">&quot;recipe &quot;</span> &lt;&lt; r<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; [</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L618" class="LineNr">618 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>steps<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L619" class="LineNr">619 </span> out &lt;&lt; <span class="Constant">&quot; &quot;</span> &lt;&lt; to_original_string<span class="Delimiter">(</span>r<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L620" class="LineNr">620 </span> out &lt;&lt; <span class="Constant">&quot;]</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L621" class="LineNr">621 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L622" class="LineNr">622 </span><span class="Delimiter">}</span> <span id="L623" class="LineNr">623 </span> <span id="L624" class="LineNr">624 </span>string debug_string<span class="Delimiter">(</span><span class="Normal">const</span> recipe&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L625" class="LineNr">625 </span> ostringstream out<span class="Delimiter">;</span> <span id="L626" class="LineNr">626 </span> out &lt;&lt; <span class="Constant">&quot;- <a href='010vm.cc.html#L19'>recipe</a> &quot;</span> &lt;&lt; x<span class="Delimiter">.</span>name &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L627" class="LineNr">627 </span> <span class="Comment">// Begin debug_string(recipe x)</span> <span id="L628" class="LineNr">628 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> index = <span class="Constant">0</span><span class="Delimiter">;</span> index &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>x<span class="Delimiter">.</span>steps<span class="Delimiter">);</span> ++index<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L629" class="LineNr">629 </span> <span class="Normal">const</span> instruction&amp; inst = x<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>index<span class="Delimiter">);</span> <span id="L630" class="LineNr">630 </span> out &lt;&lt; <span class="Constant">&quot;inst: &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>inst<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L631" class="LineNr">631 </span> out &lt;&lt; <span class="Constant">&quot; ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L632" class="LineNr">632 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L633" class="LineNr">633 </span> out &lt;&lt; <span class="Constant">&quot; &quot;</span> &lt;&lt; debug_string<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L634" class="LineNr">634 </span> out &lt;&lt; <span class="Constant">&quot; products</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L635" class="LineNr">635 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L636" class="LineNr">636 </span> out &lt;&lt; <span class="Constant">&quot; &quot;</span> &lt;&lt; debug_string<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span> <span id="L637" class="LineNr">637 </span> <span class="Delimiter">}</span> <span id="L638" class="LineNr">638 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L639" class="LineNr">639 </span><span class="Delimiter">}</span> <span id="L640" class="LineNr">640 </span> <span id="L641" class="LineNr">641 </span>string to_original_string<span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L642" class="LineNr">642 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>is_label<span class="Delimiter">)</span> <span class="Identifier">return</span> inst<span class="Delimiter">.</span>label<span class="Delimiter">;</span> <span id="L643" class="LineNr">643 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>original_string<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> inst<span class="Delimiter">.</span>original_string<span class="Delimiter">;</span> <span id="L644" class="LineNr">644 </span> ostringstream out<span class="Delimiter">;</span> <span id="L645" class="LineNr">645 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L646" class="LineNr">646 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>i &gt; <span class="Constant">0</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;, &quot;</span><span class="Delimiter">;</span> <span id="L647" class="LineNr">647 </span> out &lt;&lt; inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string<span class="Delimiter">;</span> <span id="L648" class="LineNr">648 </span> <span class="Delimiter">}</span> <span id="L649" class="LineNr">649 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> out &lt;&lt; <span class="Constant">&quot; &lt;- &quot;</span><span class="Delimiter">;</span> <span id="L650" class="LineNr">650 </span> out &lt;&lt; inst<span class="Delimiter">.</span>name<span class="Delimiter">;</span> <span id="L651" class="LineNr">651 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> out &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L652" class="LineNr">652 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L653" class="LineNr">653 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>i &gt; <span class="Constant">0</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;, &quot;</span><span class="Delimiter">;</span> <span id="L654" class="LineNr">654 </span> out &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>original_string<span class="Delimiter">;</span> <span id="L655" class="LineNr">655 </span> <span class="Delimiter">}</span> <span id="L656" class="LineNr">656 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L657" class="LineNr">657 </span><span class="Delimiter">}</span> <span id="L658" class="LineNr">658 </span> <span id="L659" class="LineNr">659 </span>string <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span><span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L660" class="LineNr">660 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>is_label<span class="Delimiter">)</span> <span class="Identifier">return</span> inst<span class="Delimiter">.</span>label<span class="Delimiter">;</span> <span id="L661" class="LineNr">661 </span> ostringstream out<span class="Delimiter">;</span> <span id="L662" class="LineNr">662 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L663" class="LineNr">663 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>i &gt; <span class="Constant">0</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;, &quot;</span><span class="Delimiter">;</span> <span id="L664" class="LineNr">664 </span> out &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span> <span id="L665" class="LineNr">665 </span> <span class="Delimiter">}</span> <span id="L666" class="LineNr">666 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> out &lt;&lt; <span class="Constant">&quot; &lt;- &quot;</span><span class="Delimiter">;</span> <span id="L667" class="LineNr">667 </span> out &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L668" class="LineNr">668 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L669" class="LineNr">669 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>i &gt; <span class="Constant">0</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;, &quot;</span><span class="Delimiter">;</span> <span id="L670" class="LineNr">670 </span> out &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">));</span> <span id="L671" class="LineNr">671 </span> <span class="Delimiter">}</span> <span id="L672" class="LineNr">672 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L673" class="LineNr">673 </span><span class="Delimiter">}</span> <span id="L674" class="LineNr">674 </span> <span id="L675" class="LineNr">675 </span>string <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L676" class="LineNr">676 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>is_dummy<span class="Delimiter">(</span>r<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">&quot;_&quot;</span><span class="Delimiter">;</span> <span id="L677" class="LineNr">677 </span> ostringstream out<span class="Delimiter">;</span> <span id="L678" class="LineNr">678 </span> out &lt;&lt; <span class="Constant">&quot;{&quot;</span><span class="Delimiter">;</span> <span id="L679" class="LineNr">679 </span> out &lt;&lt; r<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; names_to_string<span class="Delimiter">(</span>r<span class="Delimiter">.</span>type<span class="Delimiter">);</span> <span id="L680" class="LineNr">680 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span> <span id="L681" class="LineNr">681 </span> <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>properties<span class="Delimiter">);</span> ++i<span class="Delimiter">)</span> <span id="L682" class="LineNr">682 </span> out &lt;&lt; <span class="Constant">&quot;, </span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span> &lt;&lt; r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>first &lt;&lt; <span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">: &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>r<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">);</span> <span id="L683" class="LineNr">683 </span> <span class="Delimiter">}</span> <span id="L684" class="LineNr">684 </span> out &lt;&lt; <span class="Constant">&quot;}&quot;</span><span class="Delimiter">;</span> <span id="L685" class="LineNr">685 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L686" class="LineNr">686 </span><span class="Delimiter">}</span> <span id="L687" class="LineNr">687 </span> <span id="L688" class="LineNr">688 </span><span class="Comment">// special name for ignoring some products</span> <span id="L689" class="LineNr">689 </span><span class="Normal">bool</span> is_dummy<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L690" class="LineNr">690 </span> <span class="Identifier">return</span> x<span class="Delimiter">.</span>name == <span class="Constant">&quot;_&quot;</span><span class="Delimiter">;</span> <span id="L691" class="LineNr">691 </span><span class="Delimiter">}</span> <span id="L692" class="LineNr">692 </span> <span id="L693" class="LineNr">693 </span>string debug_string<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L694" class="LineNr">694 </span> ostringstream out<span class="Delimiter">;</span> <span id="L695" class="LineNr">695 </span> out &lt;&lt; x<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; x<span class="Delimiter">.</span>value &lt;&lt; <span class="Constant">' '</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>x<span class="Delimiter">.</span>type<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; -- &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span>x<span class="Delimiter">);</span> <span id="L696" class="LineNr">696 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L697" class="LineNr">697 </span><span class="Delimiter">}</span> <span id="L698" class="LineNr">698 </span> <span id="L699" class="LineNr">699 </span>string <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span><span class="Normal">const</span> string_tree* property<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L700" class="LineNr">700 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!property<span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;()&quot;</span><span class="Delimiter">;</span> <span id="L701" class="LineNr">701 </span> ostringstream out<span class="Delimiter">;</span> <span id="L702" class="LineNr">702 </span> dump<span class="Delimiter">(</span>property<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L703" class="LineNr">703 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L704" class="LineNr">704 </span><span class="Delimiter">}</span> <span id="L705" class="LineNr">705 </span> <span id="L706" class="LineNr">706 </span><span class="Normal">void</span> dump<span class="Delimiter">(</span><span class="Normal">const</span> string_tree* x<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L707" class="LineNr">707 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!x<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L708" class="LineNr">708 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L709" class="LineNr">709 </span> out &lt;&lt; <span class="Constant">'&quot;'</span> &lt;&lt; x<span class="Delimiter">-&gt;</span>value &lt;&lt; <span class="Constant">'&quot;'</span><span class="Delimiter">;</span> <span id="L710" class="LineNr">710 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L711" class="LineNr">711 </span> <span class="Delimiter">}</span> <span id="L712" class="LineNr">712 </span> out &lt;&lt; <span class="Constant">'('</span><span class="Delimiter">;</span> <span id="L713" class="LineNr">713 </span> <span class="Normal">const</span> string_tree* curr = x<span class="Delimiter">;</span> <span id="L714" class="LineNr">714 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr &amp;&amp; !curr<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L715" class="LineNr">715 </span> dump<span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>left<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L716" class="LineNr">716 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L717" class="LineNr">717 </span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L718" class="LineNr">718 </span> <span class="Delimiter">}</span> <span id="L719" class="LineNr">719 </span> <span class="Comment">// check for dotted list; should never happen</span> <span id="L720" class="LineNr">720 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L721" class="LineNr">721 </span> out &lt;&lt; <span class="Constant">&quot;. &quot;</span><span class="Delimiter">;</span> <span id="L722" class="LineNr">722 </span> dump<span class="Delimiter">(</span>curr<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L723" class="LineNr">723 </span> <span class="Delimiter">}</span> <span id="L724" class="LineNr">724 </span> out &lt;&lt; <span class="Constant">')'</span><span class="Delimiter">;</span> <span id="L725" class="LineNr">725 </span><span class="Delimiter">}</span> <span id="L726" class="LineNr">726 </span> <span id="L727" class="LineNr">727 </span>string <a href='028call_return.cc.html#L163'>to_string</a><span class="Delimiter">(</span><span class="Normal">const</span> type_tree* type<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L728" class="LineNr">728 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>type == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;()&quot;</span><span class="Delimiter">;</span> <span id="L729" class="LineNr">729 </span> ostringstream out<span class="Delimiter">;</span> <span id="L730" class="LineNr">730 </span> dump<span class="Delimiter">(</span>type<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L731" class="LineNr">731 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L732" class="LineNr">732 </span><span class="Delimiter">}</span> <span id="L733" class="LineNr">733 </span> <span id="L734" class="LineNr">734 </span><span class="Normal">void</span> dump<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* x<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L735" class="LineNr">735 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!x<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L736" class="LineNr">736 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L737" class="LineNr">737 </span> dump<span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>value<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L738" class="LineNr">738 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L739" class="LineNr">739 </span> <span class="Delimiter">}</span> <span id="L740" class="LineNr">740 </span> out &lt;&lt; <span class="Constant">'('</span><span class="Delimiter">;</span> <span id="L741" class="LineNr">741 </span> <span class="Normal">const</span> type_tree* curr = x<span class="Delimiter">;</span> <span id="L742" class="LineNr">742 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr &amp;&amp; !curr<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L743" class="LineNr">743 </span> dump<span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>left<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L744" class="LineNr">744 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L745" class="LineNr">745 </span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L746" class="LineNr">746 </span> <span class="Delimiter">}</span> <span id="L747" class="LineNr">747 </span> <span class="Comment">// check for dotted list; should never happen</span> <span id="L748" class="LineNr">748 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L749" class="LineNr">749 </span> out &lt;&lt; <span class="Constant">&quot;. &quot;</span><span class="Delimiter">;</span> <span id="L750" class="LineNr">750 </span> dump<span class="Delimiter">(</span>curr<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L751" class="LineNr">751 </span> <span class="Delimiter">}</span> <span id="L752" class="LineNr">752 </span> out &lt;&lt; <span class="Constant">')'</span><span class="Delimiter">;</span> <span id="L753" class="LineNr">753 </span><span class="Delimiter">}</span> <span id="L754" class="LineNr">754 </span> <span id="L755" class="LineNr">755 </span><span class="Normal">void</span> dump<span class="Delimiter">(</span><a href='010vm.cc.html#L125'>type_ordinal</a> type<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L756" class="LineNr">756 </span> <span class="Normal">if</span> <span class="Delimiter">(</span><a href='001help.cc.html#L226'>contains_key</a><span class="Delimiter">(</span>Type<span class="Delimiter">,</span> type<span class="Delimiter">))</span> <span id="L757" class="LineNr">757 </span> out &lt;&lt; get<span class="Delimiter">(</span>Type<span class="Delimiter">,</span> type<span class="Delimiter">).</span>name<span class="Delimiter">;</span> <span id="L758" class="LineNr">758 </span> <span class="Normal">else</span> <span id="L759" class="LineNr">759 </span> out &lt;&lt; <span class="Constant">&quot;?&quot;</span> &lt;&lt; type<span class="Delimiter">;</span> <span id="L760" class="LineNr">760 </span><span class="Delimiter">}</span> <span id="L761" class="LineNr">761 </span> <span id="L762" class="LineNr">762 </span>string names_to_string<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* type<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L763" class="LineNr">763 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>type == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;()&quot;</span><span class="Delimiter">;</span> <span class="Comment">// should never happen</span> <span id="L764" class="LineNr">764 </span> ostringstream out<span class="Delimiter">;</span> <span id="L765" class="LineNr">765 </span> dump_names<span class="Delimiter">(</span>type<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L766" class="LineNr">766 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L767" class="LineNr">767 </span><span class="Delimiter">}</span> <span id="L768" class="LineNr">768 </span> <span id="L769" class="LineNr">769 </span><span class="Normal">void</span> dump_names<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* x<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L770" class="LineNr">770 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!x<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L771" class="LineNr">771 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L772" class="LineNr">772 </span> out &lt;&lt; <span class="Constant">'&quot;'</span> &lt;&lt; x<span class="Delimiter">-&gt;</span>name &lt;&lt; <span class="Constant">'&quot;'</span><span class="Delimiter">;</span> <span id="L773" class="LineNr">773 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L774" class="LineNr">774 </span> <span class="Delimiter">}</span> <span id="L775" class="LineNr">775 </span> out &lt;&lt; <span class="Constant">'('</span><span class="Delimiter">;</span> <span id="L776" class="LineNr">776 </span> <span class="Normal">const</span> type_tree* curr = x<span class="Delimiter">;</span> <span id="L777" class="LineNr">777 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr &amp;&amp; !curr<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L778" class="LineNr">778 </span> dump_names<span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>left<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L779" class="LineNr">779 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L780" class="LineNr">780 </span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L781" class="LineNr">781 </span> <span class="Delimiter">}</span> <span id="L782" class="LineNr">782 </span> <span class="Comment">// check for dotted list; should never happen</span> <span id="L783" class="LineNr">783 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L784" class="LineNr">784 </span> out &lt;&lt; <span class="Constant">&quot;. &quot;</span><span class="Delimiter">;</span> <span id="L785" class="LineNr">785 </span> dump_names<span class="Delimiter">(</span>curr<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L786" class="LineNr">786 </span> <span class="Delimiter">}</span> <span id="L787" class="LineNr">787 </span> out &lt;&lt; <span class="Constant">')'</span><span class="Delimiter">;</span> <span id="L788" class="LineNr">788 </span><span class="Delimiter">}</span> <span id="L789" class="LineNr">789 </span> <span id="L790" class="LineNr">790 </span>string names_to_string_without_quotes<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* type<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L791" class="LineNr">791 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>type == <span class="Constant">NULL</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;()&quot;</span><span class="Delimiter">;</span> <span id="L792" class="LineNr">792 </span> ostringstream out<span class="Delimiter">;</span> <span id="L793" class="LineNr">793 </span> dump_names_without_quotes<span class="Delimiter">(</span>type<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L794" class="LineNr">794 </span> <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span> <span id="L795" class="LineNr">795 </span><span class="Delimiter">}</span> <span id="L796" class="LineNr">796 </span> <span id="L797" class="LineNr">797 </span><span class="Normal">void</span> dump_names_without_quotes<span class="Delimiter">(</span><span class="Normal">const</span> type_tree* x<span class="Delimiter">,</span> ostream&amp; out<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L798" class="LineNr">798 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!x<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L799" class="LineNr">799 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L800" class="LineNr">800 </span> out &lt;&lt; x<span class="Delimiter">-&gt;</span>name<span class="Delimiter">;</span> <span id="L801" class="LineNr">801 </span> <span class="Identifier">return</span><span class="Delimiter">;</span> <span id="L802" class="LineNr">802 </span> <span class="Delimiter">}</span> <span id="L803" class="LineNr">803 </span> out &lt;&lt; <span class="Constant">'('</span><span class="Delimiter">;</span> <span id="L804" class="LineNr">804 </span> <span class="Normal">const</span> type_tree* curr = x<span class="Delimiter">;</span> <span id="L805" class="LineNr">805 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>curr &amp;&amp; !curr<span class="Delimiter">-&gt;</span>atom<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L806" class="LineNr">806 </span> dump_names_without_quotes<span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>left<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L807" class="LineNr">807 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span> <span id="L808" class="LineNr">808 </span> curr = curr<span class="Delimiter">-&gt;</span>right<span class="Delimiter">;</span> <span id="L809" class="LineNr">809 </span> <span class="Delimiter">}</span> <span id="L810" class="LineNr">810 </span> <span class="Comment">// check for dotted list; should never happen</span> <span id="L811" class="LineNr">811 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L812" class="LineNr">812 </span> out &lt;&lt; <span class="Constant">&quot;. &quot;</span><span class="Delimiter">;</span> <span id="L813" class="LineNr">813 </span> dump_names_without_quotes<span class="Delimiter">(</span>curr<span class="Delimiter">,</span> out<span class="Delimiter">);</span> <span id="L814" class="LineNr">814 </span> <span class="Delimiter">}</span> <span id="L815" class="LineNr">815 </span> out &lt;&lt; <span class="Constant">')'</span><span class="Delimiter">;</span> <span id="L816" class="LineNr">816 </span><span class="Delimiter">}</span> <span id="L817" class="LineNr">817 </span> <span id="L818" class="LineNr">818 </span><span class="Normal">bool</span> is_integer<span class="Delimiter">(</span><span class="Normal">const</span> string&amp; s<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L819" class="LineNr">819 </span> <span class="Identifier">return</span> s<span class="Delimiter">.</span>find_first_not_of<span class="Delimiter">(</span><span class="Constant">&quot;0123456789-&quot;</span><span class="Delimiter">)</span> == string::npos <span class="Comment">// no other characters</span> <span id="L820" class="LineNr">820 </span> &amp;&amp; s<span class="Delimiter">.</span>find_first_of<span class="Delimiter">(</span><span class="Constant">&quot;0123456789&quot;</span><span class="Delimiter">)</span> != string::npos <span class="Comment">// at least one digit</span> <span id="L821" class="LineNr">821 </span> &amp;&amp; s<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">'-'</span><span class="Delimiter">,</span> <span class="Constant">1</span><span class="Delimiter">)</span> == string::npos<span class="Delimiter">;</span> <span class="Comment">// '-' only at first position</span> <span id="L822" class="LineNr">822 </span><span class="Delimiter">}</span> <span id="L823" class="LineNr">823 </span> <span id="L824" class="LineNr">824 </span><span class="Normal">int</span> to_integer<span class="Delimiter">(</span>string n<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L825" class="LineNr">825 </span> <span class="Normal">char</span>* <a href='003trace.cc.html#L225'>end</a> = <span class="Constant">NULL</span><span class="Delimiter">;</span> <span id="L826" class="LineNr">826 </span> <span class="Comment">// safe because string.c_str() is guaranteed to be null-terminated</span> <span id="L827" class="LineNr">827 </span> <span class="Normal">int</span> result = strtoll<span class="Delimiter">(</span>n<span class="Delimiter">.</span>c_str<span class="Delimiter">(),</span> &amp;end<span class="Delimiter">,</span> <span class="Comment">/*</span><span class="Comment">any base</span><span class="Comment">*/</span><span class="Constant">0</span><span class="Delimiter">);</span> <span id="L828" class="LineNr">828 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>*end != <span class="cSpecial">'\0'</span><span class="Delimiter">)</span> cerr &lt;&lt; <span class="Constant">&quot;tried to convert &quot;</span> &lt;&lt; n &lt;&lt; <span class="Constant">&quot; to number</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span><span class="Delimiter">;</span> <span id="L829" class="LineNr">829 </span> assert<span class="Delimiter">(</span>*end == <span class="cSpecial">'\0'</span><span class="Delimiter">);</span> <span id="L830" class="LineNr">830 </span> <span class="Identifier">return</span> result<span class="Delimiter">;</span> <span id="L831" class="LineNr">831 </span><span class="Delimiter">}</span> <span id="L832" class="LineNr">832 </span> <span id="L833" class="LineNr">833 </span><span class="Normal">void</span> test_is_integer<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L834" class="LineNr">834 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span><span class="Constant">&quot;1234&quot;</span><span class="Delimiter">));</span> <span id="L835" class="LineNr">835 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span><span class="Constant">&quot;-1&quot;</span><span class="Delimiter">));</span> <span id="L836" class="LineNr">836 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!is_integer<span class="Delimiter">(</span><span class="Constant">&quot;234.0&quot;</span><span class="Delimiter">));</span> <span id="L837" class="LineNr">837 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span><span class="Constant">&quot;-567&quot;</span><span class="Delimiter">));</span> <span id="L838" class="LineNr">838 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!is_integer<span class="Delimiter">(</span><span class="Constant">&quot;89-0&quot;</span><span class="Delimiter">));</span> <span id="L839" class="LineNr">839 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!is_integer<span class="Delimiter">(</span><span class="Constant">&quot;-&quot;</span><span class="Delimiter">));</span> <span id="L840" class="LineNr">840 </span> <a href='002test.cc.html#L24'>CHECK</a><span class="Delimiter">(</span>!is_integer<span class="Delimiter">(</span><span class="Constant">&quot;1e3&quot;</span><span class="Delimiter">));</span> <span class="Comment">// not supported</span> <span id="L841" class="LineNr">841 </span><span class="Delimiter">}</span> <span id="L842" class="LineNr">842 </span> <span id="L843" class="LineNr">843 </span><span class="Comment">//: helper to print numbers without excessive precision</span> <span id="L844" class="LineNr">844 </span> <span id="L845" class="LineNr">845 </span><span class="Delimiter">:(before &quot;End Types&quot;)</span> <span id="L846" class="LineNr">846 </span><span class="Normal">struct</span> no_scientific <span class="Delimiter">{</span> <span id="L847" class="LineNr">847 </span> <span class="Normal">double</span> x<span class="Delimiter">;</span> <span id="L848" class="LineNr">848 </span> <span class="Normal">explicit</span> no_scientific<span class="Delimiter">(</span><span class="Normal">double</span> y<span class="Delimiter">)</span> :x<span class="Delimiter">(</span>y<span class="Delimiter">)</span> <span class="Delimiter">{}</span> <span id="L849" class="LineNr">849 </span><span class="Delimiter">};</span> <span id="L850" class="LineNr">850 </span> <span id="L851" class="LineNr">851 </span><span class="Delimiter">:(code)</span> <span id="L852" class="LineNr">852 </span>ostream&amp; <span class="Normal">operator</span>&lt;&lt;<span class="Delimiter">(</span>ostream&amp; os<span class="Delimiter">,</span> no_scientific x<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L853" class="LineNr">853 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>!isfinite<span class="Delimiter">(</span>x<span class="Delimiter">.</span>x<span class="Delimiter">))</span> <span class="Delimiter">{</span> <span id="L854" class="LineNr">854 </span> <span class="Comment">// Infinity or NaN</span> <span id="L855" class="LineNr">855 </span> os &lt;&lt; x<span class="Delimiter">.</span>x<span class="Delimiter">;</span> <span id="L856" class="LineNr">856 </span> <span class="Identifier">return</span> os<span class="Delimiter">;</span> <span id="L857" class="LineNr">857 </span> <span class="Delimiter">}</span> <span id="L858" class="LineNr">858 </span> ostringstream tmp<span class="Delimiter">;</span> <span id="L859" class="LineNr">859 </span> <span class="Comment">// more accurate, but too slow</span> <span id="L860" class="LineNr">860 </span><span class="CommentedCode">//? tmp.precision(308); // for 64-bit numbers</span> <span id="L861" class="LineNr">861 </span> tmp &lt;&lt; std::fixed &lt;&lt; x<span class="Delimiter">.</span>x<span class="Delimiter">;</span> <span id="L862" class="LineNr">862 </span> os &lt;&lt; trim_floating_point<span class="Delimiter">(</span>tmp<span class="Delimiter">.</span>str<span class="Delimiter">());</span> <span id="L863" class="LineNr">863 </span> <span class="Identifier">return</span> os<span class="Delimiter">;</span> <span id="L864" class="LineNr">864 </span><span class="Delimiter">}</span> <span id="L865" class="LineNr">865 </span> <span id="L866" class="LineNr">866 </span>string trim_floating_point<span class="Delimiter">(</span><span class="Normal">const</span> string&amp; in<span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L867" class="LineNr">867 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>in<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> <span class="Constant">&quot;&quot;</span><span class="Delimiter">;</span> <span id="L868" class="LineNr">868 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>in<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">'.'</span><span class="Delimiter">)</span> == string::npos<span class="Delimiter">)</span> <span class="Identifier">return</span> in<span class="Delimiter">;</span> <span id="L869" class="LineNr">869 </span> <span class="Normal">int</span> length = <a href='001help.cc.html#L141'>SIZE</a><span class="Delimiter">(</span>in<span class="Delimiter">);</span> <span id="L870" class="LineNr">870 </span> <span class="Normal">while</span> <span class="Delimiter">(</span>length &gt; <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Delimiter">{</span> <span id="L871" class="LineNr">871 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>in<span class="Delimiter">.</span>at<span class="Delimiter">(</span>length-<span class="Constant">1</span><span class="Delimiter">)</span> != <span class="Constant">'0'</span><span class="Delimiter">)</span> <span class="Identifier">break</span><span class="Delimiter">;</span> <span id="L872" class="LineNr">872 </span> --length<span class="Delimiter">;</span> <span id="L873" class="LineNr">873 </span> <span class="Delimiter">}</span> <span id="L874" class="LineNr">874 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>in<span class="Delimiter">.</span>at<span class="Delimiter">(</span>length-<span class="Constant">1</span><span class="Delimiter">)</span> == <span class="Constant">'.'</span><span class="Delimiter">)</span> --length<span class="Delimiter">;</span> <span id="L875" class="LineNr">875 </span> <span class="Normal">if</span> <span class="Delimiter">(</span>length == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">&quot;0&quot;</span><span class="Delimiter">;</span> <span id="L876" class="LineNr">876 </span> <span class="Identifier">return</span> in<span class="Delimiter">.</span>substr<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">,</span> length<span class="Delimiter">);</span> <span id="L877" class="LineNr">877 </span><span class="Delimiter">}</span> <span id="L878" class="LineNr">878 </span> <span id="L879" class="LineNr">879 </span><span class="Normal">void</span> test_trim_floating_point<span class="Delimiter">()</span> <span class="Delimiter">{</span> <span id="L880" class="LineNr">880 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;&quot;</span><span class="Delimiter">);</span> <span id="L881" class="LineNr">881 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;.0&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;0&quot;</span><span class="Delimiter">);</span> <span id="L882" class="LineNr">882 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;1.5000&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;1.5&quot;</span><span class="Delimiter">);</span> <span id="L883" class="LineNr">883 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;1.000001&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;1.000001&quot;</span><span class="Delimiter">);</span> <span id="L884" class="LineNr">884 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;23.000000&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;23&quot;</span><span class="Delimiter">);</span> <span id="L885" class="LineNr">885 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;23.0&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;23&quot;</span><span class="Delimiter">);</span> <span id="L886" class="LineNr">886 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;23.&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;23&quot;</span><span class="Delimiter">);</span> <span id="L887" class="LineNr">887 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;23&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;23&quot;</span><span class="Delimiter">);</span> <span id="L888" class="LineNr">888 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;230&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;230&quot;</span><span class="Delimiter">);</span> <span id="L889" class="LineNr">889 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;3.000000&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;3&quot;</span><span class="Delimiter">);</span> <span id="L890" class="LineNr">890 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;3.0&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;3&quot;</span><span class="Delimiter">);</span> <span id="L891" class="LineNr">891 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;3.&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;3&quot;</span><span class="Delimiter">);</span> <span id="L892" class="LineNr">892 </span> <a href='002test.cc.html#L31'>CHECK_EQ</a><span class="Delimiter">(</span>trim_floating_point<span class="Delimiter">(</span><span class="Constant">&quot;3&quot;</span><span class="Delimiter">),</span> <span class="Constant">&quot;3&quot;</span><span class="Delimiter">);</span> <span id="L893" class="LineNr">893 </span><span class="Delimiter">}</span> <span id="L894" class="LineNr">894 </span> <span id="L895" class="LineNr">895 </span><span class="Delimiter">:(before &quot;End Includes&quot;)</span> <span id="L896" class="LineNr">896 </span><span class="Comment">#include &lt;map&gt;</span> <span id="L897" class="LineNr">897 </span><span class="Normal">using</span> std::map<span class="Delimiter">;</span> <span id="L898" class="LineNr">898 </span><span class="Comment">#include &lt;utility&gt;</span> <span id="L899" class="LineNr">899 </span><span class="Normal">using</span> std::pair<span class="Delimiter">;</span> <span id="L900" class="LineNr">900 </span><span class="Comment">#include &lt;math.h&gt;</span> </pre> </body> </html> <!-- vim: set foldmethod=manual : -->