about summary refs log blame commit diff stats
path: root/README.md
blob: 7eb3a5e5c2f3162bdac8a5ccca7f367efda92e97 (plain) (tree)
1
2
3
4
5
6
7
8
9
10




                               
 
                                                                    
 

                                                                           
 

                                                                            
 

                                                                      

                                                                            
 
                                                                            
                                                           
 


                                                                           













                                                                              



                                                                              
# Plain text with lines

http://akkartik.name/lines.html

## Known issues

* No support yet for Unicode graphemes spanning multiple codepoints.

* Undo/redo can be sluggish in large files. If things get sluggish, killing
  the process can lose data.

* The text cursor will always stay on the screen. This can have some strange
  implications:

    * A long series of drawings will get silently skipped when you hit
      page-down, until a line of text can be showed on screen.
    * If there's no line of text at the top of the file, you may not be able
      to scroll back up to the top with page-up.

  So far this app isn't really designed for drawing-heavy files. For now I'm
  targeting mostly-text files with a few drawings mixed in.

* No clipping yet for drawings. In particular, circles and point labels can
  overflow a drawing.

* Insufficient handling of constraints when moving points. For example, if you
  draw a manhattan line and then move one of the points, you may not be able
  to hover on it anymore.

  There's two broad ways to fix this. The first is to relax constraints,
  switch the manhattan line to not be manhattan. The second is to try to
  maintain constraints. Either constrain the point to only move along one line
  (but what if it's connected to two manhattan lines?!), or constrain the
  other end of the line to move alongside. I'm not sure yet which would be
  more useful. Getting into constraints would also make the program more
  complex.

  Bottomline: at the moment moving points connected to manhattan lines,
  rectangles or squares can break drawings in subtle ways.

* Touchpads can drag the mouse pointer using a light touch or a heavy click.
  On Linux, drags using the light touch get interrupted when a key is pressed.
  You'll have to press down to drag.
eric.EmphStrong */ .highlight .gr { color: #aa0000 } /* Generic.Error */ .highlight .gh { color: #333333 } /* Generic.Heading */ .highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ .highlight .go { color: #888888 } /* Generic.Output */ .highlight .gp { color: #555555 } /* Generic.Prompt */ .highlight .gs { font-weight: bold } /* Generic.Strong */ .highlight .gu { color: #666666 } /* Generic.Subheading */ .highlight .gt { color: #aa0000 } /* Generic.Traceback */ .highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */ .highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */ .highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #008800 } /* Keyword.Pseudo */ .highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */
<!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 - 040brace.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: #eeeeee; background-color: #080808; }
body { font-size: 12pt; font-family: monospace; color: #eeeeee; background-color: #080808; }
* { font-size: 12pt; font-size: 1em; }
.Constant { color: #00a0a0; }
.Special { color: #c00000; }
.muRecipe { color: #ff8700; }
.traceContains { color: #008000; }
.Comment { color: #9090ff; }
.Delimiter { color: #800080; }
.LineNr { color: #444444; }
.Identifier { color: #c0a020; }
.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
.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'>
<a name="L1"></a><span id="L1" class="LineNr">  1 </span><span class="Comment">//: Structured programming</span>
<a name="L2"></a><span id="L2" class="LineNr">  2 </span><span class="Comment">//:</span>
<a name="L3"></a><span id="L3" class="LineNr">  3 </span><span class="Comment">//: Our jump recipes are quite inconvenient to use, so Mu provides a</span>
<a name="L4"></a><span id="L4" class="LineNr">  4 </span><span class="Comment">//: lightweight tool called 'transform_braces' to work in a slightly more</span>
<a name="L5"></a><span id="L5" class="LineNr">  5 </span><span class="Comment">//: convenient format with nested braces:</span>
<a name="L6"></a><span id="L6" class="LineNr">  6 </span><span class="Comment">//:</span>
<a name="L7"></a><span id="L7" class="LineNr">  7 </span><span class="Comment">//:   {</span>
<a name="L8"></a><span id="L8" class="LineNr">  8 </span><span class="Comment">//:     some instructions</span>
<a name="L9"></a><span id="L9" class="LineNr">  9 </span><span class="Comment">//:     {</span>
<a name="L10"></a><span id="L10" class="LineNr"> 10 </span><span class="Comment">//:       more instructions</span>
<a name="L11"></a><span id="L11" class="LineNr"> 11 </span><span class="Comment">//:     }</span>
<a name="L12"></a><span id="L12" class="LineNr"> 12 </span><span class="Comment">//:   }</span>
<a name="L13"></a><span id="L13" class="LineNr"> 13 </span><span class="Comment">//:</span>
<a name="L14"></a><span id="L14" class="LineNr"> 14 </span><span class="Comment">//: Braces are just labels, they require no special parsing. The pseudo</span>
<a name="L15"></a><span id="L15" class="LineNr"> 15 </span><span class="Comment">//: instructions 'loop' and 'break' jump to just after the enclosing '{' and</span>
<a name="L16"></a><span id="L16" class="LineNr"> 16 </span><span class="Comment">//: '}' respectively.</span>
<a name="L17"></a><span id="L17" class="LineNr"> 17 </span><span class="Comment">//:</span>
<a name="L18"></a><span id="L18" class="LineNr"> 18 </span><span class="Comment">//: Conditional and unconditional 'loop' and 'break' should give us 80% of the</span>
<a name="L19"></a><span id="L19" class="LineNr"> 19 </span><span class="Comment">//: benefits of the control-flow primitives we're used to in other languages,</span>
<a name="L20"></a><span id="L20" class="LineNr"> 20 </span><span class="Comment">//: like 'if', 'while', 'for', etc.</span>
<a name="L21"></a><span id="L21" class="LineNr"> 21 </span>
<a name="L22"></a><span id="L22" class="LineNr"> 22 </span><span class="Delimiter">:(scenarios transform)</span>
<a name="L23"></a><span id="L23" class="LineNr"> 23 </span><span class="Delimiter">:(scenario brace_conversion)</span>
<a name="L24"></a><span id="L24" class="LineNr"> 24 </span><span class="muRecipe">def</span> main [
<a name="L25"></a><span id="L25" class="LineNr"> 25 </span>  <span class="Delimiter">{</span>
<a name="L26"></a><span id="L26" class="LineNr"> 26 </span>    <span class="Identifier">break</span>
<a name="L27"></a><span id="L27" class="LineNr"> 27 </span>    <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L28"></a><span id="L28" class="LineNr"> 28 </span>  <span class="Delimiter">}</span>
<a name="L29"></a><span id="L29" class="LineNr"> 29 </span>]
<a name="L30"></a><span id="L30" class="LineNr"> 30 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L31"></a><span id="L31" class="LineNr"> 31 </span><span class="traceContains">+transform: jump 1:offset</span>
<a name="L32"></a><span id="L32" class="LineNr"> 32 </span><span class="traceContains">+transform: copy ...</span>
<a name="L33"></a><span id="L33" class="LineNr"> 33 </span>
<a name="L34"></a><span id="L34" class="LineNr"> 34 </span><span class="Delimiter">:(before &quot;End Instruction Modifying Transforms&quot;)</span>
<a name="L35"></a><span id="L35" class="LineNr"> 35 </span>Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>transform_braces<span class="Delimiter">);</span>  <span class="Comment">// idempotent</span>
<a name="L36"></a><span id="L36" class="LineNr"> 36 </span>
<a name="L37"></a><span id="L37" class="LineNr"> 37 </span><span class="Delimiter">:(code)</span>
<a name="L38"></a><span id="L38" class="LineNr"> 38 </span><span class="Normal">void</span> transform_braces<span class="Delimiter">(</span><span class="Normal">const</span> recipe_ordinal r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L39"></a><span id="L39" class="LineNr"> 39 </span>  <span class="Normal">const</span> <span class="Normal">int</span> OPEN = <span class="Constant">0</span><span class="Delimiter">,</span> CLOSE = <span class="Constant">1</span><span class="Delimiter">;</span>
<a name="L40"></a><span id="L40" class="LineNr"> 40 </span>  <span class="Comment">// use signed integer for step index because we'll be doing arithmetic on it</span>
<a name="L41"></a><span id="L41" class="LineNr"> 41 </span>  list&lt;pair&lt;<span class="Normal">int</span><span class="Comment">/*</span><span class="Comment">OPEN/CLOSE</span><span class="Comment">*/</span><span class="Delimiter">,</span> <span class="Comment">/*</span><span class="Comment">step</span><span class="Comment">*/</span><span class="Normal">int</span>&gt; &gt; braces<span class="Delimiter">;</span>
<a name="L42"></a><span id="L42" class="LineNr"> 42 </span>  trace<span class="Delimiter">(</span><span class="Constant">9991</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;--- transform braces for recipe &quot;</span> &lt;&lt; get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name &lt;&lt; end<span class="Delimiter">();</span>
<a name="L43"></a><span id="L43" class="LineNr"> 43 </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; SIZE<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>steps<span class="Delimiter">);</span>  ++index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L44"></a><span id="L44" class="LineNr"> 44 </span>    <span class="Normal">const</span> instruction&amp; inst = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
<a name="L45"></a><span id="L45" class="LineNr"> 45 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>label == <span class="Constant">&quot;{&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L46"></a><span id="L46" class="LineNr"> 46 </span>      trace<span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; maybe<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;push (open, &quot;</span> &lt;&lt; index &lt;&lt; <span class="Constant">&quot;)&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L47"></a><span id="L47" class="LineNr"> 47 </span>      braces<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;<span class="Normal">int</span><span class="Delimiter">,</span><span class="Normal">int</span>&gt;<span class="Delimiter">(</span>OPEN<span class="Delimiter">,</span> index<span class="Delimiter">));</span>
<a name="L48"></a><span id="L48" class="LineNr"> 48 </span>    <span class="Delimiter">}</span>
<a name="L49"></a><span id="L49" class="LineNr"> 49 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>label == <span class="Constant">&quot;}&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L50"></a><span id="L50" class="LineNr"> 50 </span>      trace<span class="Delimiter">(</span><span class="Constant">9993</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;push (close, &quot;</span> &lt;&lt; index &lt;&lt; <span class="Constant">&quot;)&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L51"></a><span id="L51" class="LineNr"> 51 </span>      braces<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;<span class="Normal">int</span><span class="Delimiter">,</span><span class="Normal">int</span>&gt;<span class="Delimiter">(</span>CLOSE<span class="Delimiter">,</span> index<span class="Delimiter">));</span>
<a name="L52"></a><span id="L52" class="LineNr"> 52 </span>    <span class="Delimiter">}</span>
<a name="L53"></a><span id="L53" class="LineNr"> 53 </span>  <span class="Delimiter">}</span>
<a name="L54"></a><span id="L54" class="LineNr"> 54 </span>  stack&lt;<span class="Comment">/*</span><span class="Comment">step</span><span class="Comment">*/</span><span class="Normal">int</span>&gt; open_braces<span class="Delimiter">;</span>
<a name="L55"></a><span id="L55" class="LineNr"> 55 </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; SIZE<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>steps<span class="Delimiter">);</span>  ++index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L56"></a><span id="L56" class="LineNr"> 56 </span>    instruction&amp; inst = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
<a name="L57"></a><span id="L57" class="LineNr"> 57 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>label == <span class="Constant">&quot;{&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L58"></a><span id="L58" class="LineNr"> 58 </span>      open_braces<span class="Delimiter">.</span>push<span class="Delimiter">(</span>index<span class="Delimiter">);</span>
<a name="L59"></a><span id="L59" class="LineNr"> 59 </span>      <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L60"></a><span id="L60" class="LineNr"> 60 </span>    <span class="Delimiter">}</span>
<a name="L61"></a><span id="L61" class="LineNr"> 61 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>label == <span class="Constant">&quot;}&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L62"></a><span id="L62" class="LineNr"> 62 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>open_braces<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<a name="L63"></a><span id="L63" class="LineNr"> 63 </span>        raise &lt;&lt; <span class="Constant">&quot;missing '{' in '&quot;</span> &lt;&lt; get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L64"></a><span id="L64" class="LineNr"> 64 </span>        <span class="Identifier">return</span><span class="Delimiter">;</span>
<a name="L65"></a><span id="L65" class="LineNr"> 65 </span>      <span class="Delimiter">}</span>
<a name="L66"></a><span id="L66" class="LineNr"> 66 </span>      open_braces<span class="Delimiter">.</span>pop<span class="Delimiter">();</span>
<a name="L67"></a><span id="L67" class="LineNr"> 67 </span>      <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L68"></a><span id="L68" class="LineNr"> 68 </span>    <span class="Delimiter">}</span>
<a name="L69"></a><span id="L69" class="LineNr"> 69 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>is_label<span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L70"></a><span id="L70" class="LineNr"> 70 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;loop&quot;</span>
<a name="L71"></a><span id="L71" class="LineNr"> 71 </span>         &amp;&amp; inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;loop-if&quot;</span>
<a name="L72"></a><span id="L72" class="LineNr"> 72 </span>         &amp;&amp; inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;loop-unless&quot;</span>
<a name="L73"></a><span id="L73" class="LineNr"> 73 </span>         &amp;&amp; inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;break&quot;</span>
<a name="L74"></a><span id="L74" class="LineNr"> 74 </span>         &amp;&amp; inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;break-if&quot;</span>
<a name="L75"></a><span id="L75" class="LineNr"> 75 </span>         &amp;&amp; inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;break-unless&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L76"></a><span id="L76" class="LineNr"> 76 </span>      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>old_name &lt;&lt; <span class="Constant">&quot; ...&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L77"></a><span id="L77" class="LineNr"> 77 </span>      <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L78"></a><span id="L78" class="LineNr"> 78 </span>    <span class="Delimiter">}</span>
<a name="L79"></a><span id="L79" class="LineNr"> 79 </span>    <span class="Comment">// check for errors</span>
<a name="L80"></a><span id="L80" class="LineNr"> 80 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-if&quot;</span><span class="Delimiter">)</span> != string::npos || inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-unless&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L81"></a><span id="L81" class="LineNr"> 81 </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> <span class="Delimiter">{</span>
<a name="L82"></a><span id="L82" class="LineNr"> 82 </span>        raise &lt;&lt; <span class="Constant">&quot;'&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>old_name &lt;&lt; <span class="Constant">&quot;' expects 1 or 2 ingredients, but got none</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L83"></a><span id="L83" class="LineNr"> 83 </span>        <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L84"></a><span id="L84" class="LineNr"> 84 </span>      <span class="Delimiter">}</span>
<a name="L85"></a><span id="L85" class="LineNr"> 85 </span>    <span class="Delimiter">}</span>
<a name="L86"></a><span id="L86" class="LineNr"> 86 </span>    <span class="Comment">// update instruction operation</span>
<a name="L87"></a><span id="L87" class="LineNr"> 87 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-if&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L88"></a><span id="L88" class="LineNr"> 88 </span>      inst<span class="Delimiter">.</span>name = <span class="Constant">&quot;jump-if&quot;</span><span class="Delimiter">;</span>
<a name="L89"></a><span id="L89" class="LineNr"> 89 </span>      inst<span class="Delimiter">.</span>operation = JUMP_IF<span class="Delimiter">;</span>
<a name="L90"></a><span id="L90" class="LineNr"> 90 </span>    <span class="Delimiter">}</span>
<a name="L91"></a><span id="L91" class="LineNr"> 91 </span>    <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-unless&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L92"></a><span id="L92" class="LineNr"> 92 </span>      inst<span class="Delimiter">.</span>name = <span class="Constant">&quot;jump-unless&quot;</span><span class="Delimiter">;</span>
<a name="L93"></a><span id="L93" class="LineNr"> 93 </span>      inst<span class="Delimiter">.</span>operation = JUMP_UNLESS<span class="Delimiter">;</span>
<a name="L94"></a><span id="L94" class="LineNr"> 94 </span>    <span class="Delimiter">}</span>
<a name="L95"></a><span id="L95" class="LineNr"> 95 </span>    <span class="Normal">else</span> <span class="Delimiter">{</span>
<a name="L96"></a><span id="L96" class="LineNr"> 96 </span>      inst<span class="Delimiter">.</span>name = <span class="Constant">&quot;jump&quot;</span><span class="Delimiter">;</span>
<a name="L97"></a><span id="L97" class="LineNr"> 97 </span>      inst<span class="Delimiter">.</span>operation = JUMP<span class="Delimiter">;</span>
<a name="L98"></a><span id="L98" class="LineNr"> 98 </span>    <span class="Delimiter">}</span>
<a name="L99"></a><span id="L99" class="LineNr"> 99 </span>    <span class="Comment">// check for explicitly provided targets</span>
<a name="L100"></a><span id="L100" class="LineNr">100 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-if&quot;</span><span class="Delimiter">)</span> != string::npos || inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;-unless&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L101"></a><span id="L101" class="LineNr">101 </span>      <span class="Comment">// conditional branches check arg 1</span>
<a name="L102"></a><span id="L102" class="LineNr">102 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>SIZE<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">)</span> &gt; <span class="Constant">1</span> &amp;&amp; is_literal<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<a name="L103"></a><span id="L103" class="LineNr">103 </span>        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">1</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
<a name="L104"></a><span id="L104" class="LineNr">104 </span>        <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L105"></a><span id="L105" class="LineNr">105 </span>      <span class="Delimiter">}</span>
<a name="L106"></a><span id="L106" class="LineNr">106 </span>    <span class="Delimiter">}</span>
<a name="L107"></a><span id="L107" class="LineNr">107 </span>    <span class="Normal">else</span> <span class="Delimiter">{</span>
<a name="L108"></a><span id="L108" class="LineNr">108 </span>      <span class="Comment">// unconditional branches check arg 0</span>
<a name="L109"></a><span id="L109" class="LineNr">109 </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> &amp;&amp; is_literal<span class="Delimiter">(</span>inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">)))</span> <span class="Delimiter">{</span>
<a name="L110"></a><span id="L110" class="LineNr">110 </span>        trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
<a name="L111"></a><span id="L111" class="LineNr">111 </span>        <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L112"></a><span id="L112" class="LineNr">112 </span>      <span class="Delimiter">}</span>
<a name="L113"></a><span id="L113" class="LineNr">113 </span>    <span class="Delimiter">}</span>
<a name="L114"></a><span id="L114" class="LineNr">114 </span>    <span class="Comment">// if implicit, compute target</span>
<a name="L115"></a><span id="L115" class="LineNr">115 </span>    reagent target<span class="Delimiter">;</span>
<a name="L116"></a><span id="L116" class="LineNr">116 </span>    target<span class="Delimiter">.</span>type = <span class="Normal">new</span> type_tree<span class="Delimiter">(</span><span class="Constant">&quot;offset&quot;</span><span class="Delimiter">);</span>
<a name="L117"></a><span id="L117" class="LineNr">117 </span>    target<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<a name="L118"></a><span id="L118" class="LineNr">118 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>open_braces<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
<a name="L119"></a><span id="L119" class="LineNr">119 </span>      raise &lt;&lt; <span class="Constant">&quot;'&quot;</span> &lt;&lt; inst<span class="Delimiter">.</span>old_name &lt;&lt; <span class="Constant">&quot;' needs a '{' before</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L120"></a><span id="L120" class="LineNr">120 </span>    <span class="Normal">else</span> <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;loop&quot;</span><span class="Delimiter">)</span> != string::npos<span class="Delimiter">)</span>
<a name="L121"></a><span id="L121" class="LineNr">121 </span>      target<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>open_braces<span class="Delimiter">.</span>top<span class="Delimiter">()</span>-index<span class="Delimiter">);</span>
<a name="L122"></a><span id="L122" class="LineNr">122 </span>    <span class="Normal">else</span>  <span class="Comment">// break instruction</span>
<a name="L123"></a><span id="L123" class="LineNr">123 </span>      target<span class="Delimiter">.</span>set_value<span class="Delimiter">(</span>matching_brace<span class="Delimiter">(</span>open_braces<span class="Delimiter">.</span>top<span class="Delimiter">(),</span> braces<span class="Delimiter">,</span> r<span class="Delimiter">)</span> - index - <span class="Constant">1</span><span class="Delimiter">);</span>
<a name="L124"></a><span id="L124" class="LineNr">124 </span>    inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>target<span class="Delimiter">);</span>
<a name="L125"></a><span id="L125" class="LineNr">125 </span>    <span class="Comment">// log computed target</span>
<a name="L126"></a><span id="L126" class="LineNr">126 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>name == <span class="Constant">&quot;jump&quot;</span><span class="Delimiter">)</span>
<a name="L127"></a><span id="L127" class="LineNr">127 </span>      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;jump &quot;</span> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
<a name="L128"></a><span id="L128" class="LineNr">128 </span>    <span class="Normal">else</span>
<a name="L129"></a><span id="L129" class="LineNr">129 </span>      trace<span class="Delimiter">(</span><span class="Constant">9992</span><span class="Delimiter">,</span> <span class="Constant">&quot;transform&quot;</span><span class="Delimiter">)</span> &lt;&lt; inst<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">' '</span> &lt;&lt; inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name &lt;&lt; <span class="Constant">&quot;, &quot;</span> &lt;&lt; no_scientific<span class="Delimiter">(</span>target<span class="Delimiter">.</span>value<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;:offset</span><span class="Constant">&quot; &lt;&lt; end();</span>
<a name="L130"></a><span id="L130" class="LineNr">130 </span>  <span class="Delimiter">}</span>
<a name="L131"></a><span id="L131" class="LineNr">131 </span><span class="Delimiter">}</span>
<a name="L132"></a><span id="L132" class="LineNr">132 </span>
<a name="L133"></a><span id="L133" class="LineNr">133 </span><span class="Comment">// returns a signed integer not just so that we can return -1 but also to</span>
<a name="L134"></a><span id="L134" class="LineNr">134 </span><span class="Comment">// enable future signed arithmetic</span>
<a name="L135"></a><span id="L135" class="LineNr">135 </span><span class="Normal">int</span> matching_brace<span class="Delimiter">(</span><span class="Normal">int</span> index<span class="Delimiter">,</span> <span class="Normal">const</span> list&lt;pair&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt; &gt;&amp; braces<span class="Delimiter">,</span> recipe_ordinal r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L136"></a><span id="L136" class="LineNr">136 </span>  <span class="Normal">int</span> stacksize = <span class="Constant">0</span><span class="Delimiter">;</span>
<a name="L137"></a><span id="L137" class="LineNr">137 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>list&lt;pair&lt;<span class="Normal">int</span><span class="Delimiter">,</span> <span class="Normal">int</span>&gt; &gt;::const_iterator p = braces<span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != braces<span class="Delimiter">.</span>end<span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L138"></a><span id="L138" class="LineNr">138 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>second &lt; index<span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<a name="L139"></a><span id="L139" class="LineNr">139 </span>    stacksize += <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first ? <span class="Constant">1</span> : -<span class="Constant">1</span><span class="Delimiter">);</span>
<a name="L140"></a><span id="L140" class="LineNr">140 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>stacksize == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">return</span> p<span class="Delimiter">-&gt;</span>second<span class="Delimiter">;</span>
<a name="L141"></a><span id="L141" class="LineNr">141 </span>  <span class="Delimiter">}</span>
<a name="L142"></a><span id="L142" class="LineNr">142 </span>  raise &lt;&lt; maybe<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>name<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;unbalanced '{'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L143"></a><span id="L143" class="LineNr">143 </span>  <span class="Identifier">return</span> SIZE<span class="Delimiter">(</span>get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">).</span>steps<span class="Delimiter">);</span>  <span class="Comment">// exit current routine</span>
<a name="L144"></a><span id="L144" class="LineNr">144 </span><span class="Delimiter">}</span>
<a name="L145"></a><span id="L145" class="LineNr">145 </span>
<a name="L146"></a><span id="L146" class="LineNr">146 </span><span class="Delimiter">:(scenario loop)</span>
<a name="L147"></a><span id="L147" class="LineNr">147 </span><span class="muRecipe">def</span> main [
<a name="L148"></a><span id="L148" class="LineNr">148 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L149"></a><span id="L149" class="LineNr">149 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L150"></a><span id="L150" class="LineNr">150 </span>  <span class="Delimiter">{</span>
<a name="L151"></a><span id="L151" class="LineNr">151 </span>    <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L152"></a><span id="L152" class="LineNr">152 </span>    loop
<a name="L153"></a><span id="L153" class="LineNr">153 </span>  <span class="Delimiter">}</span>
<a name="L154"></a><span id="L154" class="LineNr">154 </span>]
<a name="L155"></a><span id="L155" class="LineNr">155 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L156"></a><span id="L156" class="LineNr">156 </span><span class="traceContains">+transform: copy ...</span>
<a name="L157"></a><span id="L157" class="LineNr">157 </span><span class="traceContains">+transform: copy ...</span>
<a name="L158"></a><span id="L158" class="LineNr">158 </span><span class="traceContains">+transform: copy ...</span>
<a name="L159"></a><span id="L159" class="LineNr">159 </span><span class="traceContains">+transform: jump -2:offset</span>
<a name="L160"></a><span id="L160" class="LineNr">160 </span>
<a name="L161"></a><span id="L161" class="LineNr">161 </span><span class="Delimiter">:(scenario break_empty_block)</span>
<a name="L162"></a><span id="L162" class="LineNr">162 </span><span class="muRecipe">def</span> main [
<a name="L163"></a><span id="L163" class="LineNr">163 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L164"></a><span id="L164" class="LineNr">164 </span>  <span class="Delimiter">{</span>
<a name="L165"></a><span id="L165" class="LineNr">165 </span>    <span class="Identifier">break</span>
<a name="L166"></a><span id="L166" class="LineNr">166 </span>  <span class="Delimiter">}</span>
<a name="L167"></a><span id="L167" class="LineNr">167 </span>]
<a name="L168"></a><span id="L168" class="LineNr">168 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L169"></a><span id="L169" class="LineNr">169 </span><span class="traceContains">+transform: copy ...</span>
<a name="L170"></a><span id="L170" class="LineNr">170 </span><span class="traceContains">+transform: jump 0:offset</span>
<a name="L171"></a><span id="L171" class="LineNr">171 </span>
<a name="L172"></a><span id="L172" class="LineNr">172 </span><span class="Delimiter">:(scenario break_cascading)</span>
<a name="L173"></a><span id="L173" class="LineNr">173 </span><span class="muRecipe">def</span> main [
<a name="L174"></a><span id="L174" class="LineNr">174 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L175"></a><span id="L175" class="LineNr">175 </span>  <span class="Delimiter">{</span>
<a name="L176"></a><span id="L176" class="LineNr">176 </span>    <span class="Identifier">break</span>
<a name="L177"></a><span id="L177" class="LineNr">177 </span>  <span class="Delimiter">}</span>
<a name="L178"></a><span id="L178" class="LineNr">178 </span>  <span class="Delimiter">{</span>
<a name="L179"></a><span id="L179" class="LineNr">179 </span>    <span class="Identifier">break</span>
<a name="L180"></a><span id="L180" class="LineNr">180 </span>  <span class="Delimiter">}</span>
<a name="L181"></a><span id="L181" class="LineNr">181 </span>]
<a name="L182"></a><span id="L182" class="LineNr">182 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L183"></a><span id="L183" class="LineNr">183 </span><span class="traceContains">+transform: copy ...</span>
<a name="L184"></a><span id="L184" class="LineNr">184 </span><span class="traceContains">+transform: jump 0:offset</span>
<a name="L185"></a><span id="L185" class="LineNr">185 </span><span class="traceContains">+transform: jump 0:offset</span>
<a name="L186"></a><span id="L186" class="LineNr">186 </span>
<a name="L187"></a><span id="L187" class="LineNr">187 </span><span class="Delimiter">:(scenario break_cascading_2)</span>
<a name="L188"></a><span id="L188" class="LineNr">188 </span><span class="muRecipe">def</span> main [
<a name="L189"></a><span id="L189" class="LineNr">189 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L190"></a><span id="L190" class="LineNr">190 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L191"></a><span id="L191" class="LineNr">191 </span>  <span class="Delimiter">{</span>
<a name="L192"></a><span id="L192" class="LineNr">192 </span>    <span class="Identifier">break</span>
<a name="L193"></a><span id="L193" class="LineNr">193 </span>    <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L194"></a><span id="L194" class="LineNr">194 </span>  <span class="Delimiter">}</span>
<a name="L195"></a><span id="L195" class="LineNr">195 </span>  <span class="Delimiter">{</span>
<a name="L196"></a><span id="L196" class="LineNr">196 </span>    <span class="Identifier">break</span>
<a name="L197"></a><span id="L197" class="LineNr">197 </span>  <span class="Delimiter">}</span>
<a name="L198"></a><span id="L198" class="LineNr">198 </span>]
<a name="L199"></a><span id="L199" class="LineNr">199 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L200"></a><span id="L200" class="LineNr">200 </span><span class="traceContains">+transform: copy ...</span>
<a name="L201"></a><span id="L201" class="LineNr">201 </span><span class="traceContains">+transform: copy ...</span>
<a name="L202"></a><span id="L202" class="LineNr">202 </span><span class="traceContains">+transform: jump 1:offset</span>
<a name="L203"></a><span id="L203" class="LineNr">203 </span><span class="traceContains">+transform: copy ...</span>
<a name="L204"></a><span id="L204" class="LineNr">204 </span><span class="traceContains">+transform: jump 0:offset</span>
<a name="L205"></a><span id="L205" class="LineNr">205 </span>
<a name="L206"></a><span id="L206" class="LineNr">206 </span><span class="Delimiter">:(scenario break_if)</span>
<a name="L207"></a><span id="L207" class="LineNr">207 </span><span class="muRecipe">def</span> main [
<a name="L208"></a><span id="L208" class="LineNr">208 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L209"></a><span id="L209" class="LineNr">209 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L210"></a><span id="L210" class="LineNr">210 </span>  <span class="Delimiter">{</span>
<a name="L211"></a><span id="L211" class="LineNr">211 </span>    <span class="Identifier">break</span>-<span class="Normal">if</span> <span class="Constant">2</span>:num
<a name="L212"></a><span id="L212" class="LineNr">212 </span>    <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L213"></a><span id="L213" class="LineNr">213 </span>  <span class="Delimiter">}</span>
<a name="L214"></a><span id="L214" class="LineNr">214 </span>  <span class="Delimiter">{</span>
<a name="L215"></a><span id="L215" class="LineNr">215 </span>    <span class="Identifier">break</span>
<a name="L216"></a><span id="L216" class="LineNr">216 </span>  <span class="Delimiter">}</span>
<a name="L217"></a><span id="L217" class="LineNr">217 </span>]
<a name="L218"></a><span id="L218" class="LineNr">218 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L219"></a><span id="L219" class="LineNr">219 </span><span class="traceContains">+transform: copy ...</span>
<a name="L220"></a><span id="L220" class="LineNr">220 </span><span class="traceContains">+transform: copy ...</span>
<a name="L221"></a><span id="L221" class="LineNr">221 </span><span class="traceContains">+transform: jump-if 2, 1:offset</span>
<a name="L222"></a><span id="L222" class="LineNr">222 </span><span class="traceContains">+transform: copy ...</span>
<a name="L223"></a><span id="L223" class="LineNr">223 </span><span class="traceContains">+transform: jump 0:offset</span>
<a name="L224"></a><span id="L224" class="LineNr">224 </span>
<a name="L225"></a><span id="L225" class="LineNr">225 </span><span class="Delimiter">:(scenario break_nested)</span>
<a name="L226"></a><span id="L226" class="LineNr">226 </span><span class="muRecipe">def</span> main [
<a name="L227"></a><span id="L227" class="LineNr">227 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L228"></a><span id="L228" class="LineNr">228 </span>  <span class="Delimiter">{</span>
<a name="L229"></a><span id="L229" class="LineNr">229 </span>    <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L230"></a><span id="L230" class="LineNr">230 </span>    <span class="Identifier">break</span>
<a name="L231"></a><span id="L231" class="LineNr">231 </span>    <span class="Delimiter">{</span>
<a name="L232"></a><span id="L232" class="LineNr">232 </span>      <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L233"></a><span id="L233" class="LineNr">233 </span>    <span class="Delimiter">}</span>
<a name="L234"></a><span id="L234" class="LineNr">234 </span>    <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L235"></a><span id="L235" class="LineNr">235 </span>  <span class="Delimiter">}</span>
<a name="L236"></a><span id="L236" class="LineNr">236 </span>]
<a name="L237"></a><span id="L237" class="LineNr">237 </span><span class="traceContains">+transform: jump 4:offset</span>
<a name="L238"></a><span id="L238" class="LineNr">238 </span>
<a name="L239"></a><span id="L239" class="LineNr">239 </span><span class="Delimiter">:(scenario break_nested_degenerate)</span>
<a name="L240"></a><span id="L240" class="LineNr">240 </span><span class="muRecipe">def</span> main [
<a name="L241"></a><span id="L241" class="LineNr">241 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L242"></a><span id="L242" class="LineNr">242 </span>  <span class="Delimiter">{</span>
<a name="L243"></a><span id="L243" class="LineNr">243 </span>    <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L244"></a><span id="L244" class="LineNr">244 </span>    <span class="Identifier">break</span>
<a name="L245"></a><span id="L245" class="LineNr">245 </span>    <span class="Delimiter">{</span>
<a name="L246"></a><span id="L246" class="LineNr">246 </span>    <span class="Delimiter">}</span>
<a name="L247"></a><span id="L247" class="LineNr">247 </span>    <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L248"></a><span id="L248" class="LineNr">248 </span>  <span class="Delimiter">}</span>
<a name="L249"></a><span id="L249" class="LineNr">249 </span>]
<a name="L250"></a><span id="L250" class="LineNr">250 </span><span class="traceContains">+transform: jump 3:offset</span>
<a name="L251"></a><span id="L251" class="LineNr">251 </span>
<a name="L252"></a><span id="L252" class="LineNr">252 </span><span class="Delimiter">:(scenario break_nested_degenerate_2)</span>
<a name="L253"></a><span id="L253" class="LineNr">253 </span><span class="muRecipe">def</span> main [
<a name="L254"></a><span id="L254" class="LineNr">254 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L255"></a><span id="L255" class="LineNr">255 </span>  <span class="Delimiter">{</span>
<a name="L256"></a><span id="L256" class="LineNr">256 </span>    <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L257"></a><span id="L257" class="LineNr">257 </span>    <span class="Identifier">break</span>
<a name="L258"></a><span id="L258" class="LineNr">258 </span>    <span class="Delimiter">{</span>
<a name="L259"></a><span id="L259" class="LineNr">259 </span>    <span class="Delimiter">}</span>
<a name="L260"></a><span id="L260" class="LineNr">260 </span>  <span class="Delimiter">}</span>
<a name="L261"></a><span id="L261" class="LineNr">261 </span>]
<a name="L262"></a><span id="L262" class="LineNr">262 </span><span class="traceContains">+transform: jump 2:offset</span>
<a name="L263"></a><span id="L263" class="LineNr">263 </span>
<a name="L264"></a><span id="L264" class="LineNr">264 </span><span class="Delimiter">:(scenario break_label)</span>
<a name="L265"></a><span id="L265" class="LineNr">265 </span><span class="Special">% Hide_errors = true;</span>
<a name="L266"></a><span id="L266" class="LineNr">266 </span><span class="muRecipe">def</span> main [
<a name="L267"></a><span id="L267" class="LineNr">267 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L268"></a><span id="L268" class="LineNr">268 </span>  <span class="Delimiter">{</span>
<a name="L269"></a><span id="L269" class="LineNr">269 </span>    <span class="Identifier">break</span> <span class="Constant">+foo:offset</span>
<a name="L270"></a><span id="L270" class="LineNr">270 </span>  <span class="Delimiter">}</span>
<a name="L271"></a><span id="L271" class="LineNr">271 </span>]
<a name="L272"></a><span id="L272" class="LineNr">272 </span><span class="traceContains">+transform: jump +foo:offset</span>
<a name="L273"></a><span id="L273" class="LineNr">273 </span>
<a name="L274"></a><span id="L274" class="LineNr">274 </span><span class="Delimiter">:(scenario break_unless)</span>
<a name="L275"></a><span id="L275" class="LineNr">275 </span><span class="muRecipe">def</span> main [
<a name="L276"></a><span id="L276" class="LineNr">276 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L277"></a><span id="L277" class="LineNr">277 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L278"></a><span id="L278" class="LineNr">278 </span>  <span class="Delimiter">{</span>
<a name="L279"></a><span id="L279" class="LineNr">279 </span>    <span class="Identifier">break</span>-unless <span class="Constant">2</span>:num
<a name="L280"></a><span id="L280" class="LineNr">280 </span>    <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L281"></a><span id="L281" class="LineNr">281 </span>  <span class="Delimiter">}</span>
<a name="L282"></a><span id="L282" class="LineNr">282 </span>]
<a name="L283"></a><span id="L283" class="LineNr">283 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L284"></a><span id="L284" class="LineNr">284 </span><span class="traceContains">+transform: copy ...</span>
<a name="L285"></a><span id="L285" class="LineNr">285 </span><span class="traceContains">+transform: copy ...</span>
<a name="L286"></a><span id="L286" class="LineNr">286 </span><span class="traceContains">+transform: jump-unless 2, 1:offset</span>
<a name="L287"></a><span id="L287" class="LineNr">287 </span><span class="traceContains">+transform: copy ...</span>
<a name="L288"></a><span id="L288" class="LineNr">288 </span>
<a name="L289"></a><span id="L289" class="LineNr">289 </span><span class="Delimiter">:(scenario loop_unless)</span>
<a name="L290"></a><span id="L290" class="LineNr">290 </span><span class="muRecipe">def</span> main [
<a name="L291"></a><span id="L291" class="LineNr">291 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L292"></a><span id="L292" class="LineNr">292 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L293"></a><span id="L293" class="LineNr">293 </span>  <span class="Delimiter">{</span>
<a name="L294"></a><span id="L294" class="LineNr">294 </span>    loop-unless <span class="Constant">2</span>:num
<a name="L295"></a><span id="L295" class="LineNr">295 </span>    <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L296"></a><span id="L296" class="LineNr">296 </span>  <span class="Delimiter">}</span>
<a name="L297"></a><span id="L297" class="LineNr">297 </span>]
<a name="L298"></a><span id="L298" class="LineNr">298 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L299"></a><span id="L299" class="LineNr">299 </span><span class="traceContains">+transform: copy ...</span>
<a name="L300"></a><span id="L300" class="LineNr">300 </span><span class="traceContains">+transform: copy ...</span>
<a name="L301"></a><span id="L301" class="LineNr">301 </span><span class="traceContains">+transform: jump-unless 2, -1:offset</span>
<a name="L302"></a><span id="L302" class="LineNr">302 </span><span class="traceContains">+transform: copy ...</span>
<a name="L303"></a><span id="L303" class="LineNr">303 </span>
<a name="L304"></a><span id="L304" class="LineNr">304 </span><span class="Delimiter">:(scenario loop_nested)</span>
<a name="L305"></a><span id="L305" class="LineNr">305 </span><span class="muRecipe">def</span> main [
<a name="L306"></a><span id="L306" class="LineNr">306 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L307"></a><span id="L307" class="LineNr">307 </span>  <span class="Delimiter">{</span>
<a name="L308"></a><span id="L308" class="LineNr">308 </span>    <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L309"></a><span id="L309" class="LineNr">309 </span>    <span class="Delimiter">{</span>
<a name="L310"></a><span id="L310" class="LineNr">310 </span>      <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L311"></a><span id="L311" class="LineNr">311 </span>    <span class="Delimiter">}</span>
<a name="L312"></a><span id="L312" class="LineNr">312 </span>    loop-<span class="Normal">if</span> <span class="Constant">4</span>:<span class="Normal">bool</span>
<a name="L313"></a><span id="L313" class="LineNr">313 </span>    <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L314"></a><span id="L314" class="LineNr">314 </span>  <span class="Delimiter">}</span>
<a name="L315"></a><span id="L315" class="LineNr">315 </span>]
<a name="L316"></a><span id="L316" class="LineNr">316 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L317"></a><span id="L317" class="LineNr">317 </span><span class="traceContains">+transform: jump-if 4, -5:offset</span>
<a name="L318"></a><span id="L318" class="LineNr">318 </span>
<a name="L319"></a><span id="L319" class="LineNr">319 </span><span class="Delimiter">:(scenario loop_label)</span>
<a name="L320"></a><span id="L320" class="LineNr">320 </span><span class="muRecipe">def</span> main [
<a name="L321"></a><span id="L321" class="LineNr">321 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L322"></a><span id="L322" class="LineNr">322 </span>  +foo
<a name="L323"></a><span id="L323" class="LineNr">323 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<a name="L324"></a><span id="L324" class="LineNr">324 </span>]
<a name="L325"></a><span id="L325" class="LineNr">325 </span><span class="traceContains">+transform: --- transform braces for recipe main</span>
<a name="L326"></a><span id="L326" class="LineNr">326 </span><span class="traceContains">+transform: copy ...</span>
<a name="L327"></a><span id="L327" class="LineNr">327 </span><span class="traceContains">+transform: copy ...</span>
<a name="L328"></a><span id="L328" class="LineNr">328 </span>
<a name="L329"></a><span id="L329" class="LineNr">329 </span><span class="Comment">//: test how things actually run</span>
<a name="L330"></a><span id="L330" class="LineNr">330 </span><span class="Delimiter">:(scenarios run)</span>
<a name="L331"></a><span id="L331" class="LineNr">331 </span><span class="Delimiter">:(scenario brace_conversion_and_run)</span>
<a name="L332"></a><span id="L332" class="LineNr">332 </span><span class="muRecipe">def</span> test-factorial [
<a name="L333"></a><span id="L333" class="LineNr">333 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>
<a name="L334"></a><span id="L334" class="LineNr">334 </span>  <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">1</span>
<a name="L335"></a><span id="L335" class="LineNr">335 </span>  <span class="Delimiter">{</span>
<a name="L336"></a><span id="L336" class="LineNr">336 </span>    <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
<a name="L337"></a><span id="L337" class="LineNr">337 </span>    <span class="Identifier">break</span>-<span class="Normal">if</span> <span class="Constant">3</span>:<span class="Normal">bool</span>
<a name="L338"></a><span id="L338" class="LineNr">338 </span><span class="Comment">#    $print 1:num</span>
<a name="L339"></a><span id="L339" class="LineNr">339 </span>    <span class="Constant">2</span>:num<span class="Special"> &lt;- </span>multiply <span class="Constant">2</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>:num
<a name="L340"></a><span id="L340" class="LineNr">340 </span>    <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>subtract <span class="Constant">1</span>:num<span class="Delimiter">,</span> <span class="Constant">1</span>
<a name="L341"></a><span id="L341" class="LineNr">341 </span>    loop
<a name="L342"></a><span id="L342" class="LineNr">342 </span>  <span class="Delimiter">}</span>
<a name="L343"></a><span id="L343" class="LineNr">343 </span>  <span class="Constant">4</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>:num  <span class="Comment"># trigger a read</span>
<a name="L344"></a><span id="L344" class="LineNr">344 </span>]
<a name="L345"></a><span id="L345" class="LineNr">345 </span><span class="traceContains">+mem: location 2 is 120</span>
<a name="L346"></a><span id="L346" class="LineNr">346 </span>
<a name="L347"></a><span id="L347" class="LineNr">347 </span><span class="Delimiter">:(scenario break_outside_braces_fails)</span>
<a name="L348"></a><span id="L348" class="LineNr">348 </span><span class="Special">% Hide_errors = true;</span>
<a name="L349"></a><span id="L349" class="LineNr">349 </span><span class="muRecipe">def</span> main [
<a name="L350"></a><span id="L350" class="LineNr">350 </span>  <span class="Identifier">break</span>
<a name="L351"></a><span id="L351" class="LineNr">351 </span>]
<a name="L352"></a><span id="L352" class="LineNr">352 </span><span class="traceContains">+error: 'break' needs a '{' before</span>
<a name="L353"></a><span id="L353" class="LineNr">353 </span>
<a name="L354"></a><span id="L354" class="LineNr">354 </span><span class="Delimiter">:(scenario break_conditional_without_ingredient_fails)</span>
<a name="L355"></a><span id="L355" class="LineNr">355 </span><span class="Special">% Hide_errors = true;</span>
<a name="L356"></a><span id="L356" class="LineNr">356 </span><span class="muRecipe">def</span> main [
<a name="L357"></a><span id="L357" class="LineNr">357 </span>  <span class="Delimiter">{</span>
<a name="L358"></a><span id="L358" class="LineNr">358 </span>    <span class="Identifier">break</span>-<span class="Normal">if</span>
<a name="L359"></a><span id="L359" class="LineNr">359 </span>  <span class="Delimiter">}</span>
<a name="L360"></a><span id="L360" class="LineNr">360 </span>]
<a name="L361"></a><span id="L361" class="LineNr">361 </span><span class="traceContains">+error: 'break-if' expects 1 or 2 ingredients, but got none</span>
<a name="L362"></a><span id="L362" class="LineNr">362 </span>
<a name="L363"></a><span id="L363" class="LineNr">363 </span><span class="Comment">//: Using break we can now implement conditional returns.</span>
<a name="L364"></a><span id="L364" class="LineNr">364 </span>
<a name="L365"></a><span id="L365" class="LineNr">365 </span><span class="Delimiter">:(scenario return_if)</span>
<a name="L366"></a><span id="L366" class="LineNr">366 </span><span class="muRecipe">def</span> main [
<a name="L367"></a><span id="L367" class="LineNr">367 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test1
<a name="L368"></a><span id="L368" class="LineNr">368 </span>]
<a name="L369"></a><span id="L369" class="LineNr">369 </span><span class="muRecipe">def</span> test1 [
<a name="L370"></a><span id="L370" class="LineNr">370 </span>  <span class="Identifier">return</span>-<span class="Normal">if</span> <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">34</span>
<a name="L371"></a><span id="L371" class="LineNr">371 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<a name="L372"></a><span id="L372" class="LineNr">372 </span>]
<a name="L373"></a><span id="L373" class="LineNr">373 </span><span class="traceContains">+mem: storing 35 in location 1</span>
<a name="L374"></a><span id="L374" class="LineNr">374 </span>
<a name="L375"></a><span id="L375" class="LineNr">375 </span><span class="Delimiter">:(scenario return_if_2)</span>
<a name="L376"></a><span id="L376" class="LineNr">376 </span><span class="muRecipe">def</span> main [
<a name="L377"></a><span id="L377" class="LineNr">377 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>test1
<a name="L378"></a><span id="L378" class="LineNr">378 </span>]
<a name="L379"></a><span id="L379" class="LineNr">379 </span><span class="muRecipe">def</span> test1 [
<a name="L380"></a><span id="L380" class="LineNr">380 </span>  <span class="Identifier">return</span>-<span class="Normal">if</span> <span class="Constant">1</span><span class="Delimiter">,</span> <span class="Constant">34</span>
<a name="L381"></a><span id="L381" class="LineNr">381 </span>  <span class="Identifier">return</span> <span class="Constant">35</span>
<a name="L382"></a><span id="L382" class="LineNr">382 </span>]
<a name="L383"></a><span id="L383" class="LineNr">383 </span><span class="traceContains">+mem: storing 34 in location 1</span>
<a name="L384"></a><span id="L384" class="LineNr">384 </span>
<a name="L385"></a><span id="L385" class="LineNr">385 </span><span class="Delimiter">:(before &quot;End Rewrite Instruction(curr, recipe result)&quot;)</span>
<a name="L386"></a><span id="L386" class="LineNr">386 </span><span class="Comment">// rewrite `return-if a, b, c, ...` to</span>
<a name="L387"></a><span id="L387" class="LineNr">387 </span><span class="Comment">//   ```</span>
<a name="L388"></a><span id="L388" class="LineNr">388 </span><span class="Comment">//   {</span>
<a name="L389"></a><span id="L389" class="LineNr">389 </span><span class="Comment">//     break-unless a</span>
<a name="L390"></a><span id="L390" class="LineNr">390 </span><span class="Comment">//     return b, c, ...</span>
<a name="L391"></a><span id="L391" class="LineNr">391 </span><span class="Comment">//   }</span>
<a name="L392"></a><span id="L392" class="LineNr">392 </span><span class="Comment">//   ```</span>
<a name="L393"></a><span id="L393" class="LineNr">393 </span><span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;return-if&quot;</span> || curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;reply-if&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L394"></a><span id="L394" class="LineNr">394 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<a name="L395"></a><span id="L395" class="LineNr">395 </span>    emit_return_block<span class="Delimiter">(</span>result<span class="Delimiter">,</span> <span class="Constant">&quot;break-unless&quot;</span><span class="Delimiter">,</span> curr<span class="Delimiter">);</span>
<a name="L396"></a><span id="L396" class="LineNr">396 </span>    curr<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
<a name="L397"></a><span id="L397" class="LineNr">397 </span>  <span class="Delimiter">}</span>
<a name="L398"></a><span id="L398" class="LineNr">398 </span>  <span class="Normal">else</span> <span class="Delimiter">{</span>
<a name="L399"></a><span id="L399" class="LineNr">399 </span>    raise &lt;&lt; <span class="Constant">&quot;'&quot;</span> &lt;&lt; curr<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;' never yields any products</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L400"></a><span id="L400" class="LineNr">400 </span>  <span class="Delimiter">}</span>
<a name="L401"></a><span id="L401" class="LineNr">401 </span><span class="Delimiter">}</span>
<a name="L402"></a><span id="L402" class="LineNr">402 </span><span class="Comment">// rewrite `return-unless a, b, c, ...` to</span>
<a name="L403"></a><span id="L403" class="LineNr">403 </span><span class="Comment">//   ```</span>
<a name="L404"></a><span id="L404" class="LineNr">404 </span><span class="Comment">//   {</span>
<a name="L405"></a><span id="L405" class="LineNr">405 </span><span class="Comment">//     break-if a</span>
<a name="L406"></a><span id="L406" class="LineNr">406 </span><span class="Comment">//     return b, c, ...</span>
<a name="L407"></a><span id="L407" class="LineNr">407 </span><span class="Comment">//   }</span>
<a name="L408"></a><span id="L408" class="LineNr">408 </span><span class="Comment">//   ```</span>
<a name="L409"></a><span id="L409" class="LineNr">409 </span><span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;return-unless&quot;</span> || curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;reply-unless&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L410"></a><span id="L410" class="LineNr">410 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Delimiter">{</span>
<a name="L411"></a><span id="L411" class="LineNr">411 </span>    emit_return_block<span class="Delimiter">(</span>result<span class="Delimiter">,</span> <span class="Constant">&quot;break-if&quot;</span><span class="Delimiter">,</span> curr<span class="Delimiter">);</span>
<a name="L412"></a><span id="L412" class="LineNr">412 </span>    curr<span class="Delimiter">.</span>clear<span class="Delimiter">();</span>
<a name="L413"></a><span id="L413" class="LineNr">413 </span>  <span class="Delimiter">}</span>
<a name="L414"></a><span id="L414" class="LineNr">414 </span>  <span class="Normal">else</span> <span class="Delimiter">{</span>
<a name="L415"></a><span id="L415" class="LineNr">415 </span>    raise &lt;&lt; <span class="Constant">&quot;'&quot;</span> &lt;&lt; curr<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot;' never yields any products</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<a name="L416"></a><span id="L416" class="LineNr">416 </span>  <span class="Delimiter">}</span>
<a name="L417"></a><span id="L417" class="LineNr">417 </span><span class="Delimiter">}</span>
<a name="L418"></a><span id="L418" class="LineNr">418 </span>
<a name="L419"></a><span id="L419" class="LineNr">419 </span><span class="Delimiter">:(code)</span>
<a name="L420"></a><span id="L420" class="LineNr">420 </span><span class="Normal">void</span> emit_return_block<span class="Delimiter">(</span>recipe&amp; out<span class="Delimiter">,</span> <span class="Normal">const</span> string&amp; break_command<span class="Delimiter">,</span> <span class="Normal">const</span> instruction&amp; inst<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<a name="L421"></a><span id="L421" class="LineNr">421 </span>  <span class="Normal">const</span> vector&lt;reagent&gt;&amp; ingredients = inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">;</span>
<a name="L422"></a><span id="L422" class="LineNr">422 </span>  reagent<span class="Comment">/*</span><span class="Comment">copy</span><span class="Comment">*/</span> condition = ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<a name="L423"></a><span id="L423" class="LineNr">423 </span>  vector&lt;reagent&gt; return_ingredients<span class="Delimiter">;</span>
<a name="L424"></a><span id="L424" class="LineNr">424 </span>  copy<span class="Delimiter">(</span>++ingredients<span class="Delimiter">.</span>begin<span class="Delimiter">(),</span> ingredients<span class="Delimiter">.</span>end<span class="Delimiter">(),</span> inserter<span class="Delimiter">(</span>return_ingredients<span class="Delimiter">,</span> return_ingredients<span class="Delimiter">.</span>end<span class="Delimiter">()));</span>
<a name="L425"></a><span id="L425" class="LineNr">425 </span>
<a name="L426"></a><span id="L426" class="LineNr">426 </span>  <span class="Comment">// {</span>
<a name="L427"></a><span id="L427" class="LineNr">427 </span>  instruction open_label<span class="Delimiter">;</span>  open_label<span class="Delimiter">.</span>is_label=<span class="Constant">true</span><span class="Delimiter">;</span>  open_label<span class="Delimiter">.</span>label = <span class="Constant">&quot;{&quot;</span><span class="Delimiter">;</span>
<a name="L428"></a><span id="L428" class="LineNr">428 </span>  out<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>open_label<span class="Delimiter">);</span>
<a name="L429"></a><span id="L429" class="LineNr">429 </span>
<a name="L430"></a><span id="L430" class="LineNr">430 </span>  <span class="Comment">// &lt;break command&gt; &lt;condition&gt;</span>
<a name="L431"></a><span id="L431" class="LineNr">431 </span>  instruction break_inst<span class="Delimiter">;</span>
<a name="L432"></a><span id="L432" class="LineNr">432 </span>  break_inst<span class="Delimiter">.</span>operation = get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> break_command<span class="Delimiter">);</span>
<a name="L433"></a><span id="L433" class="LineNr">433 </span>  break_inst<span class="Delimiter">.</span>name = break_inst<span class="Delimiter">.</span>old_name = break_command<span class="Delimiter">;</span>
<a name="L434"></a><span id="L434" class="LineNr">434 </span>  break_inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>condition<span class="Delimiter">);</span>
<a name="L435"></a><span id="L435" class="LineNr">435 </span>  out<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>break_inst<span class="Delimiter">);</span>
<a name="L436"></a><span id="L436" class="LineNr">436 </span>
<a name="L437"></a><span id="L437" class="LineNr">437 </span>  <span class="Comment">// return &lt;return ingredients&gt;</span>
<a name="L438"></a><span id="L438" class="LineNr">438 </span>  instruction return_inst<span class="Delimiter">;</span>
<a name="L439"></a><span id="L439" class="LineNr">439 </span>  return_inst<span class="Delimiter">.</span>operation = get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;return&quot;</span><span class="Delimiter">);</span>
<a name="L440"></a><span id="L440" class="LineNr">440 </span>  return_inst<span class="Delimiter">.</span>name = <span class="Constant">&quot;return&quot;</span><span class="Delimiter">;</span>
<a name="L441"></a><span id="L441" class="LineNr">441 </span>  return_inst<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>swap<span class="Delimiter">(</span>return_ingredients<span class="Delimiter">);</span>
<a name="L442"></a><span id="L442" class="LineNr">442 </span>  return_inst<span class="Delimiter">.</span>original_string = inst<span class="Delimiter">.</span>original_string<span class="Delimiter">;</span>
<a name="L443"></a><span id="L443" class="LineNr">443 </span>  out<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>return_inst<span class="Delimiter">);</span>
<a name="L444"></a><span id="L444" class="LineNr">444 </span>
<a name="L445"></a><span id="L445" class="LineNr">445 </span>  <span class="Comment">// }</span>
<a name="L446"></a><span id="L446" class="LineNr">446 </span>  instruction close_label<span class="Delimiter">;</span>  close_label<span class="Delimiter">.</span>is_label=<span class="Constant">true</span><span class="Delimiter">;</span>  close_label<span class="Delimiter">.</span>label = <span class="Constant">&quot;}&quot;</span><span class="Delimiter">;</span>
<a name="L447"></a><span id="L447" class="LineNr">447 </span>  out<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>close_label<span class="Delimiter">);</span>
<a name="L448"></a><span id="L448" class="LineNr">448 </span><span class="Delimiter">}</span>
<a name="L449"></a><span id="L449" class="LineNr">449 </span>
<a name="L450"></a><span id="L450" class="LineNr">450 </span><span class="Comment">//: Make sure these pseudo recipes get consistent numbers in all tests, even</span>
<a name="L451"></a><span id="L451" class="LineNr">451 </span><span class="Comment">//: though they aren't implemented. Allows greater flexibility in ordering</span>
<a name="L452"></a><span id="L452" class="LineNr">452 </span><span class="Comment">//: transforms.</span>
<a name="L453"></a><span id="L453" class="LineNr">453 </span>
<a name="L454"></a><span id="L454" class="LineNr">454 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Declarations&quot;)</span>
<a name="L455"></a><span id="L455" class="LineNr">455 </span>BREAK<span class="Delimiter">,</span>
<a name="L456"></a><span id="L456" class="LineNr">456 </span>BREAK_IF<span class="Delimiter">,</span>
<a name="L457"></a><span id="L457" class="LineNr">457 </span>BREAK_UNLESS<span class="Delimiter">,</span>
<a name="L458"></a><span id="L458" class="LineNr">458 </span>LOOP<span class="Delimiter">,</span>
<a name="L459"></a><span id="L459" class="LineNr">459 </span>LOOP_IF<span class="Delimiter">,</span>
<a name="L460"></a><span id="L460" class="LineNr">460 </span>LOOP_UNLESS<span class="Delimiter">,</span>
<a name="L461"></a><span id="L461" class="LineNr">461 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Numbers&quot;)</span>
<a name="L462"></a><span id="L462" class="LineNr">462 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;break&quot;</span><span class="Delimiter">,</span> BREAK<span class="Delimiter">);</span>
<a name="L463"></a><span id="L463" class="LineNr">463 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;break-if&quot;</span><span class="Delimiter">,</span> BREAK_IF<span class="Delimiter">);</span>
<a name="L464"></a><span id="L464" class="LineNr">464 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;break-unless&quot;</span><span class="Delimiter">,</span> BREAK_UNLESS<span class="Delimiter">);</span>
<a name="L465"></a><span id="L465" class="LineNr">465 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;loop&quot;</span><span class="Delimiter">,</span> LOOP<span class="Delimiter">);</span>
<a name="L466"></a><span id="L466" class="LineNr">466 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;loop-if&quot;</span><span class="Delimiter">,</span> LOOP_IF<span class="Delimiter">);</span>
<a name="L467"></a><span id="L467" class="LineNr">467 </span>put<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> <span class="Constant">&quot;loop-unless&quot;</span><span class="Delimiter">,</span> LOOP_UNLESS<span class="Delimiter">);</span>
<a name="L468"></a><span id="L468" class="LineNr">468 </span><span class="Delimiter">:(before &quot;End Primitive Recipe Checks&quot;)</span>
<a name="L469"></a><span id="L469" class="LineNr">469 </span><span class="Normal">case</span> BREAK: <span class="Identifier">break</span><span class="Delimiter">;</span>
<a name="L470"></a><span id="L470" class="LineNr">470 </span><span class="Normal">case</span> BREAK_IF: <span class="Identifier">break</span><span class="Delimiter">;</span>
<a name="L471"></a><span id="L471" class="LineNr">471 </span><span class="Normal">case</span> BREAK_UNLESS: <span class="Identifier">break</span><span class="Delimiter">;</span>
<a name="L472"></a><span id="L472" class="LineNr">472 </span><span class="Normal">case</span> LOOP: <span class="Identifier">break</span><span class="Delimiter">;</span>
<a name="L473"></a><span id="L473" class="LineNr">473 </span><span class="Normal">case</span> LOOP_IF: <span class="Identifier">break</span><span class="Delimiter">;</span>
<a name="L474"></a><span id="L474" class="LineNr">474 </span><span class="Normal">case</span> LOOP_UNLESS: <span class="Identifier">break</span><span class="Delimiter">;</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->