about summary refs log blame commit diff stats
path: root/html/010vm.cc.html
blob: 77ed750f5320582975af9c410fede037a0ead683 (plain) (tree)
1
2
3
4
5



                                                                                          
                                      






















































































                                                                                                                                                                                                                                                                                            
                                                                                                





                                                                                                       
                                                                                                        















                                                                                                                                                                 


                                                                                                                                                                                                                                              






                                                                                                                                               
                                                                        
























































































                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      


                                                                                                                                                                                                                                                                                                                                                                                                                      


                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                                                               











                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                          




                                                                                                                                                                                                                                                                                 



                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          













                                                                                                                                                                                                                                                                                         
                                                                                                                                                                        




                                                                                                                                                                                                                                                                               
                                                                                                                                                                           

















                                                                                                                                                                             
                                                                                                                                                                                                                                                                                                                                                 









                                                                                                                                                                                                                                                   
<!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>~/Desktop/s/mu/010vm.cc</title>
<meta name="Generator" content="Vim/7.4">
<meta name="plugin-version" content="vim7.4_v1">
<meta name="syntax" content="cpp">
<meta name="settings" content="use_css,pre_wrap,no_foldcolumn,expand_tabs,prevent_copy=">
<meta name="colorscheme" content="minimal">
<style type="text/css">
<!--
pre { white-space: pre-wrap; font-family: monospace; color: #d0d0d0; background-color: #000000; }
body { font-family: monospace; color: #d0d0d0; background-color: #000000; }
* { font-size: 1em; }
.cSpecial { color: #008000; }
.Constant { color: #008080; }
.Comment { color: #8080ff; }
.Delimiter { color: #c000c0; }
.SalientComment { color: #00ffff; }
.Identifier { color: #008080; }
.PreProc { color: #c000c0; }
-->
</style>

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

-->
</script>
</head>
<body>
<pre id='vimCodeElement'>
<span class="Delimiter">:(after &quot;Types&quot;)</span>
<span class="Comment">// A program is a book of 'recipes' (functions)</span>
typedef size_t recipe_number<span class="Delimiter">;</span>
<span class="Delimiter">:(before &quot;End Globals&quot;)</span>
map&lt;string<span class="Delimiter">,</span> recipe_number&gt; Recipe_number<span class="Delimiter">;</span>
map&lt;recipe_number<span class="Delimiter">,</span> recipe&gt; Recipe<span class="Delimiter">;</span>
recipe_number Next_recipe_number = <span class="Constant">1</span><span class="Delimiter">;</span>

<span class="Delimiter">:(before &quot;End Types&quot;)</span>
<span class="Comment">// Recipes are lists of instructions. To run a recipe, the computer runs its</span>
<span class="Comment">// instructions.</span>
struct recipe <span class="Delimiter">{</span>
  string name<span class="Delimiter">;</span>
  vector&lt;instruction&gt; steps<span class="Delimiter">;</span>
  <span class="Comment">// End recipe Fields</span>
<span class="Delimiter">};</span>

<span class="Delimiter">:(before &quot;struct recipe&quot;)</span>
<span class="Comment">// Each instruction is either of the form:</span>
<span class="Comment">//   product1, product2, product3, ... &lt;- operation ingredient1, ingredient2, ingredient3, ...</span>
<span class="Comment">// or just a single 'label' starting with a non-alphanumeric character</span>
<span class="Comment">//   +label</span>
<span class="Comment">// Labels don't do anything, they're just waypoints.</span>
struct instruction <span class="Delimiter">{</span>
  bool is_label<span class="Delimiter">;</span>
  string label<span class="Delimiter">;</span>  <span class="Comment">// only if is_label</span>
  string name<span class="Delimiter">;</span>  <span class="Comment">// only if !is_label</span>
  recipe_number operation<span class="Delimiter">;</span>  <span class="Comment">// Recipe_number[name]</span>
  vector&lt;reagent&gt; ingredients<span class="Delimiter">;</span>  <span class="Comment">// only if !is_label</span>
  vector&lt;reagent&gt; products<span class="Delimiter">;</span>  <span class="Comment">// only if !is_label</span>
  instruction<span class="Delimiter">();</span>
  void clear<span class="Delimiter">();</span>
  string to_string<span class="Delimiter">()</span> const<span class="Delimiter">;</span>
<span class="Delimiter">};</span>

<span class="Delimiter">:(before &quot;struct instruction&quot;)</span>
<span class="Comment">// Ingredients and products are a single species -- a reagent. Reagents refer</span>
<span class="Comment">// either to numbers or to locations in memory along with 'type' tags telling</span>
<span class="Comment">// us how to interpret them. They also can contain arbitrary other lists of</span>
<span class="Comment">// properties besides types, but we're getting ahead of ourselves.</span>
struct reagent <span class="Delimiter">{</span>
  vector&lt;pair&lt;string<span class="Delimiter">,</span> vector&lt;string&gt; &gt; &gt; properties<span class="Delimiter">;</span>
  string name<span class="Delimiter">;</span>
  long long int value<span class="Delimiter">;</span>
  bool initialized<span class="Delimiter">;</span>
  vector&lt;type_number&gt; types<span class="Delimiter">;</span>
  reagent<span class="Delimiter">(</span>string s<span class="Delimiter">);</span>
  reagent<span class="Delimiter">();</span>
  void set_value<span class="Delimiter">(</span>long long int 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>
  string to_string<span class="Delimiter">()</span> const<span class="Delimiter">;</span>
<span class="Delimiter">};</span>

<span class="Delimiter">:(before &quot;struct reagent&quot;)</span>
struct property <span class="Delimiter">{</span>
  vector&lt;string&gt; values<span class="Delimiter">;</span>
<span class="Delimiter">};</span>

<span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span class="Comment">// Locations refer to a common 'memory'. Each location can store a number.</span>
map&lt;index_t<span class="Delimiter">,</span> double&gt; Memory<span class="Delimiter">;</span>
<span class="Delimiter">:(before &quot;End Setup&quot;)</span>
Memory<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>

<span class="Delimiter">:(after &quot;Types&quot;)</span>
<span class="Comment">// Mu types encode how the numbers stored in different parts of memory are</span>
<span class="Comment">// interpreted. A location tagged as a 'character' type will interpret the</span>
<span class="Comment">// number 97 as the letter 'a', while a different location of type 'number'</span>
<span class="Comment">// would not.</span>
<span class="Comment">//</span>
<span class="Comment">// Unlike most computers today, mu stores types in a single big table, shared</span>
<span class="Comment">// by all the mu programs on the computer. This is useful in providing a</span>
<span class="Comment">// seamless experience to help understand arbitrary mu programs.</span>
typedef size_t type_number<span class="Delimiter">;</span>
<span class="Delimiter">:(before &quot;End Globals&quot;)</span>
map&lt;string<span class="Delimiter">,</span> type_number&gt; Type_number<span class="Delimiter">;</span>
map&lt;type_number<span class="Delimiter">,</span> type_info&gt; Type<span class="Delimiter">;</span>
type_number Next_type_number = <span class="Constant">1</span><span class="Delimiter">;</span>
<span class="Delimiter">:(code)</span>
void setup_types<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  Type<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>  Type_number<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
  Type_number[<span class="Constant">&quot;literal&quot;</span>] = <span class="Constant">0</span><span class="Delimiter">;</span>
  Next_type_number = <span class="Constant">1</span><span class="Delimiter">;</span>
  <span class="Comment">// Mu Types Initialization</span>
  type_number number = Type_number[<span class="Constant">&quot;number&quot;</span>] = Next_type_number++<span class="Delimiter">;</span>
  Type_number[<span class="Constant">&quot;location&quot;</span>] = Type_number[<span class="Constant">&quot;number&quot;</span>]<span class="Delimiter">;</span>  <span class="Comment">// wildcard type: either a pointer or a scalar</span>
  Type[number]<span class="Delimiter">.</span>name = <span class="Constant">&quot;number&quot;</span><span class="Delimiter">;</span>
  type_number address = Type_number[<span class="Constant">&quot;address&quot;</span>] = Next_type_number++<span class="Delimiter">;</span>
  Type[address]<span class="Delimiter">.</span>name = <span class="Constant">&quot;address&quot;</span><span class="Delimiter">;</span>
  type_number boolean = Type_number[<span class="Constant">&quot;boolean&quot;</span>] = Next_type_number++<span class="Delimiter">;</span>
  Type[boolean]<span class="Delimiter">.</span>name = <span class="Constant">&quot;boolean&quot;</span><span class="Delimiter">;</span>
  type_number character = Type_number[<span class="Constant">&quot;character&quot;</span>] = Next_type_number++<span class="Delimiter">;</span>
  Type[character]<span class="Delimiter">.</span>name = <span class="Constant">&quot;character&quot;</span><span class="Delimiter">;</span>
  <span class="Comment">// Array types are a special modifier to any other type. For example,</span>
  <span class="Comment">// array:number or array:address:boolean.</span>
  type_number array = Type_number[<span class="Constant">&quot;array&quot;</span>] = Next_type_number++<span class="Delimiter">;</span>
  Type[array]<span class="Delimiter">.</span>name = <span class="Constant">&quot;array&quot;</span><span class="Delimiter">;</span>
  <span class="Comment">// End Mu Types Initialization</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span>
setup_types<span class="Delimiter">();</span>

<span class="Delimiter">:(before &quot;End Types&quot;)</span>
<span class="Comment">// You can construct arbitrary new types. New types are either 'containers'</span>
<span class="Comment">// with multiple 'elements' of other types, or 'exclusive containers' containing</span>
<span class="Comment">// one of multiple 'variants'. (These are similar to C structs and unions,</span>
<span class="Comment">// respectively, though exclusive containers implicitly include a tag element</span>
<span class="Comment">// recording which variant they should be interpreted as.)</span>
<span class="Comment">//</span>
<span class="Comment">// For example, storing bank balance and name for an account might require a</span>
<span class="Comment">// container, but if bank accounts may be either for individuals or groups,</span>
<span class="Comment">// with different properties for each, that may require an exclusive container</span>
<span class="Comment">// whose variants are individual-account and joint-account containers.</span>
enum kind_of_type <span class="Delimiter">{</span>
  primitive<span class="Delimiter">,</span>
  container<span class="Delimiter">,</span>
  exclusive_container
<span class="Delimiter">};</span>

struct type_info <span class="Delimiter">{</span>
  string name<span class="Delimiter">;</span>
  kind_of_type kind<span class="Delimiter">;</span>
  size_t size<span class="Delimiter">;</span>  <span class="Comment">// only if type is not primitive; primitives and addresses have size 1 (except arrays are dynamic)</span>
  vector&lt;vector&lt;type_number&gt; &gt; elements<span class="Delimiter">;</span>
  vector&lt;string&gt; element_names<span class="Delimiter">;</span>
  <span class="Comment">// End type_info Fields</span>
  type_info<span class="Delimiter">()</span> :kind<span class="Delimiter">(</span>primitive<span class="Delimiter">),</span> size<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)</span> <span class="Delimiter">{}</span>
<span class="Delimiter">};</span>

enum primitive_recipes <span class="Delimiter">{</span>
  IDLE = <span class="Constant">0</span><span class="Delimiter">,</span>
  COPY<span class="Delimiter">,</span>
  <span class="Comment">// End Primitive Recipe Declarations</span>
  MAX_PRIMITIVE_RECIPES<span class="Delimiter">,</span>
<span class="Delimiter">};</span>
<span class="Delimiter">:(code)</span>
<span class="Comment">//: It's all very well to construct recipes out of other recipes, but we need</span>
<span class="Comment">//: to know how to do *something* out of the box. For the following</span>
<span class="Comment">//: recipes there are only codes, no entries in the book, because mu just knows</span>
<span class="Comment">//: what to do for them.</span>
void setup_recipes<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  Recipe<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>  Recipe_number<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
  Recipe_number[<span class="Constant">&quot;idle&quot;</span>] = IDLE<span class="Delimiter">;</span>
  <span class="Comment">// Primitive Recipe Numbers</span>
  Recipe_number[<span class="Constant">&quot;copy&quot;</span>] = COPY<span class="Delimiter">;</span>
  <span class="Comment">// End Primitive Recipe Numbers</span>
<span class="Delimiter">}</span>
<span class="Comment">//: We could just reset the recipe table after every test, but that gets slow</span>
<span class="Comment">//: all too quickly. Instead, initialize the common stuff just once at</span>
<span class="Comment">//: startup. Later layers will carefully undo each test's additions after</span>
<span class="Comment">//: itself.</span>
<span class="Delimiter">:(before &quot;End One-time Setup&quot;)</span>
setup_recipes<span class="Delimiter">();</span>
assert<span class="Delimiter">(</span>MAX_PRIMITIVE_RECIPES &lt; <span class="Constant">100</span><span class="Delimiter">);</span>  <span class="Comment">// level 0 is primitives; until 99</span>
Next_recipe_number = <span class="Constant">100</span><span class="Delimiter">;</span>
<span class="Comment">// End Load Recipes</span>
<span class="Delimiter">:(before &quot;End Test Run Initialization&quot;)</span>
assert<span class="Delimiter">(</span>Next_recipe_number &lt; <span class="Constant">1000</span><span class="Delimiter">);</span>  <span class="Comment">// functions being tested didn't overflow into test space</span>
<span class="Delimiter">:(before &quot;End Setup&quot;)</span>
Next_recipe_number = <span class="Constant">1000</span><span class="Delimiter">;</span>  <span class="Comment">// consistent new numbers for each test</span>

^L

<span class="SalientComment">//:: Helpers</span>

<span class="Delimiter">:(code)</span>
instruction::instruction<span class="Delimiter">()</span> :is_label<span class="Delimiter">(</span><span class="Constant">false</span><span class="Delimiter">),</span> operation<span class="Delimiter">(</span>IDLE<span class="Delimiter">)</span> <span class="Delimiter">{}</span>
void instruction::clear<span class="Delimiter">()</span> <span class="Delimiter">{</span> is_label=<span class="Constant">false</span><span class="Delimiter">;</span> label<span class="Delimiter">.</span>clear<span class="Delimiter">();</span> operation=IDLE<span class="Delimiter">;</span> ingredients<span class="Delimiter">.</span>clear<span class="Delimiter">();</span> products<span class="Delimiter">.</span>clear<span class="Delimiter">();</span> <span class="Delimiter">}</span>

<span class="Comment">// Reagents have the form &lt;name&gt;:&lt;type&gt;:&lt;type&gt;:.../&lt;property&gt;/&lt;property&gt;/...</span>
reagent::reagent<span class="Delimiter">(</span>string s<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>
  istringstream in<span class="Delimiter">(</span>s<span class="Delimiter">);</span>
  in &gt;&gt; std::noskipws<span class="Delimiter">;</span>
  <span class="Comment">// properties</span>
  while <span class="Delimiter">(</span>!in<span class="Delimiter">.</span>eof<span class="Delimiter">())</span> <span class="Delimiter">{</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>
    row &gt;&gt; std::noskipws<span class="Delimiter">;</span>
    string name = slurp_until<span class="Delimiter">(</span>row<span class="Delimiter">,</span> <span class="Constant">':'</span><span class="Delimiter">);</span>
    vector&lt;string&gt; values<span class="Delimiter">;</span>
    while <span class="Delimiter">(</span>!row<span class="Delimiter">.</span>eof<span class="Delimiter">())</span>
      values<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>slurp_until<span class="Delimiter">(</span>row<span class="Delimiter">,</span> <span class="Constant">':'</span><span class="Delimiter">));</span>
    properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> vector&lt;string&gt; &gt;<span class="Delimiter">(</span>name<span class="Delimiter">,</span> values<span class="Delimiter">));</span>
  <span class="Delimiter">}</span>
  <span class="Comment">// structures for the first row of properties</span>
  name = properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>first<span class="Delimiter">;</span>
  for <span class="Delimiter">(</span>index_t i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>second<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    types<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>Type_number[properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>second<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">)</span>]<span class="Delimiter">);</span>
  <span class="Delimiter">}</span>
  if <span class="Delimiter">(</span>name == <span class="Constant">&quot;_&quot;</span> &amp;&amp; types<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
    types<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
    properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>second<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span><span class="Constant">&quot;dummy&quot;</span><span class="Delimiter">);</span>
  <span class="Delimiter">}</span>
<span class="Delimiter">}</span>
reagent::reagent<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 class="Comment">// The first property is special, so ensure we always have it.</span>
  <span class="Comment">// Other properties can be pushed back, but the first must always be</span>
  <span class="Comment">// assigned to.</span>
  properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> vector&lt;string&gt; &gt;<span class="Delimiter">(</span><span class="Constant">&quot;&quot;</span><span class="Delimiter">,</span> vector&lt;string&gt;<span class="Delimiter">()));</span>
<span class="Delimiter">}</span>
string reagent::to_string<span class="Delimiter">()</span> const <span class="Delimiter">{</span>
  ostringstream out<span class="Delimiter">;</span>
  out &lt;&lt; <span class="Constant">&quot;{name: </span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span> &lt;&lt; name &lt;&lt; <span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">, value: &quot;</span> &lt;&lt; value &lt;&lt; <span class="Constant">&quot;, type: &quot;</span><span class="Delimiter">;</span>
  for <span class="Delimiter">(</span>index_t i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; types<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    out &lt;&lt; types<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">);</span>
    if <span class="Delimiter">(</span>i &lt; types<span class="Delimiter">.</span>size<span class="Delimiter">()</span>-<span class="Constant">1</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;-&quot;</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  if <span class="Delimiter">(</span>!properties<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
    out &lt;&lt; <span class="Constant">&quot;, properties: [&quot;</span><span class="Delimiter">;</span>
    for <span class="Delimiter">(</span>index_t i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; properties<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
      out &lt;&lt; <span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span> &lt;&lt; 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><span class="Delimiter">;</span>
      for <span class="Delimiter">(</span>index_t j = <span class="Constant">0</span><span class="Delimiter">;</span> j &lt; properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++j<span class="Delimiter">)</span> <span class="Delimiter">{</span>
        out &lt;&lt; <span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span> &lt;&lt; properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>at<span class="Delimiter">(</span>j<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;</span><span class="cSpecial">\&quot;</span><span class="Constant">&quot;</span><span class="Delimiter">;</span>
        if <span class="Delimiter">(</span>j &lt; properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">.</span>size<span class="Delimiter">()</span>-<span class="Constant">1</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;:&quot;</span><span class="Delimiter">;</span>
      <span class="Delimiter">}</span>
      if <span class="Delimiter">(</span>i &lt; properties<span class="Delimiter">.</span>size<span class="Delimiter">()</span>-<span class="Constant">1</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">&quot;, &quot;</span><span class="Delimiter">;</span>
      else out &lt;&lt; <span class="Constant">&quot;]&quot;</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
  <span class="Delimiter">}</span>
  out &lt;&lt; <span class="Constant">&quot;}&quot;</span><span class="Delimiter">;</span>
  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

string instruction::to_string<span class="Delimiter">()</span> const <span class="Delimiter">{</span>
  if <span class="Delimiter">(</span>is_label<span class="Delimiter">)</span> <span class="Identifier">return</span> label<span class="Delimiter">;</span>
  ostringstream out<span class="Delimiter">;</span>
  for <span class="Delimiter">(</span>index_t i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; products<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    if <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>
    out &lt;&lt; products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>to_string<span class="Delimiter">();</span>
  <span class="Delimiter">}</span>
  if <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>
  out &lt;&lt; name &lt;&lt; <span class="Constant">'/'</span> &lt;&lt; operation &lt;&lt; <span class="Constant">' '</span><span class="Delimiter">;</span>
  for <span class="Delimiter">(</span>index_t i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; ingredients<span class="Delimiter">.</span>size<span class="Delimiter">();</span> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    if <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>
    out &lt;&lt; ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>to_string<span class="Delimiter">();</span>
  <span class="Delimiter">}</span>
  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

string slurp_until<span class="Delimiter">(</span>istream&amp; in<span class="Delimiter">,</span> char delim<span class="Delimiter">)</span> <span class="Delimiter">{</span>
  ostringstream out<span class="Delimiter">;</span>
  char c<span class="Delimiter">;</span>
  while <span class="Delimiter">(</span>in &gt;&gt; c<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    if <span class="Delimiter">(</span>c == delim<span class="Delimiter">)</span> <span class="Delimiter">{</span>
      <span class="Comment">// drop the delim</span>
      <span class="Identifier">break</span><span class="Delimiter">;</span>
    <span class="Delimiter">}</span>
    out &lt;&lt; c<span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
  <span class="Identifier">return</span> out<span class="Delimiter">.</span>str<span class="Delimiter">();</span>
<span class="Delimiter">}</span>

void dump_memory<span class="Delimiter">()</span> <span class="Delimiter">{</span>
  for <span class="Delimiter">(</span>map&lt;index_t<span class="Delimiter">,</span> double&gt;::iterator p = Memory<span class="Delimiter">.</span>begin<span class="Delimiter">();</span> p != Memory<span class="Delimiter">.</span>end<span class="Delimiter">();</span> ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
    cout &lt;&lt; p<span class="Delimiter">-&gt;</span>first &lt;&lt; <span class="Constant">&quot;: &quot;</span> &lt;&lt; p<span class="Delimiter">-&gt;</span>second &lt;&lt; <span class="cSpecial">'\n'</span><span class="Delimiter">;</span>
  <span class="Delimiter">}</span>
<span class="Delimiter">}</span>
<span class="Delimiter">:(before &quot;End Includes&quot;)</span>
<span class="PreProc">#include </span><span class="Constant">&lt;map&gt;</span>
using std::map<span class="Delimiter">;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->