about summary refs log tree commit diff stats
path: root/main.c
Commit message (Expand)AuthorAgeFilesLines
* applied Gottox patchesarg@mig292006-11-211-2/+3
* applied Gottox' windowarea patcharg@mig292006-11-161-1/+6
* code polishing, removed unnecessary newlinesAnselm R. Garbe2006-10-061-21/+9
* removed the stack position stuffAnselm R. Garbe2006-10-051-4/+1
* keep master ratio on resizecol -> arrangeAnselm R. Garbe2006-10-051-3/+3
* added symbols for different modesAnselm R. Garbe2006-09-291-2/+5
* removed useless updatemasterAnselm R. Garbe2006-09-291-1/+1
* added the new dotile as described on mlAnselm R. Garbe2006-09-291-1/+1
* first step to a more flexible dotile() algorithmAnselm R. Garbe2006-09-291-2/+2
* applied Jukkas patcharg@mmvi2006-09-251-3/+3
* implemented the maximization as I described on the mailinglist, this feels be...arg@mmvi2006-09-221-1/+0
* removed a bunch of lines through making function signatures more consistent w...Anselm R. Garbe2006-09-121-19/+11
* applied Christof Musik's multihead patch for a pathologic cornercaseAnselm R. Garbe2006-09-121-1/+2
* fixed some other comments, now also the code side seems to be at a level to b...Anselm R. Garbe2006-09-111-2/+2
* using a global stack for focus recovery on arrange() - seems to work greatAnselm R. Garbe2006-09-071-0/+1
* small fixAnselm R. Garbe2006-09-061-0/+1
* applied Sanders max_and_focus.patchAnselm R. Garbe2006-09-041-0/+1
* trying a different configurationAnselm R. Garbe2006-08-251-3/+3
* fixed typoAnselm R. Garbe2006-08-251-1/+1
* removed a bunch of lines, made mode symbols configurableAnselm R. Garbe2006-08-251-1/+1
* new color stuff/new rendering stuffAnselm R. Garbe2006-08-251-5/+9
* back to 3 colorsAnselm R. Garbe2006-08-251-4/+3
* 3->4 colorsAnselm R. Garbe2006-08-241-3/+4
* changing tag indicator through underlineAnselm R. Garbe2006-08-241-0/+1
* removed a blank lineAnselm R. Garbe2006-08-231-1/+0
* separated setup stuff into main.c:setup() - this makes main() more readableAnselm R. Garbe2006-08-231-86/+95
* rearranged getprotoAnselm R. Garbe2006-08-221-6/+5
* removed winprop (merged into getproto)Anselm R. Garbe2006-08-221-27/+7
* removed DEFTAGAnselm R. Garbe2006-08-221-1/+1
* small renamings of two static functionsAnselm R.Garbe2006-08-211-2/+2
* small changes to dwm.1, rearranged order within main event loopAnselm R.Garbe2006-08-211-4/+4
* corrected order of cleanup code Anselm R.Garbe2006-08-161-1/+1
* we close stdin as wellAnselm R.Garbe2006-08-161-3/+4
* extended cleanupAnselm R.Garbe2006-08-151-0/+7
* applied jk_to_tab patchAnselm R.Garbe2006-08-151-2/+1
* changed main event loopAnselm R.Garbe2006-08-151-10/+7
* removed NUMLOCKMASK, added dynamically calculated numlockmask insteadAnselm R.Garbe2006-08-141-7/+19
* changed order of selecting input at root windowAnselm R.Garbe2006-08-141-4/+4
* removed unneecessary crapAnselm R.Garbe2006-08-141-1/+0
* some other small fixesAnselm R.Garbe2006-08-141-8/+8
* removed ungrabkeys again (because of sander's mail)Anselm R.Garbe2006-08-141-1/+0
* implemented ungrabkeys() which is called in cleanup()Anselm R.Garbe2006-08-141-0/+1
* supplying NULL args in selectAnselm R.Garbe2006-08-141-1/+1
* reducing ConnectionNumber calls to a bare minimumAnselm R.Garbe2006-08-141-4/+5
* implemented viewextend and added M-S-C-n shortcuts for extending the current ...Anselm R.Garbe2006-08-111-3/+3
* implement multi-tag selection through button3 click on the specific tagAnselm R.Garbe2006-08-111-1/+3
* prepared 0.8 0.8Anselm R.Garbe2006-08-101-0/+1
* readded border color, this sucks leastAnselm R.Garbe2006-08-101-0/+1
* removed unnecessary border colorAnselm R.Garbe2006-08-101-1/+0
* removed NET_ACTIVE_WINDOW handlingAnselm R.Garbe2006-08-081-1/+0
n> #080808; } body { font-family: monospace; color: #eeeeee; background-color: #080808; } * { font-size: 1.05em; } .cSpecial { color: #008000; } .Constant { color: #00a0a0; } .Comment { color: #9090ff; } .Delimiter { color: #a04060; } .SalientComment { color: #00ffff; } .CommentedCode { color: #6c6c6c; } .PreProc { color: #c000c0; } .Identifier { color: #804000; } --> </style> <script type='text/javascript'> <!-- --> </script> </head> <body> <pre id='vimCodeElement'> <span class="Comment">//: A program is a book of 'recipes' (functions)</span> <span class="Delimiter">:(before &quot;End Globals&quot;)</span> <span class="Comment">//: Each recipe is stored at a specific page number, or ordinal.</span> map&lt;recipe_ordinal<span class="Delimiter">,</span> recipe&gt; Recipe<span class="Delimiter">;</span> <span class="Comment">//: You can also refer to each recipe by its name.</span> map&lt;string<span class="Delimiter">,</span> recipe_ordinal&gt; Recipe_ordinal<span class="Delimiter">;</span> recipe_ordinal Next_recipe_ordinal = <span class="Constant">1</span><span class="Delimiter">;</span> <span class="Comment">//: Ordinals are like numbers, except you can't do arithmetic on them. Ordinal</span> <span class="Comment">//: 1 is not less than 2, it's just different. Phone numbers are ordinals;</span> <span class="Comment">//: adding two phone numbers is meaningless. Here each recipe does something</span> <span class="Comment">//: incommensurable with any other recipe.</span> <span class="Delimiter">:(after &quot;Types&quot;)</span> typedef long long int recipe_ordinal<span class="Delimiter">;</span> <span class="Delimiter">:(before &quot;End Types&quot;)</span> <span class="Comment">// Recipes are lists of instructions. To perform or 'run' a recipe, the</span> <span class="Comment">// computer runs its 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_ordinal operation<span class="Delimiter">;</span> <span class="Comment">// Recipe_ordinal[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> string original_string<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> double value<span class="Delimiter">;</span> bool initialized<span class="Delimiter">;</span> vector&lt;type_ordinal&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>double 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;long long int<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 long long int type_ordinal<span class="Delimiter">;</span> <span class="Delimiter">:(before &quot;End Globals&quot;)</span> map&lt;string<span class="Delimiter">,</span> type_ordinal&gt; Type_ordinal<span class="Delimiter">;</span> map&lt;type_ordinal<span class="Delimiter">,</span> type_info&gt; Type<span class="Delimiter">;</span> type_ordinal Next_type_ordinal = <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_ordinal<span class="Delimiter">.</span>clear<span class="Delimiter">();</span> Type_ordinal[<span class="Constant">&quot;literal&quot;</span>] = <span class="Constant">0</span><span class="Delimiter">;</span> Next_type_ordinal = <span class="Constant">1</span><span class="Delimiter">;</span> <span class="Comment">// Mu Types Initialization</span> type_ordinal number = Type_ordinal[<span class="Constant">&quot;number&quot;</span>] = Next_type_ordinal++<span class="Delimiter">;</span> Type_ordinal[<span class="Constant">&quot;location&quot;</span>] = Type_ordinal[<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_ordinal address = Type_ordinal[<span class="Constant">&quot;address&quot;</span>] = Next_type_ordinal++<span class="Delimiter">;</span> Type[address]<span class="Delimiter">.</span>name = <span class="Constant">&quot;address&quot;</span><span class="Delimiter">;</span> type_ordinal boolean = Type_ordinal[<span class="Constant">&quot;boolean&quot;</span>] = Next_type_ordinal++<span class="Delimiter">;</span> Type[boolean]<span class="Delimiter">.</span>name = <span class="Constant">&quot;boolean&quot;</span><span class="Delimiter">;</span> type_ordinal character = Type_ordinal[<span class="Constant">&quot;character&quot;</span>] = Next_type_ordinal++<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_ordinal array = Type_ordinal[<span class="Constant">&quot;array&quot;</span>] = Next_type_ordinal++<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> long long int 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_ordinal&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_ordinal<span class="Delimiter">.</span>clear<span class="Delimiter">();</span> Recipe_ordinal[<span class="Constant">&quot;idle&quot;</span>] = IDLE<span class="Delimiter">;</span> <span class="Comment">// Primitive Recipe Numbers</span> Recipe_ordinal[<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_ordinal = <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_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 class="Delimiter">:(before &quot;End Setup&quot;)</span> Next_recipe_ordinal = <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> :original_string<span class="Delimiter">(</span>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>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<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> ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span> string type = 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> if <span class="Delimiter">(</span>Type_ordinal<span class="Delimiter">.</span>find<span class="Delimiter">(</span>type<span class="Delimiter">)</span> == Type_ordinal<span class="Delimiter">.</span>end<span class="Delimiter">())</span> <span class="Delimiter">{</span> <span class="CommentedCode">//? cerr &lt;&lt; type &lt;&lt; &quot; is &quot; &lt;&lt; Next_type_ordinal &lt;&lt; '\n'; //? 1</span> Type_ordinal[type] = Next_type_ordinal++<span class="Delimiter">;</span> <span class="Delimiter">}</span> types<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>Type_ordinal[type]<span class="Delimiter">);</span> <span class="Delimiter">}</span> if <span class="Delimiter">(</span>is_integer<span class="Delimiter">(</span>name<span class="Delimiter">)</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;literal&quot;</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">&quot;</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>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>properties<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>long long int j = <span class="Constant">0</span><span class="Delimiter">;</span> j &lt; SIZE<span class="Delimiter">(</span>properties<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">).</span>second<span class="Delimiter">);</span> ++j<span class="Delimiter">)</span> <span class="Delimiter">{</span> if <span class="Delimiter">(</span>j &gt; <span class="Constant">0</span><span class="Delimiter">)</span> out &lt;&lt; <span class="Constant">':'</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> <span class="Delimiter">}</span> if <span class="Delimiter">(</span>i &lt; SIZE<span class="Delimiter">(</span>properties<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="CommentedCode">//? if (properties.at(0).second.empty()) cerr &lt;&lt; out.str(); //? 1</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>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>products<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>original_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><span class="Delimiter">;</span> for <span class="Delimiter">(</span>long long int i = <span class="Constant">0</span><span class="Delimiter">;</span> i &lt; SIZE<span class="Delimiter">(</span>ingredients<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>original_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;long long int<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> <span class="PreProc">#include</span><span class="Constant">&lt;utility&gt;</span> using std::pair<span class="Delimiter">;</span> </pre> </body> </html> <!-- vim: set foldmethod=manual : -->