summary refs log blame commit diff stats
path: root/doc/rifle.pod
blob: ea04c5ee2caae244cadfe1e0d7d37863c3565e11 (plain) (tree)








































































































                                                                                                                                                                                                                                                                                                                                                         
 





                                             
 



                                                             
 



                                                               
 
                                 
=head1 NAME

rifle - ranger's file opener




=head1 SYNOPSIS

B<rifle> [B<--help>] [B<-f> I<FLAGS>] [B<-l>] [B<-p> I<KEYWORD>]
[B<-w> I<PROGRAM>] I<files>




=head1 DESCRIPTION

rifle is a powerful file executor that allows for complex file type checking,
written to meet the needs of the file manager I<ranger>.  rifle's strength lies
in automatically determining file types, depending on which programs are
installed on the system, even without any user interaction.




=head1 OPTIONS

=over 14

=item B<-f> I<FLAGS>

Specify flags for opening the files.  Flags are letters that changes how the
program is executed.  Any combination of flags will work.  Writing uppercase
flags will negate the effect of all previously used lowercase flags of the same
letter.

Table of all flags:
 f   fork program to background
 r   run program as root, using sudo
 t   run program in a separate terminal, as specified by $TERMCMD

=item B<-l>

List all possible ways to open the specified files.  Each line will contain information in the format of I<id:label:flags:command>. I<id> is the identification number. I<label> is an arbitrary string that was specified for this command, I<flags> are the flags that are used by default, and I<command> is the command that is going to be executed.

=item B<-p> I<KEYWORD>

Pick a method to open the files.

I<KEYWORD> is either the ID number listed by C<rifle -l> or a string that matches a label in the configuration file.

=item B<-w> I<PROGRAM>

Open the files with the program I<PROGRAM>

=item B<-h>, B<--help>

Print a list of options and exit.

=back




=head1 FILES

rifle shares configuration files with ranger, though ranger is not required in
order to use rifle.  The configuration file F<rifle.conf> is expected to be at
F<~/.config/ranger/rifle.conf>.

This file specifies patterns for determining the commands to open files with.
The syntax is described in the comments of the default F<rifle.conf> that ships
with ranger.  To obtain it, you need to run: C<ranger --copy-config=rifle>




=head1 ENVIRONMENT

=over 8

=item EDITOR

Determines which editor to use for editing files (in the default F<rifle.conf>).

=item PAGER

Determines which pager to use for displaying files (in the default F<rifle.conf>).

=item TERMCMD

Determines the terminal emulator command for use with the I<t> flag.  It is required that the value is the path to an executable file which accepts the "-e COMMAND" argument.

=item XDG_CONFIG_HOME

Specifies the directory for configuration files. Defaults to F<$HOME/.config>.

=back




=head1 EXAMPLES

List all the different methods:

 $ rifle -l helloworld.py
 0:editor::"$EDITOR" -- "$@"
 1:pager::"$PAGER" -- "$@"
 2:::python -- "$1"

Display its content by opening it with "cat":

 $ rifle -w cat helloworld.py
 print("Hello World!")

Run it by picking the method 2, which calls 'python -- "$1"':

 $ rifle -p 2 helloworld.py
 Hello World!

Display the file in a pager inside a new terminal, run as root:

 $ rifle -p 1 -f tr helloworld.py
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 - 043space.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; }
a { text-decoration: none; }
a:hover { text-decoration: underline; }
* { font-size: 12pt; font-size: 1em; }
.SalientComment { color: #00ffff; }
.muRecipe { color: #ff8700; }
.LineNr { color: #444444; }
.muData { color: #ffff00; }
.cSpecial { color: #008000; }
.Delimiter { color: #800080; }
.Normal { color: #eeeeee; background-color: #080808; padding-bottom: 1px; }
.traceContains { color: #008000; }
.traceAbsent { color: #c00000; }
.Comment { color: #9090ff; }
.Constant { color: #00a0a0; }
.Special { color: #c00000; }
.Identifier { color: #c0a020; }
-->
</style>

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

/* function to open any folds containing a jumped-to line before jumping to it */
function JumpToLine()
{
  var lineNum;
  lineNum = window.location.hash;
  lineNum = lineNum.substr(1); /* strip off '#' */

  if (lineNum.indexOf('L') == -1) {
    lineNum = 'L'+lineNum;
  }
  lineElem = document.getElementById(lineNum);
  /* Always jump to new location even if the line was hidden inside a fold, or
   * we corrected the raw number to a line ID.
   */
  if (lineElem) {
    lineElem.scrollIntoView(true);
  }
  return true;
}
if ('onhashchange' in window) {
  window.onhashchange = JumpToLine;
}

-->
</script>
</head>
<body onload='JumpToLine();'>
<pre id='vimCodeElement'>
<span id="L1" class="LineNr">  1 </span><span class="Comment">//: Spaces help isolate recipes from each other. You can create them at will,</span>
<span id="L2" class="LineNr">  2 </span><span class="Comment">//: and all addresses in arguments are implicitly based on the 'default-space'</span>
<span id="L3" class="LineNr">  3 </span><span class="Comment">//: (unless they have the /raw property)</span>
<span id="L4" class="LineNr">  4 </span>
<span id="L5" class="LineNr">  5 </span><span class="Comment">//: A space is just an array of any scalar location.</span>
<span id="L6" class="LineNr">  6 </span><span class="Delimiter">:(before &quot;End Mu Types Initialization&quot;)</span>
<span id="L7" class="LineNr">  7 </span><a href='001help.cc.html#L218'>put</a><span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">,</span> <a href='018type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span><span class="Constant">&quot;address:array:location&quot;</span><span class="Delimiter">));</span>
<span id="L8" class="LineNr">  8 </span><span class="Comment">//: Spaces are often called 'scopes' in other languages.</span>
<span id="L9" class="LineNr">  9 </span><a href='001help.cc.html#L218'>put</a><span class="Delimiter">(</span>Type_abbreviations<span class="Delimiter">,</span> <span class="Constant">&quot;scope&quot;</span><span class="Delimiter">,</span> <a href='018type_abbreviations.cc.html#L58'>new_type_tree</a><span class="Delimiter">(</span><span class="Constant">&quot;address:array:location&quot;</span><span class="Delimiter">));</span>
<span id="L10" class="LineNr"> 10 </span>
<span id="L11" class="LineNr"> 11 </span><span class="Delimiter">:(scenario set_default_space)</span>
<span id="L12" class="LineNr"> 12 </span><span class="Comment"># if default-space is 10, and if an array of 5 locals lies from location 12 to 16 (inclusive),</span>
<span id="L13" class="LineNr"> 13 </span><span class="Comment"># then local 0 is really location 12, local 1 is really location 13, and so on.</span>
<span id="L14" class="LineNr"> 14 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L15" class="LineNr"> 15 </span>  <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
<span id="L16" class="LineNr"> 16 </span>  <span class="Constant">10</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
<span id="L17" class="LineNr"> 17 </span>  <span class="Constant">11</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
<span id="L18" class="LineNr"> 18 </span>  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
<span id="L19" class="LineNr"> 19 </span>  <span class="Constant">1</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">23</span>
<span id="L20" class="LineNr"> 20 </span>]
<span id="L21" class="LineNr"> 21 </span><span class="traceContains">+mem: storing 23 in location 13</span>
<span id="L22" class="LineNr"> 22 </span>
<span id="L23" class="LineNr"> 23 </span><span class="Delimiter">:(scenario lookup_sidesteps_default_space)</span>
<span id="L24" class="LineNr"> 24 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L25" class="LineNr"> 25 </span>  <span class="Comment"># pretend pointer from outside (2000 reserved for refcount)</span>
<span id="L26" class="LineNr"> 26 </span>  <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L27" class="LineNr"> 27 </span>  <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
<span id="L28" class="LineNr"> 28 </span>  <span class="Constant">1000</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
<span id="L29" class="LineNr"> 29 </span>  <span class="Constant">1001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
<span id="L30" class="LineNr"> 30 </span>  <span class="Comment"># actual start of this recipe</span>
<span id="L31" class="LineNr"> 31 </span>  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe
<span id="L32" class="LineNr"> 32 </span>  <span class="Constant">1</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">2000</span>/unsafe  <span class="Comment"># even local variables always contain raw addresses</span>
<span id="L33" class="LineNr"> 33 </span>  <span class="Constant">8</span>:num/<span class="Special">raw &lt;- </span>copy *<span class="Constant">1</span>:&amp;:num
<span id="L34" class="LineNr"> 34 </span>]
<span id="L35" class="LineNr"> 35 </span><span class="traceContains">+mem: storing 34 in location 8</span>
<span id="L36" class="LineNr"> 36 </span>
<span id="L37" class="LineNr"> 37 </span><span class="SalientComment">//:: first disable name conversion for 'default-space'</span>
<span id="L38" class="LineNr"> 38 </span><span class="Delimiter">:(scenario convert_names_passes_default_space)</span>
<span id="L39" class="LineNr"> 39 </span><span class="Special">% Hide_errors = true;</span>
<span id="L40" class="LineNr"> 40 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L41" class="LineNr"> 41 </span>  <span class="Normal">default</span>-space:num<span class="Delimiter">,</span> x:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span><span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L42" class="LineNr"> 42 </span>]
<span id="L43" class="LineNr"> 43 </span><span class="traceContains">+name: assign x 1</span>
<span id="L44" class="LineNr"> 44 </span><span class="traceAbsent">-name: assign default-space 1</span>
<span id="L45" class="LineNr"> 45 </span>
<span id="L46" class="LineNr"> 46 </span><span class="Delimiter">:(before &quot;End <a href='042name.cc.html#L99'>is_disqualified</a> Special-cases&quot;)</span>
<span id="L47" class="LineNr"> 47 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span>
<span id="L48" class="LineNr"> 48 </span>  x<span class="Delimiter">.</span>initialized = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L49" class="LineNr"> 49 </span><span class="Delimiter">:(before &quot;End <a href='042name.cc.html#L156'>is_special_name</a> Special-cases&quot;)</span>
<span id="L50" class="LineNr"> 50 </span><span class="Normal">if</span> <span class="Delimiter">(</span>s == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L51" class="LineNr"> 51 </span>
<span id="L52" class="LineNr"> 52 </span><span class="SalientComment">//:: now implement space support</span>
<span id="L53" class="LineNr"> 53 </span><span class="Delimiter">:(before &quot;End call Fields&quot;)</span>
<span id="L54" class="LineNr"> 54 </span><span class="Normal">int</span> default_space<span class="Delimiter">;</span>
<span id="L55" class="LineNr"> 55 </span><span class="Delimiter">:(before &quot;End call Constructor&quot;)</span>
<span id="L56" class="LineNr"> 56 </span>default_space = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L57" class="LineNr"> 57 </span>
<span id="L58" class="LineNr"> 58 </span><span class="Delimiter">:(before &quot;End canonize(x) Special-cases&quot;)</span>
<span id="L59" class="LineNr"> 59 </span><a href='043space.cc.html#L61'>absolutize</a><span class="Delimiter">(</span>x<span class="Delimiter">);</span>
<span id="L60" class="LineNr"> 60 </span><span class="Delimiter">:(code)</span>
<span id="L61" class="LineNr"> 61 </span><span class="Normal">void</span> <a href='043space.cc.html#L61'>absolutize</a><span class="Delimiter">(</span>reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L62" class="LineNr"> 62 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span><a href='022arithmetic.cc.html#L108'>is_raw</a><span class="Delimiter">(</span>x<span class="Delimiter">)</span> || is_dummy<span class="Delimiter">(</span>x<span class="Delimiter">))</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L63" class="LineNr"> 63 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L64" class="LineNr"> 64 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!x<span class="Delimiter">.</span>initialized<span class="Delimiter">)</span>
<span id="L65" class="LineNr"> 65 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; to_original_string<span class="Delimiter">(</span>current_instruction<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;: reagent not initialized: '&quot;</span> &lt;&lt; x<span class="Delimiter">.</span>original_string &lt;&lt; <span class="Constant">&quot;'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L66" class="LineNr"> 66 </span>  x<span class="Delimiter">.</span><a href='010vm.cc.html#L66'>set_value</a><span class="Delimiter">(</span><a href='043space.cc.html#L76'>address</a><span class="Delimiter">(</span>x<span class="Delimiter">.</span>value<span class="Delimiter">,</span> space_base<span class="Delimiter">(</span>x<span class="Delimiter">)));</span>
<span id="L67" class="LineNr"> 67 </span>  x<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span>
<span id="L68" class="LineNr"> 68 </span>  assert<span class="Delimiter">(</span><a href='022arithmetic.cc.html#L108'>is_raw</a><span class="Delimiter">(</span>x<span class="Delimiter">));</span>
<span id="L69" class="LineNr"> 69 </span><span class="Delimiter">}</span>
<span id="L70" class="LineNr"> 70 </span>
<span id="L71" class="LineNr"> 71 </span><span class="Comment">//: hook replaced in a later layer</span>
<span id="L72" class="LineNr"> 72 </span><span class="Normal">int</span> space_base<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; x<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L73" class="LineNr"> 73 </span>  <span class="Identifier">return</span> current_call<span class="Delimiter">().</span>default_space ? <span class="Delimiter">(</span>current_call<span class="Delimiter">().</span>default_space+<span class="Comment">/*</span><span class="Comment">skip refcount</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">)</span> : <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L74" class="LineNr"> 74 </span><span class="Delimiter">}</span>
<span id="L75" class="LineNr"> 75 </span>
<span id="L76" class="LineNr"> 76 </span><span class="Normal">int</span> <a href='043space.cc.html#L76'>address</a><span class="Delimiter">(</span><span class="Normal">int</span> offset<span class="Delimiter">,</span> <span class="Normal">int</span> base<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L77" class="LineNr"> 77 </span>  assert<span class="Delimiter">(</span>offset &gt;= <span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L78" class="LineNr"> 78 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>base == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">return</span> offset<span class="Delimiter">;</span>  <span class="Comment">// raw</span>
<span id="L79" class="LineNr"> 79 </span>  <span class="Normal">int</span> size = <a href='001help.cc.html#L225'>get_or_insert</a><span class="Delimiter">(</span>Memory<span class="Delimiter">,</span> base<span class="Delimiter">);</span>
<span id="L80" class="LineNr"> 80 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>offset &gt;= size<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L81" class="LineNr"> 81 </span>    <span class="Comment">// todo: test</span>
<span id="L82" class="LineNr"> 82 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; <span class="Constant">&quot;location &quot;</span> &lt;&lt; offset &lt;&lt; <span class="Constant">&quot; is out of bounds &quot;</span> &lt;&lt; size &lt;&lt; <span class="Constant">&quot; at &quot;</span> &lt;&lt; base &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L83" class="LineNr"> 83 </span>    <span class="Identifier">return</span> <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L84" class="LineNr"> 84 </span>  <span class="Delimiter">}</span>
<span id="L85" class="LineNr"> 85 </span>  <span class="Identifier">return</span> base + <span class="Comment">/*</span><span class="Comment">skip length</span><span class="Comment">*/</span><span class="Constant">1</span> + offset<span class="Delimiter">;</span>
<span id="L86" class="LineNr"> 86 </span><span class="Delimiter">}</span>
<span id="L87" class="LineNr"> 87 </span>
<span id="L88" class="LineNr"> 88 </span><span class="SalientComment">//:: reads and writes to the 'default-space' variable have special behavior</span>
<span id="L89" class="LineNr"> 89 </span>
<span id="L90" class="LineNr"> 90 </span><span class="Delimiter">:(after &quot;Begin Preprocess write_memory(x, data)&quot;)</span>
<span id="L91" class="LineNr"> 91 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L92" class="LineNr"> 92 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!scalar<span class="Delimiter">(</span>data<span class="Delimiter">)</span> || !is_space<span class="Delimiter">(</span>x<span class="Delimiter">))</span>
<span id="L93" class="LineNr"> 93 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>current_recipe_name<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;'default-space' should be of type <a href='043space.cc.html#L76'>address</a>:array:location, but is &quot;</span> &lt;&lt; <a href='028call_return.cc.html#L158'>to_string</a><span class="Delimiter">(</span>x<span class="Delimiter">.</span>type<span class="Delimiter">)</span> &lt;&lt; <span class="cSpecial">'\n'</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L94" class="LineNr"> 94 </span>  current_call<span class="Delimiter">().</span>default_space = data<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L95" class="LineNr"> 95 </span>  <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L96" class="LineNr"> 96 </span><span class="Delimiter">}</span>
<span id="L97" class="LineNr"> 97 </span><span class="Delimiter">:(code)</span>
<span id="L98" class="LineNr"> 98 </span><span class="Normal">bool</span> <a href='043space.cc.html#L98'>is_space</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L99" class="LineNr"> 99 </span>  <span class="Identifier">return</span> <a href='039location_array.cc.html#L15'>is_address_of_array_of_numbers</a><span class="Delimiter">(</span>r<span class="Delimiter">);</span>
<span id="L100" class="LineNr">100 </span><span class="Delimiter">}</span>
<span id="L101" class="LineNr">101 </span>
<span id="L102" class="LineNr">102 </span><span class="Delimiter">:(scenario get_default_space)</span>
<span id="L103" class="LineNr">103 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L104" class="LineNr">104 </span>  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">10</span>/unsafe
<span id="L105" class="LineNr">105 </span>  <span class="Constant">1</span>:space/<span class="Special">raw &lt;- </span>copy <span class="Normal">default</span>-space:space
<span id="L106" class="LineNr">106 </span>]
<span id="L107" class="LineNr">107 </span><span class="traceContains">+mem: storing 10 in location 1</span>
<span id="L108" class="LineNr">108 </span>
<span id="L109" class="LineNr">109 </span><span class="Delimiter">:(after &quot;Begin Preprocess read_memory(x)&quot;)</span>
<span id="L110" class="LineNr">110 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L111" class="LineNr">111 </span>  vector&lt;<span class="Normal">double</span>&gt; result<span class="Delimiter">;</span>
<span id="L112" class="LineNr">112 </span>  result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>current_call<span class="Delimiter">().</span>default_space<span class="Delimiter">);</span>
<span id="L113" class="LineNr">113 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L114" class="LineNr">114 </span><span class="Delimiter">}</span>
<span id="L115" class="LineNr">115 </span>
<span id="L116" class="LineNr">116 </span><span class="SalientComment">//:: fix 'get'</span>
<span id="L117" class="LineNr">117 </span>
<span id="L118" class="LineNr">118 </span><span class="Delimiter">:(scenario lookup_sidesteps_default_space_in_get)</span>
<span id="L119" class="LineNr">119 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L120" class="LineNr">120 </span>  <span class="Comment"># pretend pointer to container from outside (2000 reserved for refcount)</span>
<span id="L121" class="LineNr">121 </span>  <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L122" class="LineNr">122 </span>  <span class="Constant">2002</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
<span id="L123" class="LineNr">123 </span>  <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
<span id="L124" class="LineNr">124 </span>  <span class="Constant">1000</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
<span id="L125" class="LineNr">125 </span>  <span class="Constant">1001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
<span id="L126" class="LineNr">126 </span>  <span class="Comment"># actual start of this recipe</span>
<span id="L127" class="LineNr">127 </span>  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe
<span id="L128" class="LineNr">128 </span>  <span class="Constant">1</span>:&amp;:point<span class="Special"> &lt;- </span>copy <span class="Constant">2000</span>/unsafe
<span id="L129" class="LineNr">129 </span>  <span class="Constant">9</span>:num/<span class="Special">raw &lt;- </span>get *<span class="Constant">1</span>:&amp;:point<span class="Delimiter">,</span> <span class="Constant">1:offset</span>
<span id="L130" class="LineNr">130 </span>]
<span id="L131" class="LineNr">131 </span><span class="traceContains">+mem: storing 35 in location 9</span>
<span id="L132" class="LineNr">132 </span>
<span id="L133" class="LineNr">133 </span><span class="Delimiter">:(before &quot;Read element&quot; following &quot;case GET:&quot;)</span>
<span id="L134" class="LineNr">134 </span>element<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span>
<span id="L135" class="LineNr">135 </span>
<span id="L136" class="LineNr">136 </span><span class="SalientComment">//:: fix 'index'</span>
<span id="L137" class="LineNr">137 </span>
<span id="L138" class="LineNr">138 </span><span class="Delimiter">:(scenario lookup_sidesteps_default_space_in_index)</span>
<span id="L139" class="LineNr">139 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L140" class="LineNr">140 </span>  <span class="Comment"># pretend pointer to array from outside (2000 reserved for refcount)</span>
<span id="L141" class="LineNr">141 </span>  <span class="Constant">2001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">2</span>  <span class="Comment"># length</span>
<span id="L142" class="LineNr">142 </span>  <span class="Constant">2002</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L143" class="LineNr">143 </span>  <span class="Constant">2003</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">35</span>
<span id="L144" class="LineNr">144 </span>  <span class="Comment"># pretend address:array:location; in practice we'll use new</span>
<span id="L145" class="LineNr">145 </span>  <span class="Constant">1000</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>  <span class="Comment"># refcount</span>
<span id="L146" class="LineNr">146 </span>  <span class="Constant">1001</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">5</span>  <span class="Comment"># length</span>
<span id="L147" class="LineNr">147 </span>  <span class="Comment"># actual start of this recipe</span>
<span id="L148" class="LineNr">148 </span>  <span class="Normal">default</span>-space:space<span class="Special"> &lt;- </span>copy <span class="Constant">1000</span>/unsafe
<span id="L149" class="LineNr">149 </span>  <span class="Constant">1</span>:&amp;:@:num<span class="Special"> &lt;- </span>copy <span class="Constant">2000</span>/unsafe
<span id="L150" class="LineNr">150 </span>  <span class="Constant">9</span>:num/<span class="Special">raw &lt;- </span>index *<span class="Constant">1</span>:&amp;:@:num<span class="Delimiter">,</span> <span class="Constant">1</span>
<span id="L151" class="LineNr">151 </span>]
<span id="L152" class="LineNr">152 </span><span class="traceContains">+mem: storing 35 in location 9</span>
<span id="L153" class="LineNr">153 </span>
<span id="L154" class="LineNr">154 </span><span class="Delimiter">:(before &quot;Read element&quot; following &quot;case INDEX:&quot;)</span>
<span id="L155" class="LineNr">155 </span>element<span class="Delimiter">.</span>properties<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>pair&lt;string<span class="Delimiter">,</span> string_tree*&gt;<span class="Delimiter">(</span><span class="Constant">&quot;raw&quot;</span><span class="Delimiter">,</span> <span class="Constant">NULL</span><span class="Delimiter">));</span>
<span id="L156" class="LineNr">156 </span>
<span id="L157" class="LineNr">157 </span><span class="SalientComment">//:: convenience operation to automatically deduce the amount of space to</span>
<span id="L158" class="LineNr">158 </span><span class="SalientComment">//:: allocate in a default space with names</span>
<span id="L159" class="LineNr">159 </span>
<span id="L160" class="LineNr">160 </span><span class="Delimiter">:(scenario new_default_space)</span>
<span id="L161" class="LineNr">161 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L162" class="LineNr">162 </span>  <span class="Normal">new</span>-<span class="Normal">default</span>-space
<span id="L163" class="LineNr">163 </span>  <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<span id="L164" class="LineNr">164 </span>  <span class="Normal">y</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">3</span>
<span id="L165" class="LineNr">165 </span>]
<span id="L166" class="LineNr">166 </span><span class="Comment"># allocate space for x and y, as well as the chaining slot at 0</span>
<span id="L167" class="LineNr">167 </span><span class="traceContains">+mem: array length is 3</span>
<span id="L168" class="LineNr">168 </span>
<span id="L169" class="LineNr">169 </span><span class="Delimiter">:(before &quot;End <a href='042name.cc.html#L99'>is_disqualified</a> Special-cases&quot;)</span>
<span id="L170" class="LineNr">170 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span>
<span id="L171" class="LineNr">171 </span>  x<span class="Delimiter">.</span>initialized = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L172" class="LineNr">172 </span><span class="Delimiter">:(before &quot;End <a href='042name.cc.html#L156'>is_special_name</a> Special-cases&quot;)</span>
<span id="L173" class="LineNr">173 </span><span class="Normal">if</span> <span class="Delimiter">(</span>s == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L174" class="LineNr">174 </span>
<span id="L175" class="LineNr">175 </span><span class="Delimiter">:(before &quot;End Rewrite Instruction(curr, <a href='010vm.cc.html#L19'>recipe</a> result)&quot;)</span>
<span id="L176" class="LineNr">176 </span><span class="Comment">// rewrite `new-default-space` to</span>
<span id="L177" class="LineNr">177 </span><span class="Comment">//   `default-space:space &lt;- new location:type, number-of-locals:literal`</span>
<span id="L178" class="LineNr">178 </span><span class="Comment">// where N is Name[recipe][&quot;&quot;]</span>
<span id="L179" class="LineNr">179 </span><span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;new-default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L180" class="LineNr">180 </span>  <a href='043space.cc.html#L305'>rewrite_default_space_instruction</a><span class="Delimiter">(</span>curr<span class="Delimiter">);</span>
<span id="L181" class="LineNr">181 </span><span class="Delimiter">}</span>
<span id="L182" class="LineNr">182 </span><span class="Delimiter">:(after &quot;Begin Preprocess read_memory(x)&quot;)</span>
<span id="L183" class="LineNr">183 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L184" class="LineNr">184 </span>  vector&lt;<span class="Normal">double</span>&gt; result<span class="Delimiter">;</span>
<span id="L185" class="LineNr">185 </span>  result<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>Name[get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> current_recipe_name<span class="Delimiter">())</span>][<span class="Constant">&quot;&quot;</span>]<span class="Delimiter">);</span>
<span id="L186" class="LineNr">186 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>result<span class="Delimiter">.</span>back<span class="Delimiter">()</span> == <span class="Constant">0</span><span class="Delimiter">)</span>
<span id="L187" class="LineNr">187 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; <span class="Constant">&quot;no space allocated for default-space in <a href='010vm.cc.html#L19'>recipe</a> &quot;</span> &lt;&lt; current_recipe_name<span class="Delimiter">()</span> &lt;&lt; <span class="Constant">&quot;; are you using names?</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L188" class="LineNr">188 </span>  <span class="Identifier">return</span> result<span class="Delimiter">;</span>
<span id="L189" class="LineNr">189 </span><span class="Delimiter">}</span>
<span id="L190" class="LineNr">190 </span><span class="Delimiter">:(after &quot;Begin Preprocess write_memory(x, data)&quot;)</span>
<span id="L191" class="LineNr">191 </span><span class="Normal">if</span> <span class="Delimiter">(</span>x<span class="Delimiter">.</span>name == <span class="Constant">&quot;number-of-locals&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L192" class="LineNr">192 </span>  <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; <a href='013update_operation.cc.html#L25'>maybe</a><span class="Delimiter">(</span>current_recipe_name<span class="Delimiter">())</span> &lt;&lt; <span class="Constant">&quot;can't write to special name 'number-of-locals'</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L193" class="LineNr">193 </span>  <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L194" class="LineNr">194 </span><span class="Delimiter">}</span>
<span id="L195" class="LineNr">195 </span>
<span id="L196" class="LineNr">196 </span><span class="SalientComment">//:: 'local-scope' is like 'new-default-space' except that we'll reclaim the</span>
<span id="L197" class="LineNr">197 </span><span class="SalientComment">//:: default-space when the routine exits</span>
<span id="L198" class="LineNr">198 </span>
<span id="L199" class="LineNr">199 </span><span class="Delimiter">:(scenario local_scope)</span>
<span id="L200" class="LineNr">200 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L201" class="LineNr">201 </span>  <span class="Constant">1</span>:&amp;:@:location<span class="Special"> &lt;- </span>foo
<span id="L202" class="LineNr">202 </span>  <span class="Constant">2</span>:&amp;:@:location<span class="Special"> &lt;- </span>foo
<span id="L203" class="LineNr">203 </span>  <span class="Constant">3</span>:<span class="Normal">bool</span><span class="Special"> &lt;- </span>equal <span class="Constant">1</span>:&amp;<span class="Delimiter">,</span> <span class="Constant">2</span>:&amp;
<span id="L204" class="LineNr">204 </span>]
<span id="L205" class="LineNr">205 </span><span class="muRecipe">def</span> foo [
<span id="L206" class="LineNr">206 </span>  local-scope
<span id="L207" class="LineNr">207 </span>  <span class="Normal">x</span>:num<span class="Special"> &lt;- </span>copy <span class="Constant">34</span>
<span id="L208" class="LineNr">208 </span>  <span class="Identifier">return</span> <span class="Normal">default</span>-space:space
<span id="L209" class="LineNr">209 </span>]
<span id="L210" class="LineNr">210 </span><span class="Comment"># both calls to foo should have received the same default-space</span>
<span id="L211" class="LineNr">211 </span><span class="traceContains">+mem: storing 1 in location 3</span>
<span id="L212" class="LineNr">212 </span>
<span id="L213" class="LineNr">213 </span><span class="Delimiter">:(scenario local_scope_frees_up_addresses)</span>
<span id="L214" class="LineNr">214 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L215" class="LineNr">215 </span>  local-scope
<span id="L216" class="LineNr">216 </span>  <span class="Normal">x</span>:text<span class="Special"> &lt;- </span><span class="Normal">new</span> [abc]
<span id="L217" class="LineNr">217 </span>]
<span id="L218" class="LineNr">218 </span><span class="traceContains">+mem: clearing x:text</span>
<span id="L219" class="LineNr">219 </span>
<span id="L220" class="LineNr">220 </span><span class="Delimiter">:(before &quot;End Rewrite Instruction(curr, <a href='010vm.cc.html#L19'>recipe</a> result)&quot;)</span>
<span id="L221" class="LineNr">221 </span><span class="Normal">if</span> <span class="Delimiter">(</span>curr<span class="Delimiter">.</span>name == <span class="Constant">&quot;local-scope&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L222" class="LineNr">222 </span>  <a href='043space.cc.html#L305'>rewrite_default_space_instruction</a><span class="Delimiter">(</span>curr<span class="Delimiter">);</span>
<span id="L223" class="LineNr">223 </span><span class="Delimiter">}</span>
<span id="L224" class="LineNr">224 </span>
<span id="L225" class="LineNr">225 </span><span class="Comment">//: todo: do this in a transform, rather than magically in the 'return' instruction</span>
<span id="L226" class="LineNr">226 </span><span class="Delimiter">:(after &quot;Falling Through End Of Recipe&quot;)</span>
<span id="L227" class="LineNr">227 </span><a href='043space.cc.html#L232'>try_reclaim_locals</a><span class="Delimiter">();</span>
<span id="L228" class="LineNr">228 </span><span class="Delimiter">:(after &quot;Starting Reply&quot;)</span>
<span id="L229" class="LineNr">229 </span><a href='043space.cc.html#L232'>try_reclaim_locals</a><span class="Delimiter">();</span>
<span id="L230" class="LineNr">230 </span>
<span id="L231" class="LineNr">231 </span><span class="Delimiter">:(code)</span>
<span id="L232" class="LineNr">232 </span><span class="Normal">void</span> <a href='043space.cc.html#L232'>try_reclaim_locals</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L233" class="LineNr">233 </span>  <span class="Comment">// only reclaim routines starting with 'local-scope'</span>
<span id="L234" class="LineNr">234 </span>  <span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r = get<span class="Delimiter">(</span>Recipe_ordinal<span class="Delimiter">,</span> current_recipe_name<span class="Delimiter">());</span>
<span id="L235" class="LineNr">235 </span>  <span class="Normal">const</span> recipe&amp; exiting_recipe = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">);</span>
<span id="L236" class="LineNr">236 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>exiting_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L237" class="LineNr">237 </span>  <span class="Normal">const</span> instruction&amp; inst = exiting_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">);</span>
<span id="L238" class="LineNr">238 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>old_name != <span class="Constant">&quot;local-scope&quot;</span><span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L239" class="LineNr">239 </span>  <span class="Comment">// reclaim any local variables unless they're being returned</span>
<span id="L240" class="LineNr">240 </span>  vector&lt;<span class="Normal">double</span>&gt; zeros<span class="Delimiter">;</span>
<span id="L241" class="LineNr">241 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Comment">/*</span><span class="Comment">leave default space for last</span><span class="Comment">*/</span><span class="Constant">1</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L138'>SIZE</a><span class="Delimiter">(</span>exiting_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L242" class="LineNr">242 </span>    <span class="Normal">const</span> instruction&amp; inst = exiting_recipe<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">);</span>
<span id="L243" class="LineNr">243 </span>    <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">int</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L138'>SIZE</a><span class="Delimiter">(</span>inst<span class="Delimiter">.</span>products<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L244" class="LineNr">244 </span>      <span class="Normal">const</span> reagent&amp; product = inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">);</span>
<span id="L245" class="LineNr">245 </span>      <span class="Comment">// local variables only</span>
<span id="L246" class="LineNr">246 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>has_property<span class="Delimiter">(</span>product<span class="Delimiter">,</span> <span class="Constant">&quot;lookup&quot;</span><span class="Delimiter">))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L247" class="LineNr">247 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span>has_property<span class="Delimiter">(</span>product<span class="Delimiter">,</span> <span class="Constant">&quot;raw&quot;</span><span class="Delimiter">))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>  <span class="Comment">// tests often want to check such locations after they run</span>
<span id="L248" class="LineNr">248 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span><a href='043space.cc.html#L264'>escaping</a><span class="Delimiter">(</span>product<span class="Delimiter">))</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L249" class="LineNr">249 </span>      <span class="Comment">// End Checks For Reclaiming Locals</span>
<span id="L250" class="LineNr">250 </span>      <a href='003trace.cc.html#L171'>trace</a><span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;mem&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;clearing &quot;</span> &lt;&lt; product<span class="Delimiter">.</span>original_string &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L251" class="LineNr">251 </span>      zeros<span class="Delimiter">.</span>resize<span class="Delimiter">(</span>size_of<span class="Delimiter">(</span>product<span class="Delimiter">));</span>
<span id="L252" class="LineNr">252 </span>      write_memory<span class="Delimiter">(</span>product<span class="Delimiter">,</span> zeros<span class="Delimiter">);</span>
<span id="L253" class="LineNr">253 </span>    <span class="Delimiter">}</span>
<span id="L254" class="LineNr">254 </span>  <span class="Delimiter">}</span>
<span id="L255" class="LineNr">255 </span>  <a href='003trace.cc.html#L171'>trace</a><span class="Delimiter">(</span><span class="Constant">9999</span><span class="Delimiter">,</span> <span class="Constant">&quot;mem&quot;</span><span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot;automatically abandoning &quot;</span> &lt;&lt; current_call<span class="Delimiter">().</span>default_space &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L256" class="LineNr">256 </span>  <a href='037abandon.cc.html#L28'>abandon</a><span class="Delimiter">(</span>current_call<span class="Delimiter">().</span>default_space<span class="Delimiter">,</span>
<span id="L257" class="LineNr">257 </span>          inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>type<span class="Delimiter">-&gt;</span>right<span class="Delimiter">,</span>
<span id="L258" class="LineNr">258 </span>          <span class="Comment">/*</span><span class="Comment">refcount</span><span class="Comment">*/</span><span class="Constant">1</span> + <span class="Comment">/*</span><span class="Comment">array length</span><span class="Comment">*/</span><span class="Constant">1</span> + <span class="Comment">/*</span><span class="Comment">number-of-locals</span><span class="Comment">*/</span>Name[r][<span class="Constant">&quot;&quot;</span>]<span class="Delimiter">);</span>
<span id="L259" class="LineNr">259 </span><span class="Delimiter">}</span>
<span id="L260" class="LineNr">260 </span>
<span id="L261" class="LineNr">261 </span><span class="Delimiter">:(code)</span>
<span id="L262" class="LineNr">262 </span><span class="Comment">// is this reagent one of the values returned by the current (return) instruction?</span>
<span id="L263" class="LineNr">263 </span><span class="Comment">// is the corresponding ingredient saved in the caller?</span>
<span id="L264" class="LineNr">264 </span><span class="Normal">bool</span> <a href='043space.cc.html#L264'>escaping</a><span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L265" class="LineNr">265 </span>  assert<span class="Delimiter">(</span>Current_routine<span class="Delimiter">);</span>  <span class="Comment">// run-time only</span>
<span id="L266" class="LineNr">266 </span>  <span class="Comment">// nothing escapes when you fall through past end of recipe</span>
<span id="L267" class="LineNr">267 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>current_step_index<span class="Delimiter">()</span> &gt;= <a href='001help.cc.html#L138'>SIZE</a><span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>steps<span class="Delimiter">()))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L268" class="LineNr">268 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span><span class="Normal">long</span> <span class="Normal">long</span> i = <span class="Constant">0</span><span class="Delimiter">;</span>  i &lt; <a href='001help.cc.html#L138'>SIZE</a><span class="Delimiter">(</span>current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">);</span>  ++i<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L269" class="LineNr">269 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>r == current_instruction<span class="Delimiter">().</span>ingredients<span class="Delimiter">.</span>at<span class="Delimiter">(</span>i<span class="Delimiter">))</span> <span class="Delimiter">{</span>
<span id="L270" class="LineNr">270 </span>      <span class="Normal">if</span> <span class="Delimiter">(</span><a href='043space.cc.html#L295'>caller_uses_product</a><span class="Delimiter">(</span>i<span class="Delimiter">))</span>
<span id="L271" class="LineNr">271 </span>        <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L272" class="LineNr">272 </span>    <span class="Delimiter">}</span>
<span id="L273" class="LineNr">273 </span>  <span class="Delimiter">}</span>
<span id="L274" class="LineNr">274 </span>  <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L275" class="LineNr">275 </span><span class="Delimiter">}</span>
<span id="L276" class="LineNr">276 </span>
<span id="L277" class="LineNr">277 </span><span class="Comment">//: since we don't decrement refcounts for escaping values above, make sure we</span>
<span id="L278" class="LineNr">278 </span><span class="Comment">//: don't increment them when the caller saves them either</span>
<span id="L279" class="LineNr">279 </span>
<span id="L280" class="LineNr">280 </span><span class="Delimiter">:(after &quot;Write Products of Instruction&quot;)</span>
<span id="L281" class="LineNr">281 </span>Update_refcounts_in_write_memory = <a href='043space.cc.html#L285'>should_update_refcounts_in_write_memory</a><span class="Delimiter">();</span>
<span id="L282" class="LineNr">282 </span><span class="Delimiter">:(before &quot;End Write Products of Instruction&quot;)</span>
<span id="L283" class="LineNr">283 </span>Update_refcounts_in_write_memory = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L284" class="LineNr">284 </span><span class="Delimiter">:(code)</span>
<span id="L285" class="LineNr">285 </span><span class="Normal">bool</span> <a href='043space.cc.html#L285'>should_update_refcounts_in_write_memory</a><span class="Delimiter">()</span> <span class="Delimiter">{</span>
<span id="L286" class="LineNr">286 </span>  <span class="Normal">const</span> instruction&amp; inst = current_instruction<span class="Delimiter">();</span>
<span id="L287" class="LineNr">287 </span>  <span class="Comment">// End should_update_refcounts_in_write_memory Special-cases For Primitives</span>
<span id="L288" class="LineNr">288 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>inst<span class="Delimiter">.</span>operation &lt; <a href='010vm.cc.html#L192'>MAX_PRIMITIVE_RECIPES</a><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L289" class="LineNr">289 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_key<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>operation<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L290" class="LineNr">290 </span>  <span class="Normal">const</span> recipe&amp; callee = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> inst<span class="Delimiter">.</span>operation<span class="Delimiter">);</span>
<span id="L291" class="LineNr">291 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>callee<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L292" class="LineNr">292 </span>  <span class="Identifier">return</span> callee<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>old_name != <span class="Constant">&quot;local-scope&quot;</span><span class="Delimiter">;</span>  <span class="Comment">// callees that call local-scope are already dealt with before return</span>
<span id="L293" class="LineNr">293 </span><span class="Delimiter">}</span>
<span id="L294" class="LineNr">294 </span>
<span id="L295" class="LineNr">295 </span><span class="Normal">bool</span> <a href='043space.cc.html#L295'>caller_uses_product</a><span class="Delimiter">(</span><span class="Normal">int</span> product_index<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L296" class="LineNr">296 </span>  assert<span class="Delimiter">(</span>Current_routine<span class="Delimiter">);</span>  <span class="Comment">// run-time only</span>
<span id="L297" class="LineNr">297 </span>  assert<span class="Delimiter">(</span>!Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>empty<span class="Delimiter">());</span>
<span id="L298" class="LineNr">298 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>size<span class="Delimiter">()</span> == <span class="Constant">1</span><span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L299" class="LineNr">299 </span>  <span class="Normal">const</span> call&amp; caller = *++Current_routine<span class="Delimiter">-&gt;</span>calls<span class="Delimiter">.</span>begin<span class="Delimiter">();</span>
<span id="L300" class="LineNr">300 </span>  <span class="Normal">const</span> instruction&amp; caller_inst = to_instruction<span class="Delimiter">(</span>caller<span class="Delimiter">);</span>
<span id="L301" class="LineNr">301 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>product_index &gt;= <a href='001help.cc.html#L138'>SIZE</a><span class="Delimiter">(</span>caller_inst<span class="Delimiter">.</span>products<span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L302" class="LineNr">302 </span>  <span class="Identifier">return</span> !is_dummy<span class="Delimiter">(</span>caller_inst<span class="Delimiter">.</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span>product_index<span class="Delimiter">));</span>
<span id="L303" class="LineNr">303 </span><span class="Delimiter">}</span>
<span id="L304" class="LineNr">304 </span>
<span id="L305" class="LineNr">305 </span><span class="Normal">void</span> <a href='043space.cc.html#L305'>rewrite_default_space_instruction</a><span class="Delimiter">(</span>instruction&amp; curr<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L306" class="LineNr">306 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!curr<span class="Delimiter">.</span>ingredients<span class="Delimiter">.</span>empty<span class="Delimiter">())</span>
<span id="L307" class="LineNr">307 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; to_original_string<span class="Delimiter">(</span>curr<span class="Delimiter">)</span> &lt;&lt; <span class="Constant">&quot; can't take any ingredients</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L308" class="LineNr">308 </span>  curr<span class="Delimiter">.</span>name = <span class="Constant">&quot;new&quot;</span><span class="Delimiter">;</span>
<span id="L309" class="LineNr">309 </span>  <span class="Constant">curr.ingredients.push_back(reagent(&quot;location:type</span><span class="Constant">&quot;));</span>
<span id="L310" class="LineNr">310 </span>  <span class="Constant">curr.ingredients.push_back(reagent(&quot;number-of-locals:literal</span><span class="Constant">&quot;));</span>
<span id="L311" class="LineNr">311 </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 id="L312" class="LineNr">312 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; <span class="Constant">&quot;new-default-space can't take any results</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; end<span class="Delimiter">();</span>
<span id="L313" class="LineNr">313 </span>  curr<span class="Delimiter">.</span>products<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>reagent<span class="Delimiter">(</span><span class="Constant">&quot;default-space:space&quot;</span><span class="Delimiter">));</span>
<span id="L314" class="LineNr">314 </span><span class="Delimiter">}</span>
<span id="L315" class="LineNr">315 </span>
<span id="L316" class="LineNr">316 </span><span class="Delimiter">:(scenario local_scope_frees_up_addresses_inside_containers)</span>
<span id="L317" class="LineNr">317 </span><span class="muData">container</span> foo [
<span id="L318" class="LineNr">318 </span>  <span class="Normal">x</span>:num
<span id="L319" class="LineNr">319 </span>  <span class="Normal">y</span>:&amp;:num
<span id="L320" class="LineNr">320 </span>]
<span id="L321" class="LineNr">321 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L322" class="LineNr">322 </span>  local-scope
<span id="L323" class="LineNr">323 </span>  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
<span id="L324" class="LineNr">324 </span>  <span class="Normal">y</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> x:&amp;:num
<span id="L325" class="LineNr">325 </span>  <span class="Comment"># x and y are both cleared when main returns</span>
<span id="L326" class="LineNr">326 </span>]
<span id="L327" class="LineNr">327 </span><span class="traceContains">+mem: clearing x:&amp;:num</span>
<span id="L328" class="LineNr">328 </span><span class="traceContains">+mem: decrementing refcount of 1006: 2 -&gt; 1</span>
<span id="L329" class="LineNr">329 </span><span class="traceContains">+mem: clearing y:foo</span>
<span id="L330" class="LineNr">330 </span><span class="traceContains">+mem: decrementing refcount of 1006: 1 -&gt; 0</span>
<span id="L331" class="LineNr">331 </span><span class="traceContains">+mem: automatically abandoning 1006</span>
<span id="L332" class="LineNr">332 </span>
<span id="L333" class="LineNr">333 </span><span class="Delimiter">:(scenario local_scope_returns_addresses_inside_containers)</span>
<span id="L334" class="LineNr">334 </span><span class="muData">container</span> foo [
<span id="L335" class="LineNr">335 </span>  <span class="Normal">x</span>:num
<span id="L336" class="LineNr">336 </span>  <span class="Normal">y</span>:&amp;:num
<span id="L337" class="LineNr">337 </span>]
<span id="L338" class="LineNr">338 </span><span class="muRecipe">def</span> f [
<span id="L339" class="LineNr">339 </span>  local-scope
<span id="L340" class="LineNr">340 </span>  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
<span id="L341" class="LineNr">341 </span>  *x:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">12</span>
<span id="L342" class="LineNr">342 </span>  <span class="Normal">y</span>:foo<span class="Special"> &lt;- </span>merge <span class="Constant">34</span><span class="Delimiter">,</span> x:&amp;:num
<span id="L343" class="LineNr">343 </span>  <span class="Comment"># since y is 'escaping' f, it should not be cleared</span>
<span id="L344" class="LineNr">344 </span>  <span class="Identifier">return</span> y:foo
<span id="L345" class="LineNr">345 </span>]
<span id="L346" class="LineNr">346 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L347" class="LineNr">347 </span>  <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span>f
<span id="L348" class="LineNr">348 </span>  <span class="Constant">3</span>:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">x:offset</span>
<span id="L349" class="LineNr">349 </span>  <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>get <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">y:offset</span>
<span id="L350" class="LineNr">350 </span>  <span class="Constant">5</span>:num<span class="Special"> &lt;- </span>copy *<span class="Constant">4</span>:&amp;:num
<span id="L351" class="LineNr">351 </span>  <span class="Constant">1</span>:foo<span class="Special"> &lt;- </span><a href='001help.cc.html#L218'>put</a> <span class="Constant">1</span>:foo<span class="Delimiter">,</span> <span class="Constant">y:offset</span><span class="Delimiter">,</span> <span class="Constant">0</span>
<span id="L352" class="LineNr">352 </span>  <span class="Constant">4</span>:&amp;:num<span class="Special"> &lt;- </span>copy <span class="Constant">0</span>
<span id="L353" class="LineNr">353 </span>]
<span id="L354" class="LineNr">354 </span><span class="traceContains">+mem: storing 34 in location 1</span>
<span id="L355" class="LineNr">355 </span><span class="traceContains">+mem: storing 1006 in location 2</span>
<span id="L356" class="LineNr">356 </span><span class="traceContains">+mem: storing 34 in location 3</span>
<span id="L357" class="LineNr">357 </span><span class="Comment"># refcount of 1:foo shouldn't include any stray ones from f</span>
<span id="L358" class="LineNr">358 </span><span class="traceContains">+run: {4: (&quot;address&quot; &quot;number&quot;)} &lt;- get {1: &quot;foo&quot;}, {y: &quot;offset&quot;}</span>
<span id="L359" class="LineNr">359 </span><span class="traceContains">+mem: incrementing refcount of 1006: 1 -&gt; 2</span>
<span id="L360" class="LineNr">360 </span><span class="Comment"># 1:foo wasn't abandoned/cleared</span>
<span id="L361" class="LineNr">361 </span><span class="traceContains">+run: {5: &quot;number&quot;} &lt;- copy {4: (&quot;address&quot; &quot;number&quot;), &quot;lookup&quot;: ()}</span>
<span id="L362" class="LineNr">362 </span><span class="traceContains">+mem: storing 12 in location 5</span>
<span id="L363" class="LineNr">363 </span><span class="traceContains">+run: {1: &quot;foo&quot;} &lt;- <a href='001help.cc.html#L218'>put</a> {1: &quot;foo&quot;}, {y: &quot;offset&quot;}, {0: &quot;literal&quot;}</span>
<span id="L364" class="LineNr">364 </span><span class="traceContains">+mem: decrementing refcount of 1006: 2 -&gt; 1</span>
<span id="L365" class="LineNr">365 </span><span class="traceContains">+run: {4: (&quot;address&quot; &quot;number&quot;)} &lt;- copy {0: &quot;literal&quot;}</span>
<span id="L366" class="LineNr">366 </span><span class="traceContains">+mem: decrementing refcount of 1006: 1 -&gt; 0</span>
<span id="L367" class="LineNr">367 </span><span class="traceContains">+mem: automatically abandoning 1006</span>
<span id="L368" class="LineNr">368 </span>
<span id="L369" class="LineNr">369 </span><span class="Delimiter">:(scenario local_scope_claims_return_values_when_not_saved)</span>
<span id="L370" class="LineNr">370 </span><span class="muRecipe">def</span> f [
<span id="L371" class="LineNr">371 </span>  local-scope
<span id="L372" class="LineNr">372 </span>  <span class="Normal">x</span>:&amp;:num<span class="Special"> &lt;- </span><span class="Normal">new</span> <span class="Constant">number:type</span>
<span id="L373" class="LineNr">373 </span>  <span class="Identifier">return</span> x:&amp;:num
<span id="L374" class="LineNr">374 </span>]
<span id="L375" class="LineNr">375 </span><span class="muRecipe">def</span> <a href='000organization.cc.html#L113'>main</a> [
<span id="L376" class="LineNr">376 </span>  f  <span class="Comment"># doesn't save result</span>
<span id="L377" class="LineNr">377 </span>]
<span id="L378" class="LineNr">378 </span><span class="Comment"># x reclaimed</span>
<span id="L379" class="LineNr">379 </span><span class="traceContains">+mem: automatically abandoning 1004</span>
<span id="L380" class="LineNr">380 </span><span class="Comment"># f's local scope reclaimed</span>
<span id="L381" class="LineNr">381 </span><span class="traceContains">+mem: automatically abandoning 1000</span>
<span id="L382" class="LineNr">382 </span>
<span id="L383" class="LineNr">383 </span><span class="SalientComment">//:: all recipes must set default-space one way or another</span>
<span id="L384" class="LineNr">384 </span>
<span id="L385" class="LineNr">385 </span><span class="Delimiter">:(before &quot;End Globals&quot;)</span>
<span id="L386" class="LineNr">386 </span><span class="Normal">bool</span> Hide_missing_default_space_errors = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L387" class="LineNr">387 </span><span class="Delimiter">:(before &quot;End Checks&quot;)</span>
<span id="L388" class="LineNr">388 </span>Transform<span class="Delimiter">.</span>push_back<span class="Delimiter">(</span>check_default_space<span class="Delimiter">);</span>  <span class="Comment">// idempotent</span>
<span id="L389" class="LineNr">389 </span><span class="Delimiter">:(code)</span>
<span id="L390" class="LineNr">390 </span><span class="Normal">void</span> check_default_space<span class="Delimiter">(</span><span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L391" class="LineNr">391 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>Hide_missing_default_space_errors<span class="Delimiter">)</span> <span class="Identifier">return</span><span class="Delimiter">;</span>  <span class="Comment">// skip previous core tests; this is only for Mu code</span>
<span id="L392" class="LineNr">392 </span>  <span class="Normal">const</span> recipe&amp; caller = get<span class="Delimiter">(</span>Recipe<span class="Delimiter">,</span> r<span class="Delimiter">);</span>
<span id="L393" class="LineNr">393 </span>  <span class="Comment">// End check_default_space Special-cases</span>
<span id="L394" class="LineNr">394 </span>  <span class="Comment">// assume recipes with only numeric addresses know what they're doing (usually tests)</span>
<span id="L395" class="LineNr">395 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>!contains_non_special_name<span class="Delimiter">(</span>r<span class="Delimiter">))</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L396" class="LineNr">396 </span>  <a href='003trace.cc.html#L171'>trace</a><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;--- check that <a href='010vm.cc.html#L19'>recipe</a> &quot;</span> &lt;&lt; caller<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; sets default-space&quot;</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L397" class="LineNr">397 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>caller<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">return</span><span class="Delimiter">;</span>
<span id="L398" class="LineNr">398 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>caller<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>products<span class="Delimiter">.</span>empty<span class="Delimiter">()</span>
<span id="L399" class="LineNr">399 </span>      || caller<span class="Delimiter">.</span>steps<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>products<span class="Delimiter">.</span>at<span class="Delimiter">(</span><span class="Constant">0</span><span class="Delimiter">).</span>name != <span class="Constant">&quot;default-space&quot;</span><span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L400" class="LineNr">400 </span>    <a href='003trace.cc.html#L178'>raise</a> &lt;&lt; caller<span class="Delimiter">.</span>name &lt;&lt; <span class="Constant">&quot; does not seem to start with default-space or local-scope</span><span class="cSpecial">\n</span><span class="Constant">&quot;</span> &lt;&lt; <a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>
<span id="L401" class="LineNr">401 </span>  <span class="Delimiter">}</span>
<span id="L402" class="LineNr">402 </span><span class="Delimiter">}</span>
<span id="L403" class="LineNr">403 </span><span class="Delimiter">:(after &quot;Load Mu Prelude&quot;)</span>
<span id="L404" class="LineNr">404 </span>Hide_missing_default_space_errors = <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L405" class="LineNr">405 </span><span class="Delimiter">:(after &quot;Test Runs&quot;)</span>
<span id="L406" class="LineNr">406 </span>Hide_missing_default_space_errors = <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L407" class="LineNr">407 </span><span class="Delimiter">:(after &quot;Running Main&quot;)</span>
<span id="L408" class="LineNr">408 </span>Hide_missing_default_space_errors = <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L409" class="LineNr">409 </span>
<span id="L410" class="LineNr">410 </span><span class="Delimiter">:(code)</span>
<span id="L411" class="LineNr">411 </span><span class="Normal">bool</span> contains_non_special_name<span class="Delimiter">(</span><span class="Normal">const</span> <a href='010vm.cc.html#L14'>recipe_ordinal</a> r<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L412" class="LineNr">412 </span>  <span class="Normal">for</span> <span class="Delimiter">(</span>map&lt;string<span class="Delimiter">,</span> <span class="Normal">int</span>&gt;::iterator p = Name[r]<span class="Delimiter">.</span>begin<span class="Delimiter">();</span>  p != Name[r]<span class="Delimiter">.</span><a href='003trace.cc.html#L195'>end</a><span class="Delimiter">();</span>  ++p<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L413" class="LineNr">413 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">.</span>empty<span class="Delimiter">())</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>
<span id="L414" class="LineNr">414 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">.</span>find<span class="Delimiter">(</span><span class="Constant">&quot;stash_&quot;</span><span class="Delimiter">)</span> == <span class="Constant">0</span><span class="Delimiter">)</span> <span class="Identifier">continue</span><span class="Delimiter">;</span>  <span class="Comment">// generated by rewrite_stashes_to_text (cross-layer)</span>
<span id="L415" class="LineNr">415 </span>    <span class="Normal">if</span> <span class="Delimiter">(</span>!is_special_name<span class="Delimiter">(</span>p<span class="Delimiter">-&gt;</span>first<span class="Delimiter">))</span>
<span id="L416" class="LineNr">416 </span>      <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L417" class="LineNr">417 </span>  <span class="Delimiter">}</span>
<span id="L418" class="LineNr">418 </span>  <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L419" class="LineNr">419 </span><span class="Delimiter">}</span>
<span id="L420" class="LineNr">420 </span>
<span id="L421" class="LineNr">421 </span><span class="Comment">// reagent comparison -- only between reagents in a single recipe</span>
<span id="L422" class="LineNr">422 </span><span class="Normal">bool</span> <span class="Normal">operator</span>==<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; a<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; b<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L423" class="LineNr">423 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>a<span class="Delimiter">.</span>name != b<span class="Delimiter">.</span>name<span class="Delimiter">)</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L424" class="LineNr">424 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>property<span class="Delimiter">(</span>a<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)</span> != property<span class="Delimiter">(</span>b<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">))</span> <span class="Identifier">return</span> <span class="Constant">false</span><span class="Delimiter">;</span>
<span id="L425" class="LineNr">425 </span>  <span class="Identifier">return</span> <span class="Constant">true</span><span class="Delimiter">;</span>
<span id="L426" class="LineNr">426 </span><span class="Delimiter">}</span>
<span id="L427" class="LineNr">427 </span>
<span id="L428" class="LineNr">428 </span><span class="Normal">bool</span> <span class="Normal">operator</span>&lt;<span class="Delimiter">(</span><span class="Normal">const</span> reagent&amp; a<span class="Delimiter">,</span> <span class="Normal">const</span> reagent&amp; b<span class="Delimiter">)</span> <span class="Delimiter">{</span>
<span id="L429" class="LineNr">429 </span>  <span class="Normal">int</span> aspace = <span class="Constant">0</span><span class="Delimiter">,</span> bspace = <span class="Constant">0</span><span class="Delimiter">;</span>
<span id="L430" class="LineNr">430 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>has_property<span class="Delimiter">(</span>a<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">))</span> aspace = <a href='002test.cc.html#L92'>to_integer</a><span class="Delimiter">(</span>property<span class="Delimiter">(</span>a<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)-&gt;</span>value<span class="Delimiter">);</span>
<span id="L431" class="LineNr">431 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>has_property<span class="Delimiter">(</span>b<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">))</span> bspace = <a href='002test.cc.html#L92'>to_integer</a><span class="Delimiter">(</span>property<span class="Delimiter">(</span>b<span class="Delimiter">,</span> <span class="Constant">&quot;space&quot;</span><span class="Delimiter">)-&gt;</span>value<span class="Delimiter">);</span>
<span id="L432" class="LineNr">432 </span>  <span class="Normal">if</span> <span class="Delimiter">(</span>aspace != bspace<span class="Delimiter">)</span> <span class="Identifier">return</span> aspace &lt; bspace<span class="Delimiter">;</span>
<span id="L433" class="LineNr">433 </span>  <span class="Identifier">return</span> a<span class="Delimiter">.</span>name &lt; b<span class="Delimiter">.</span>name<span class="Delimiter">;</span>
<span id="L434" class="LineNr">434 </span><span class="Delimiter">}</span>
</pre>
</body>
</html>
<!-- vim: set foldmethod=manual : -->