Release v0.1.0 - fornax - Collection of tools to visualize Path Finding Algorithms

about summary refs log tree commit diff stats

diff options

author	Andinus <andinus@nand.sh>	2021-11-03 23:48:05 +0530
committer	Andinus <andinus@nand.sh>	2021-11-03 23:48:05 +0530
commit	c5c4c7fb0ec378c7eb4bea3bf8e6f143ec9fb205 (patch)
tree	33fbf6fdd0889379a958343f1f94b94f690637aa /lib
parent	4d522584df205feab4c40f99154ab3af264282b8 (diff)
download	fornax-c5c4c7fb0ec378c7eb4bea3bf8e6f143ec9fb205.tar.gz

Release v0.1.0 v0.1.0

Diffstat (limited to 'lib')

0 files changed, 0 insertions, 0 deletions

title='Blame the previous revision' href='/akkartik/mu/blame/html/010vm.cc.html?h=main&id=63e1c465e46502bd7c391e31db73e7e5ae19adfd'>^

a654e4ec ^

672e3e50 ^

4a39d12d ^

4c4d325c ^

a654e4ec ^

fe8bf967 ^

805d58c6 ^

4bb57a55 ^

805d58c6 ^

4bb57a55 ^

805d58c6 ^

fe8bf967 ^

4bb57a55 ^

fe8bf967 ^

4bb57a55 ^

672e3e50 ^

a654e4ec ^

e5c11a51 ^

a654e4ec ^

672e3e50 ^

e5c11a51 ^

a654e4ec ^

204dae92 ^

201458e3 ^

204dae92 ^

201458e3 ^

204dae92 ^

201458e3 ^

204dae92 ^

201458e3 ^

204dae92 ^

201458e3 ^

204dae92 ^

598f1b53 ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

7452d052 ^

1fb0cf9e ^

672e3e50 ^

a654e4ec ^

11
12

13
14
15

20
21
22

30
31

59
60

83
84
85

96
97
98

498
499

500
501

510
511
512

513
514

515
516
517

518
519

520
521

522
523
524

525
526

527
528
529

629
630

634
635

746
747

959
960
961

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


context:
space:
mode: