1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-06-17 07:40:47 +03:00

Improved command-line interface for inter

This commit is contained in:
Graham Nelson 2022-03-24 23:35:22 +00:00
parent fdbb235a63
commit c876a87d40
24 changed files with 671 additions and 386 deletions

View file

@ -104,11 +104,40 @@ or, say, "32-bit to be generated to ANSI C code".
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Inform6"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"3.1.2"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"i6"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"ulx"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"gblorb"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"Quixe"</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="comment-syntax"> hat tip: modesty forbids</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Binary"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Binary"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Binary"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Binary"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="comment-syntax"> C support added September 2021</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"C"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"C"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="comment-syntax"> Inventory support added March 2022</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Inventory"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"16d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Inventory"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Inventory"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-tvm.html#SP3" class="function-link"><span class="function-syntax">TargetVMs::new</span></a><span class="plain-syntax">(</span><a href="2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::from_codename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"32d"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Inventory"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VersionNumbers::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"1"</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"c"</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">""</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>The <a href="2-tvm.html#SP2" class="internal">target_vm</a> structure contains two arguably architectural doohickies:

View file

@ -73,7 +73,7 @@ function togglePopup(material_id) {
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Compiler Tools</a></li><li><a href="index.html">inter</a></li><li><a href="index.html#1">Chapter 1: Outside of inform7</a></li><li><b>Main</b></li></ul></div>
<p class="purpose">A command-line interface for Inter functions which are not part of the normal operation of the Inform compiler.</p>
<ul class="toc"><li><a href="1-mn.html#SP1">&#167;1. Settings variables</a></li><li><a href="1-mn.html#SP2">&#167;2. Main routine</a></li><li><a href="1-mn.html#SP2_7">&#167;2.7. Command line</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="1-mn.html#SP1">&#167;1. Settings variables</a></li><li><a href="1-mn.html#SP2">&#167;2. Main routine</a></li><li><a href="1-mn.html#SP2_6">&#167;2.6. Command line</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Settings variables. </b>The following will be set at the command line.
</p>
@ -84,17 +84,18 @@ function togglePopup(material_id) {
<span class="reserved-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">domain_path</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="comment-syntax"> of </span><span class="extract"><span class="extract-syntax">filename</span></span>
<span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">output_textually</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">output_binarily</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">output_file</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">dictionary</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">internal_path</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">output_format</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="comment-syntax"> for any </span><span class="extract"><span class="extract-syntax">-o</span></span><span class="comment-syntax"> output</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tracing</span><span class="plain-syntax"> = </span><span class="constant-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::add_pipeline_variable</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Main::add_pipeline_variable</span></span>:<br/><a href="1-mn.html#SP2_3">&#167;2.3</a>, <a href="1-mn.html#SP3_1">&#167;3.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">name</span><span class="plain-syntax">, </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">value</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP17" class="function-link"><span class="function-syntax">Str::copy</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/2-dct.html#SP9" class="function-link"><span class="function-syntax">Dictionaries::create_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">, </span><span class="identifier-syntax">name</span><span class="plain-syntax">), </span><span class="identifier-syntax">value</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::add_pipeline_variable_from_filename</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></span>:<br/><a href="1-mn.html#SP2_3">&#167;2.3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">name</span><span class="plain-syntax">, </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::add_pipeline_variable_from_filename</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></span>:<br/><a href="1-mn.html#SP2_3">&#167;2.3</a>, <a href="1-mn.html#SP2_4">&#167;2.4</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">name</span><span class="plain-syntax">, </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">fullname</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">fullname</span><span class="plain-syntax">, </span><span class="string-syntax">"%f"</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="1-mn.html#SP1" class="function-link"><span class="function-syntax">Main::add_pipeline_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">name</span><span class="plain-syntax">, </span><span class="identifier-syntax">fullname</span><span class="plain-syntax">);</span>
@ -115,13 +116,10 @@ also done with a pipeline.
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">main</span><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">argc</span><span class="plain-syntax">, </span><span class="reserved-syntax">char</span><span class="plain-syntax"> **</span><span class="identifier-syntax">argv</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_1" class="named-paragraph-link"><span class="named-paragraph">Start up the modules</span><span class="named-paragraph-number">2.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_2" class="named-paragraph-link"><span class="named-paragraph">Begin with an empty file list and variables dictionary</span><span class="named-paragraph-number">2.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_7" class="named-paragraph-link"><span class="named-paragraph">Read the command line</span><span class="named-paragraph-number">2.7</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_3" class="named-paragraph-link"><span class="named-paragraph">Set up a pipeline for kit-building</span><span class="named-paragraph-number">2.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_4" class="named-paragraph-link"><span class="named-paragraph">Run the pipeline</span><span class="named-paragraph-number">2.4</span></a></span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_5" class="named-paragraph-link"><span class="named-paragraph">Read the list of inter files, and perhaps transcode them</span><span class="named-paragraph-number">2.5</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_6" class="named-paragraph-link"><span class="named-paragraph">Shut down the modules</span><span class="named-paragraph-number">2.6</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_6" class="named-paragraph-link"><span class="named-paragraph">Read the command line</span><span class="named-paragraph-number">2.6</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_3" class="named-paragraph-link"><span class="named-paragraph">Select the build-kit pipeline</span><span class="named-paragraph-number">2.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_4" class="named-paragraph-link"><span class="named-paragraph">Run the pipeline</span><span class="named-paragraph-number">2.4</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_5" class="named-paragraph-link"><span class="named-paragraph">Shut down the modules</span><span class="named-paragraph-number">2.5</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/3-em.html#SP1" class="function-link"><span class="function-syntax">Errors::have_occurred</span></a><span class="plain-syntax">()) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
@ -148,13 +146,7 @@ also done with a pipeline.
<span class="plain-syntax"> </span><span class="identifier-syntax">internal_path</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-pth.html#SP5" class="function-link"><span class="function-syntax">Pathnames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"inform7/Internal"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_3" class="paragraph-anchor"></a><b>&#167;2.3. </b>This pipeline is supplied built in to the installation of <span class="extract"><span class="extract-syntax">inter</span></span>. In fact,
it only ever writes the binary form of the code it produces, so only <span class="extract"><span class="extract-syntax">*out</span></span>
is used. But at times in the past it has been useful to debug with the text
form, which would be written to <span class="extract"><span class="extract-syntax">*outt</span></span>.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Set up a pipeline for kit-building</span><span class="named-paragraph-number">2.3</span></span><span class="comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP2_3" class="paragraph-anchor"></a><b>&#167;2.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Select the build-kit pipeline</span><span class="named-paragraph-number">2.3</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -169,52 +161,59 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-pth.html#SP7" class="function-link"><span class="function-syntax">Pathnames::directory_name</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><a href="1-mn.html#SP1" class="function-link"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"*out"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><a href="../arch-module/2-arc.html#SP4" class="function-link"><span class="function-syntax">Architectures::canonical_binary</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">, </span><span class="identifier-syntax">A</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><a href="1-mn.html#SP1" class="function-link"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"*outt"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><a href="../arch-module/2-arc.html#SP4" class="function-link"><span class="function-syntax">Architectures::canonical_textual</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">, </span><span class="identifier-syntax">A</span><span class="plain-syntax">));</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_4" class="paragraph-anchor"></a><b>&#167;2.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Run the pipeline</span><span class="named-paragraph-number">2.4</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/2-llas.html#SP7" class="function-link"><span class="function-syntax">LinkedLists::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"-pipeline-text and -pipeline-file cannot be combined with inter files"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"-pipeline-text and -pipeline-file are mutually exclusive"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">inter_pipeline</span><span class="plain-syntax"> *</span><span class="identifier-syntax">SS</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_file</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NEW_LINKED_LIST</span><span class="plain-syntax">(</span><span class="reserved-syntax">attachment_instruction</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax">) </span><a href="../pipeline-module/2-rp.html#SP3" class="function-link"><span class="function-syntax">RunningPipelines::run</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">domain_path</span><span class="plain-syntax">, </span><span class="identifier-syntax">SS</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">, </span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"pipeline could not be parsed"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP8" class="function-link"><span class="function-syntax">Str::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">output_format</span><span class="plain-syntax">) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">output_format</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="string-syntax">"Text"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">target_vm</span><span class="plain-syntax"> *</span><span class="identifier-syntax">VM</span><span class="plain-syntax"> = </span><a href="../arch-module/2-tvm.html#SP6" class="function-link"><span class="function-syntax">TargetVMs::find</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">output_format</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">VM</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"unrecognised compilation -format"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../pipeline-module/1-pm.html#SP4" class="function-link"><span class="function-syntax">PipelineModule::set_architecture</span></a><span class="plain-syntax">(</span>
<span class="plain-syntax"> </span><a href="../arch-module/2-arc.html#SP5" class="function-link"><span class="function-syntax">Architectures::to_codename</span></a><span class="plain-syntax">(</span><a href="../arch-module/2-tvm.html#SP11" class="function-link"><span class="function-syntax">TargetVMs::get_architecture</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">VM</span><span class="plain-syntax">)));</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">inter_tree</span><span class="plain-syntax"> *</span><span class="identifier-syntax">I</span><span class="plain-syntax"> = </span><a href="../bytecode-module/2-it.html#SP2" class="function-link"><span class="function-syntax">InterTree::new</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/2-llas.html#SP7" class="function-link"><span class="function-syntax">LinkedLists::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/2-llas.html#SP7" class="function-link"><span class="function-syntax">LinkedLists::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"only one file of Inter can be supplied"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOOP_OVER_LINKED_LIST</span><span class="plain-syntax">(</span><span class="identifier-syntax">F</span><span class="plain-syntax">, </span><span class="reserved-syntax">filename</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="1-mn.html#SP1" class="function-link"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"*in"</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">output_file</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="1-mn.html#SP1" class="function-link"><span class="function-syntax">Main::add_pipeline_variable_from_filename</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"*out"</span><span class="plain-syntax">, </span><span class="identifier-syntax">output_file</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">inter_pipeline</span><span class="plain-syntax"> *</span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP2_4_1" class="named-paragraph-link"><span class="named-paragraph">Compile the pipeline</span><span class="named-paragraph-number">2.4.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">req_list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NEW_LINKED_LIST</span><span class="plain-syntax">(</span><span class="reserved-syntax">attachment_instruction</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../pipeline-module/2-rp.html#SP3" class="function-link"><span class="function-syntax">RunningPipelines::run</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">domain_path</span><span class="plain-syntax">, </span><span class="identifier-syntax">SS</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="plain-syntax">, </span><span class="identifier-syntax">kit_to_build</span><span class="plain-syntax">, </span><span class="identifier-syntax">req_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">VM</span><span class="plain-syntax">, </span><span class="identifier-syntax">tracing</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_5" class="paragraph-anchor"></a><b>&#167;2.5. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Read the list of inter files, and perhaps transcode them</span><span class="named-paragraph-number">2.5</span></span><span class="comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP2_4_1" class="paragraph-anchor"></a><b>&#167;2.4.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile the pipeline</span><span class="named-paragraph-number">2.4.1</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">inter_tree</span><span class="plain-syntax"> *</span><span class="identifier-syntax">I</span><span class="plain-syntax"> = </span><a href="../bytecode-module/2-it.html#SP2" class="function-link"><span class="function-syntax">InterTree::new</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOOP_OVER_LINKED_LIST</span><span class="plain-syntax">(</span><span class="identifier-syntax">F</span><span class="plain-syntax">, </span><span class="reserved-syntax">filename</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../bytecode-module/3-iibf.html#SP1" class="function-link"><span class="function-syntax">BinaryInter::test_file</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">F</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><a href="../bytecode-module/3-iibf.html#SP9" class="function-link"><span class="function-syntax">BinaryInter::read</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>
<span class="plain-syntax"> </span><a href="../bytecode-module/3-iitf.html#SP1" class="function-link"><span class="function-syntax">TextualInter::read</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_file</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"pipeline could not be parsed"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"pipeline could not be parsed"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">output_file</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"read &lt;- *in, generate -&gt; *out"</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"pipeline could not be parsed"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/2-llas.html#SP7" class="function-link"><span class="function-syntax">LinkedLists::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SS</span><span class="plain-syntax"> = </span><a href="../pipeline-module/2-pp.html#SP5" class="function-link"><span class="function-syntax">ParsingPipelines::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="string-syntax">"read &lt;- *in"</span><span class="plain-syntax">, </span><span class="identifier-syntax">pipeline_vars</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal</span></a><span class="plain-syntax">(</span><span class="string-syntax">"pipeline could not be parsed"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">output_textually</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> </span><span class="identifier-syntax">C_struct</span><span class="plain-syntax">; </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax"> = &amp;</span><span class="identifier-syntax">C_struct</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">STREAM_OPEN_TO_FILE</span><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">output_textually</span><span class="plain-syntax">, </span><span class="constant-syntax">UTF8_ENC</span><span class="plain-syntax">) == </span><span class="constant-syntax">FALSE</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-em.html#SP2" class="function-link"><span class="function-syntax">Errors::fatal_with_file</span></a><span class="plain-syntax">(</span><span class="string-syntax">"unable to open textual inter file for output: %f"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">output_textually</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../bytecode-module/3-iitf.html#SP9" class="function-link"><span class="function-syntax">TextualInter::write</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">STREAM_CLOSE</span><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">output_binarily</span><span class="plain-syntax">) </span><a href="../bytecode-module/3-iibf.html#SP9" class="function-link"><span class="function-syntax">BinaryInter::write</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">output_binarily</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_6" class="paragraph-anchor"></a><b>&#167;2.6. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Shut down the modules</span><span class="named-paragraph-number">2.6</span></span><span class="comment-syntax"> =</span>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2_4">&#167;2.4</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_5" class="paragraph-anchor"></a><b>&#167;2.5. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Shut down the modules</span><span class="named-paragraph-number">2.5</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -227,11 +226,9 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/1-fm.html#SP9" class="function-link"><span class="function-syntax">Foundation::end</span></a><span class="plain-syntax">(); </span><span class="comment-syntax"> must be ended last</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="1-mn.html#SP2">&#167;2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP2_7" class="paragraph-anchor"></a><b>&#167;2.7. Command line. </b></p>
<p class="commentary firstcommentary"><a id="SP2_6" class="paragraph-anchor"></a><b>&#167;2.6. Command line. </b></p>
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">PROGRAM_NAME</span><span class="plain-syntax"> </span><span class="string-syntax">"inter"</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">TEXTUAL_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">BINARY_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">PIPELINE_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">PIPELINE_FILE_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">PIPELINE_VARIABLE_CLSW</span>
@ -242,8 +239,11 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="definition-keyword">enum</span> <span class="constant-syntax">CONSTRUCTS_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">ANNOTATIONS_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">PRIMITIVES_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">FORMAT_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">O_CLSW</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">TRACE_CLSW</span>
</pre>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Read the command line</span><span class="named-paragraph-number">2.7</span></span><span class="comment-syntax"> =</span>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Read the command line</span><span class="named-paragraph-number">2.6</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -251,10 +251,10 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"[[Purpose]]\n\n"</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"usage: inter file1 file2 ... [options]\n"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">TEXTUAL_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"textual"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"write to file X in textual format"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">BINARY_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"binary"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"write to file X in binary format"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">O_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"o"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"code-generate to file X"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP6" class="function-link"><span class="function-syntax">CommandLine::declare_textual_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">FORMAT_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"format"</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"code-generate -o output to format X (default is Text)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">PIPELINE_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"pipeline-text"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"specify pipeline textually, with X being a comma-separated list of stages"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">PIPELINE_FILE_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"pipeline-file"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
@ -275,6 +275,8 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"print out table of all symbol annotations in the Inter language"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP5" class="function-link"><span class="function-syntax">CommandLine::declare_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">PRIMITIVES_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"primitives"</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"print out table of all primitive invocations in the Inter language"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP6" class="function-link"><span class="function-syntax">CommandLine::declare_boolean_switch</span></a><span class="plain-syntax">(</span><span class="constant-syntax">TRACE_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"trace"</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"print out all pipeline steps as they are followed"</span><span class="plain-syntax">, </span><span class="constant-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/3-cla.html#SP8" class="function-link"><span class="function-syntax">CommandLine::read</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">argc</span><span class="plain-syntax">, </span><span class="identifier-syntax">argv</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, &amp;</span><a href="1-mn.html#SP3" class="function-link"><span class="function-syntax">Main::respond</span></a><span class="plain-syntax">, &amp;</span><a href="1-mn.html#SP4" class="function-link"><span class="function-syntax">Main::add_file</span></a><span class="plain-syntax">);</span>
@ -284,10 +286,10 @@ form, which would be written to <span class="extract"><span class="extract-synta
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::respond</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">Main::respond</span></span>:<br/><a href="1-mn.html#SP2_7">&#167;2.7</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">id</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">arg</span><span class="plain-syntax">, </span><span class="reserved-syntax">void</span><span class="plain-syntax"> *</span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::respond</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">Main::respond</span></span>:<br/><a href="1-mn.html#SP2_6">&#167;2.6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">id</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">arg</span><span class="plain-syntax">, </span><span class="reserved-syntax">void</span><span class="plain-syntax"> *</span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">id</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">TEXTUAL_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">output_textually</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">BINARY_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">output_binarily</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">O_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">output_file</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">FORMAT_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">output_format</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP3" class="function-link"><span class="function-syntax">Str::duplicate</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PIPELINE_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">pipeline_as_text</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP3" class="function-link"><span class="function-syntax">Str::duplicate</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PIPELINE_FILE_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">pipeline_as_file</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PIPELINE_VARIABLE_CLSW:</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-mn.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Add a pipeline variable to the dictionary</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
@ -301,6 +303,7 @@ form, which would be written to <span class="extract"><span class="extract-synta
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">CONSTRUCTS_CLSW:</span><span class="plain-syntax"> </span><a href="../bytecode-module/3-ic.html#SP16" class="function-link"><span class="function-syntax">InterInstruction::show_constructs</span></a><span class="plain-syntax">(</span><span class="constant-syntax">STDOUT</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">ANNOTATIONS_CLSW:</span><span class="plain-syntax"> </span><a href="../bytecode-module/2-ann.html#SP5" class="function-link"><span class="function-syntax">SymbolAnnotation::show_annotations</span></a><span class="plain-syntax">(</span><span class="constant-syntax">STDOUT</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRIMITIVES_CLSW:</span><span class="plain-syntax"> </span><a href="../building-module/1-ip.html#SP6" class="function-link"><span class="function-syntax">Primitives::show_primitives</span></a><span class="plain-syntax">(</span><span class="constant-syntax">STDOUT</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRACE_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">tracing</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">val</span><span class="plain-syntax">)?</span><span class="identifier-syntax">TRUE:FALSE</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax">}</span>
</pre>
@ -324,7 +327,7 @@ form, which would be written to <span class="extract"><span class="extract-synta
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::add_file</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Main::add_file</span></span>:<br/><a href="1-mn.html#SP2_7">&#167;2.7</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">id</span><span class="plain-syntax">, </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">arg</span><span class="plain-syntax">, </span><span class="reserved-syntax">void</span><span class="plain-syntax"> *</span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Main::add_file</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Main::add_file</span></span>:<br/><a href="1-mn.html#SP2_6">&#167;2.6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">id</span><span class="plain-syntax">, </span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">arg</span><span class="plain-syntax">, </span><span class="reserved-syntax">void</span><span class="plain-syntax"> *</span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">ADD_TO_LINKED_LIST</span><span class="plain-syntax">(</span><span class="identifier-syntax">F</span><span class="plain-syntax">, </span><span class="reserved-syntax">filename</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_file_list</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>

View file

@ -66,48 +66,43 @@
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Compiler Tools</a></li><li><a href="index.html">inter</a></li><li><a href="index.html#M">Manual</a></li><li><b>Pipelines and Stages</b></li></ul></div>
<p class="purpose">Sequences of named code-generation stages are called pipelines.</p>
<ul class="toc"><li><a href="M-pas.html#SP1">&#167;1. Stages and pipelines</a></li><li><a href="M-pas.html#SP4">&#167;4. Pipelines run by Inform</a></li><li><a href="M-pas.html#SP7">&#167;7. Syntax of pipeline descriptions</a></li><li><a href="M-pas.html#SP9">&#167;9. Dictionary of stages</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="M-pas.html#SP1">&#167;1. Variables and filenames</a></li><li><a href="M-pas.html#SP4">&#167;4. Pipelines run by Inform</a></li><li><a href="M-pas.html#SP5">&#167;5. Syntax of pipeline descriptions</a></li><li><a href="M-pas.html#SP7">&#167;7. Dictionary of stages</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Stages and pipelines. </b>Inter has a pipeline design, meaning that it expects to work on Inter trees by
running a series of modifying "steps", one at a time.
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Variables and filenames. </b>For an introduction to pipelines, first read the section <a href="M-ui.html" class="internal">Using Inter</a>.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; </span><span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; </span><span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; ... --------&gt; </span><span class="element-syntax">T</span>
<span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span><span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span><span class="plain-syntax"> ... </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="element-syntax">N</span>
</pre>
<p class="commentary">The Inter tree <span class="extract"><span class="extract-syntax">T</span></span> starts out empty, and at the end it is thrown away. So any
useful pipeline will begin by loading something in (usually as step 1), and
end by producing some useful output (usually in its last step or steps).
<p class="commentary">In that section, two variables <span class="extract"><span class="extract-syntax">*in</span></span> and <span class="extract"><span class="extract-syntax">*out</span></span> appeared, but no others.
Those were automatically set as needed: <span class="extract"><span class="extract-syntax">*in</span></span> was the file specified first
in the command, while <span class="extract"><span class="extract-syntax">*out</span></span> was the value of the <span class="extract"><span class="extract-syntax">-o</span></span> output file switch.
</p>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>Formally, a pipeline is a list of steps, with each step being a usage of
a "stage". If a pipeline is spelled out textually on the Inter command line,
then commas are used to divide the stages:
<p class="commentary">In fact, though, any number of variables can be set at the command line.
<span class="extract"><span class="extract-syntax">-variable '*magicword=zooge'</span></span>, for example, creates the variable <span class="extract"><span class="extract-syntax">*magicword</span></span>
and sets its initial value to "zooge".
</p>
<p class="commentary">Of course, this has no practical effect unless the pipeline we are running
makes use of such a variable. But we might imagine running:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -pipeline-text</span><span class="ConsoleText-plain-syntax"> 'plugh, xyzzy, plover'</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -pipeline-file</span><span class="ConsoleText-plain-syntax"> mypl.interpipeline</span><span class="ConsoleText-identifier-syntax"> -variable</span><span class="ConsoleText-plain-syntax"> '*textual=v1.intert'</span><span class="ConsoleText-identifier-syntax"> -variable</span><span class="ConsoleText-plain-syntax"> '*binary=v2.interb'</span>
</pre>
<p class="commentary">If the pipeline is in an external file, we would instead write:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -pipeline-file</span><span class="ConsoleText-plain-syntax"> mypl.interpipeline</span>
</pre>
<p class="commentary">and the file <span class="extract"><span class="ConsoleText-extract-syntax">mypl.interpipeline</span></span> would have one stage listed on each line,
so that the commas are not needed:
<p class="commentary">where <span class="extract"><span class="ConsoleText-extract-syntax">mypl.interpipeline</span></span> reads:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> plugh</span>
<span class="plain-syntax"> xyzzy</span>
<span class="plain-syntax"> plover</span>
<span class="plain-syntax">read &lt;- *in</span>
<span class="plain-syntax">generate text -&gt; *textual</span>
<span class="plain-syntax">generate binary -&gt; *binary</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. </b>A pipeline description can make use of "variables". These hold only text,
and generally represent filenames. Variable names begin with a star <span class="extract"><span class="extract-syntax">*</span></span>.
The pipeline cannot create variables: instead, the user of the pipeline has
to make them before use. For example,
<p class="commentary">This will then write out the same Inter program in two different formats, to
two different files.
</p>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>Variables hold only text, and generally represent filenames. Variable names
begin with a star <span class="extract"><span class="extract-syntax">*</span></span>. When a pipeline runs, the value of a variable is
substituted for its name. For example,
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
@ -132,11 +127,14 @@ description are interpreted as follows:
<ul class="items"><li>(a) If a filename contains a slash character, it is considered a literal
filename.
</li><li>(b) If not, it is considered to be a leafname inside the "domain" directory.
</li><li>(b) If the filename is just <span class="extract"><span class="extract-syntax">-</span></span>, it is considered to mean the console, that
is, what in Unix is usually called <span class="extract"><span class="extract-syntax">stdout</span></span>. In other words, output is printed
rather than saved.
</li><li>(c) If not, it is considered to be a leafname inside the "domain" directory.
By default this is the current working directory, but using <span class="extract"><span class="extract-syntax">-domain</span></span> at
the Inter command line changes that.
</li></ul>
<p class="commentary">The special variable <span class="extract"><span class="extract-syntax">*log</span></span>, which always exists, means the debugging log.
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. </b>The special variable <span class="extract"><span class="extract-syntax">*log</span></span>, which always exists, means the debugging log.
A command to write a text file to <span class="extract"><span class="extract-syntax">*log</span></span> is interpreted instead to mean
"spool the output you would otherwise write to the debugging log instead".
For example,
@ -145,27 +143,7 @@ For example,
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> generate inventory </span><span class="reserved-syntax">-&gt;</span><span class="plain-syntax"> </span><span class="identifier-syntax">*log</span>
</pre>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Pipelines run by Inform. </b>As the above implies, Inter pipelines normally begin with a clean slate:
no trees, no variables.
</p>
<p class="commentary">When a pipeline is being run by the main Inform 7 compiler, however,
two variables are created in advance. <span class="extract"><span class="extract-syntax">*in</span></span> is set to the Inter code
which Inform has generated on the current run, and <span class="extract"><span class="extract-syntax">*out</span></span> is set to the
filename to which final code needs to be generated. The practical
effect is that any useful pipeline for Inform will begin and end thus:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> read </span><span class="reserved-syntax">&lt;-</span><span class="plain-syntax"> </span><span class="identifier-syntax">*in</span>
<span class="plain-syntax"> ...</span>
<span class="plain-syntax"> generate </span><span class="reserved-syntax">-&gt;</span><span class="plain-syntax"> </span><span class="identifier-syntax">*out</span>
</pre>
<p class="commentary">In addition, the "domain" is set to the directory containing the <span class="extract"><span class="extract-syntax">*out</span></span>
file.
</p>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. </b>To Inbuild and Inform, pipelines are resources in their own right, rather
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Pipelines run by Inform. </b>To Inbuild and Inform, pipelines are resources in their own right, rather
like extensions or kits. So, for example, the standard distribution includes
</p>
@ -231,10 +209,7 @@ last two. (It can't find pipelines by name because it doesn't contain the
supervisor module for sorting out resources.)
</p>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. </b>For more on this, see <a href="../pipeline-module/P-wtmd.html" class="internal">What This Module Does (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Syntax of pipeline descriptions. </b>Pipelines are, roughly speaking, just lists of steps. Each step occupies a single
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Syntax of pipeline descriptions. </b>Pipelines are, roughly speaking, just lists of steps. Each step occupies a single
line: blank lines are ignored, and so are lines whose first non-white-space
character is a <span class="extract"><span class="ConsoleText-extract-syntax">!</span></span>, which are considered comments.
</p>
@ -280,7 +255,7 @@ example, <span class="extract"><span class="extract-syntax">eliminate-redundant-
<span class="plain-syntax"> read </span><span class="constant-syntax">2</span><span class="plain-syntax"> </span><span class="reserved-syntax">&lt;-</span><span class="plain-syntax"> </span><span class="identifier-syntax">*in</span>
<span class="plain-syntax"> generate </span><span class="constant-syntax">3</span><span class="plain-syntax"> </span><span class="reserved-syntax">-&gt;</span><span class="plain-syntax"> </span><span class="identifier-syntax">*out</span>
</pre>
<p class="commentary">Pipeline descriptios allow us to manage up to 10 different Inter trees, and
<p class="commentary">Pipeline descriptions allow us to manage up to 10 different Inter trees, and
these are called <span class="extract"><span class="extract-syntax">0</span></span> to <span class="extract"><span class="extract-syntax">9</span></span>. These are all initially empty. Any stage which
doesn't specify a tree is considered to apply to <span class="extract"><span class="extract-syntax">0</span></span>; so pipelines often never
mention the digits <span class="extract"><span class="extract-syntax">0</span></span> to <span class="extract"><span class="extract-syntax">9</span></span> at all because they always work inside <span class="extract"><span class="extract-syntax">0</span></span>.
@ -307,7 +282,7 @@ or by the tool calling for the pipeline to be run, e.g., the <a href="../supervi
module inside Inform 7.
</p>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. </b>Pipelines can also include each other. For example, the step:
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. </b>Pipelines can also include each other. For example, the step:
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -330,12 +305,12 @@ main pipeline <span class="extract"><span class="extract-syntax">compile</span><
<span class="plain-syntax">generate </span><span class="reserved-syntax">-&gt;</span><span class="plain-syntax"> </span><span class="identifier-syntax">*out</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Dictionary of stages. </b>The following gives a brief guide to the available stages, in alphabetical
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Dictionary of stages. </b>The following gives a brief guide to the available stages, in alphabetical
order. See also <a href="../pipeline-module/P-wtmd.html" class="internal">What This Module Does (in pipeline)</a> for how (some of) these
stages are used when building kits or projects.
</p>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. </b><span class="extract"><span class="extract-syntax">compile-splats</span></span>.
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. </b><span class="extract"><span class="extract-syntax">compile-splats</span></span>.
A "splat" node holds a single Inform 6-written statement or directive, and
thus represents not-yet-compiled material. This stage converts all remaining
splat nodes to Inter code. Note that <span class="extract"><span class="extract-syntax">resolve-conditional-compilation</span></span> must
@ -345,7 +320,7 @@ already have run for this to handle <span class="extract"><span class="extract-s
<p class="commentary">For the implementation, see <a href="../pipeline-module/3-css.html" class="internal">Compile Splats Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. </b><span class="extract"><span class="extract-syntax">detect-indirect-calls</span></span>.
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. </b><span class="extract"><span class="extract-syntax">detect-indirect-calls</span></span>.
Handles an edge case in linking where a function call in one compilation unit,
e.g., <span class="extract"><span class="extract-syntax">X(1)</span></span>, turned out more complicated because <span class="extract"><span class="extract-syntax">X</span></span>, defined in another
compilation unit, was a variable holding the address of a function, and not
@ -355,7 +330,7 @@ as expected the name of a specific function.
<p class="commentary">For the implementation, see <a href="../pipeline-module/4-dics.html" class="internal">Detect Indirect Calls Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-labels</span></span>.
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-labels</span></span>.
Performs peephole optimisation on functions to remove all labels which are
declared but can never be jumped to. At the end of this stage, all labels
inside functions are targets of some branch, either by <span class="extract"><span class="extract-syntax">inv !jump</span></span> or in
@ -365,7 +340,7 @@ assembly language.
<p class="commentary">For the implementation, see <a href="../pipeline-module/6-erls.html" class="internal">Eliminate Redundant Labels Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>&#167;13. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-matter</span></span>.
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-matter</span></span>.
Works through the dependency graph of the Inter tree to find packages which
are never needed (such as functions never called), and remove them, thus
making the final executable smaller.
@ -378,7 +353,7 @@ in the built-in <span class="extract"><span class="extract-syntax">compile</span
<p class="commentary">For the implementation, see <a href="../pipeline-module/6-erms.html" class="internal">Eliminate Redundant Matter Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP14" class="paragraph-anchor"></a><b>&#167;14. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-operations</span></span>.
<p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. </b><span class="extract"><span class="extract-syntax">eliminate-redundant-operations</span></span>.
Performs peephole optimisation on functions to remove arithmetic or logical
operations which can be proved to have neither a direct effect nor any
side-effect: for example, performing <span class="extract"><span class="extract-syntax">x + 0</span></span> rather than just evaluating <span class="extract"><span class="extract-syntax">x</span></span>.
@ -387,7 +362,7 @@ side-effect: for example, performing <span class="extract"><span class="extract-
<p class="commentary">For the implementation, see <a href="../pipeline-module/6-eros.html" class="internal">Eliminate Redundant Operations Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP15" class="paragraph-anchor"></a><b>&#167;15. </b><span class="extract"><span class="extract-syntax">generate [FORMAT] -&gt; [DESTINATION]</span></span>.
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>&#167;13. </b><span class="extract"><span class="extract-syntax">generate [FORMAT] -&gt; [DESTINATION]</span></span>.
Produces "final code" in some format, writing it to an external file specified
as the destination. If not given, the format will be the one chosen by the
<a href="../supervisor-module/index.html" class="internal">supervisor</a> module.
@ -407,7 +382,7 @@ make executable programs.
<p class="commentary">For the implementation, see <a href="../final-module/2-cg.html" class="internal">Code Generation (in final)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP16" class="paragraph-anchor"></a><b>&#167;16. </b><span class="extract"><span class="extract-syntax">load-binary-kits</span></span>.
<p class="commentary firstcommentary"><a id="SP14" class="paragraph-anchor"></a><b>&#167;14. </b><span class="extract"><span class="extract-syntax">load-binary-kits</span></span>.
Kits are libraries of Inter code which support the operation of Inform programs
at runtime. When "built" (using <a href="index.html" class="internal">inter</a> with the <span class="extract"><span class="extract-syntax">build-kit</span></span> pipeline), a
kit provides a binary Inter file of code for each possible architecture. This
@ -423,7 +398,7 @@ being run. For Inform compilations, this is handled automatically by the
<p class="commentary">For the implementation, see <a href="../pipeline-module/4-lbks.html" class="internal">Load Binary Kits Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP17" class="paragraph-anchor"></a><b>&#167;17. </b><span class="extract"><span class="extract-syntax">load-kit-source &lt;- [SOURCE]</span></span>.
<p class="commentary firstcommentary"><a id="SP15" class="paragraph-anchor"></a><b>&#167;15. </b><span class="extract"><span class="extract-syntax">load-kit-source &lt;- [SOURCE]</span></span>.
Reads a file of Inform 6-syntax source code and adds the resulting material to
the Inter tree in the form of a series of "splat" nodes, one for each statement
or directive. Those won't be much use as they stand, but see <span class="extract"><span class="extract-syntax">compile-splats</span></span>.
@ -432,7 +407,7 @@ or directive. Those won't be much use as they stand, but see <span class="extrac
<p class="commentary">For the implementation, see <a href="../pipeline-module/3-ps.html" class="internal">Parsing Stages (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>&#167;18. </b><span class="extract"><span class="extract-syntax">make-identifiers-unique</span></span>.
<p class="commentary firstcommentary"><a id="SP16" class="paragraph-anchor"></a><b>&#167;16. </b><span class="extract"><span class="extract-syntax">make-identifiers-unique</span></span>.
Ensures that symbols marked as needing to be unique will be translated, during
any use of <span class="extract"><span class="extract-syntax">generate</span></span>, to identifiers which are all different from each other
across the entire tree. (In effect, this stage is needed because Inter has
@ -447,7 +422,7 @@ where collisions of identifiers would be very unfortunate.)
<p class="commentary">For the implementation, see <a href="../pipeline-module/4-mius.html" class="internal">Make Identifiers Unique Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>&#167;19. </b><span class="extract"><span class="extract-syntax">make-synoptic-module</span></span>.
<p class="commentary firstcommentary"><a id="SP17" class="paragraph-anchor"></a><b>&#167;17. </b><span class="extract"><span class="extract-syntax">make-synoptic-module</span></span>.
The synoptic module is a top-level section of material in the Inter tree which
contains functions and arrays which index or otherwise gather up material
ranging across all other modules. For example, each module originally presents
@ -458,7 +433,7 @@ collates all of those together, sorted and de-duplicated.
<p class="commentary">For the implementation, see <a href="../pipeline-module/5-msms.html" class="internal">Make Synoptic Module Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>&#167;20. </b><span class="extract"><span class="extract-syntax">move &lt;- LOCATION</span></span>.
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>&#167;18. </b><span class="extract"><span class="extract-syntax">move &lt;- LOCATION</span></span>.
This moves a branch of one Inter tree to a position in another one, reconciling
the necessary symbol dependencies. For example, <span class="extract"><span class="extract-syntax">move 1 &lt;- 3:/main/my_fn</span></span>
moves the package <span class="extract"><span class="extract-syntax">/main/my_fn</span></span> in tree 3 to the same position in tree 1.
@ -474,7 +449,7 @@ testing of the so-called "transmigration" process, which powers <span class="ext
<p class="commentary">For the implementation, see <a href="../pipeline-module/2-rmss.html" class="internal">Read, Move, Stop Stages (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP21" class="paragraph-anchor"></a><b>&#167;21. </b><span class="extract"><span class="extract-syntax">new</span></span>.
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>&#167;19. </b><span class="extract"><span class="extract-syntax">new</span></span>.
A completely empty Inter tree is not very useful. <span class="extract"><span class="extract-syntax">new</span></span> adds the very basic
definitions needed, and gives it a <span class="extract"><span class="extract-syntax">/main</span></span> package.
</p>
@ -482,7 +457,7 @@ definitions needed, and gives it a <span class="extract"><span class="extract-sy
<p class="commentary">For the implementation, see <a href="../pipeline-module/2-ns.html" class="internal">New Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>&#167;22. </b><span class="extract"><span class="extract-syntax">optionally-generate [FORMAT] -&gt; DESTINATION</span></span>.
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>&#167;20. </b><span class="extract"><span class="extract-syntax">optionally-generate [FORMAT] -&gt; DESTINATION</span></span>.
This is identical to <span class="extract"><span class="extract-syntax">generate</span></span> except that if the DESTINATION is given as
a variable which does not exist then no error is produced, and nothing is done.
</p>
@ -490,7 +465,7 @@ a variable which does not exist then no error is produced, and nothing is done.
<p class="commentary">For the implementation, see <a href="../final-module/2-cg.html" class="internal">Code Generation (in final)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP23" class="paragraph-anchor"></a><b>&#167;23. </b><span class="extract"><span class="extract-syntax">parse-insertions</span></span>.
<p class="commentary firstcommentary"><a id="SP21" class="paragraph-anchor"></a><b>&#167;21. </b><span class="extract"><span class="extract-syntax">parse-insertions</span></span>.
This looks for <span class="extract"><span class="extract-syntax">INSERT_IST</span></span> nodes in the tree, a small number of which may have
been created by the <a href="../inform7/index.html" class="internal">inform7</a> compiler in response to uses of <span class="extract"><span class="extract-syntax">Include (- ... -)</span></span>.
These can hold arbitrarily long runs of Inform 6-syntax source code, and what
@ -504,7 +479,7 @@ or directive. Those won't be much use as they stand, but see <span class="extrac
<p class="commentary">For the implementation, see <a href="../pipeline-module/3-ps.html" class="internal">Parsing Stages (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24. </b><span class="extract"><span class="extract-syntax">read &lt;- SOURCE</span></span>.
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>&#167;22. </b><span class="extract"><span class="extract-syntax">read &lt;- SOURCE</span></span>.
Copies the contents of the SOURCE file to be the new contents of the tree.
The file must be an Inter file, but can be in either binary or textual format.
</p>
@ -519,7 +494,7 @@ then read it in again.
<p class="commentary">For the implementation, see <a href="../pipeline-module/2-rmss.html" class="internal">Read, Move, Stop Stages (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25. </b><span class="extract"><span class="extract-syntax">reconcile-verbs</span></span>.
<p class="commentary firstcommentary"><a id="SP23" class="paragraph-anchor"></a><b>&#167;23. </b><span class="extract"><span class="extract-syntax">reconcile-verbs</span></span>.
Looks for clashes between any verbs (i.e., command parser imperatives like
PURLOIN or LOOK) which are created in different compilation units. For example,
if the main source text creates a verb called ABSTRACT, which clashes with the
@ -536,7 +511,7 @@ kit-defined one.
<p class="commentary">For the implementation, see <a href="../pipeline-module/4-rvs.html" class="internal">Reconcile Verbs Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26. </b><span class="extract"><span class="extract-syntax">resolve-conditional-compilation</span></span>.
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24. </b><span class="extract"><span class="extract-syntax">resolve-conditional-compilation</span></span>.
Looks for splats arising from Inform 6-syntax conditional compilation directives
such as <span class="extract"><span class="extract-syntax">#ifdef</span></span>, <span class="extract"><span class="extract-syntax">#ifndef</span></span>, <span class="extract"><span class="extract-syntax">#endif</span></span>; it then detects whether the relevant
symbols are defined, or looks at their values, and deletes sections of code not
@ -562,7 +537,7 @@ splats left in the tree. For example:
<p class="commentary">For the implementation, see <a href="../pipeline-module/3-rccs.html" class="internal">Resolve Conditional Compilation Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP27" class="paragraph-anchor"></a><b>&#167;27. </b><span class="extract"><span class="extract-syntax">shorten-wiring</span></span>.
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25. </b><span class="extract"><span class="extract-syntax">shorten-wiring</span></span>.
Wiring is the process by which symbols in one package can refer to definitions
in another one; we say S is wired to T if S in one package refers to the meaning
defined by T is another one. The linking process can result in extended chains
@ -574,7 +549,7 @@ S is wired to T then T is not wired to anything else.
<p class="commentary">For the implementation, see <a href="../pipeline-module/4-sws.html" class="internal">Shorten Wiring Stage (in pipeline)</a>.
</p>
<p class="commentary firstcommentary"><a id="SP28" class="paragraph-anchor"></a><b>&#167;28. </b><span class="extract"><span class="extract-syntax">stop</span></span>.
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26. </b><span class="extract"><span class="extract-syntax">stop</span></span>.
The special stage <span class="extract"><span class="extract-syntax">stop</span></span> halts processing of the pipeline midway. At present
this is only useful for making experimental edits to pipeline descriptions
to see what just the first half does, without deleting the second half of

View file

@ -75,15 +75,16 @@
<span class="plain-syntax">-annotations print out table of all symbol annotations in the Inter language</span>
<span class="plain-syntax">-architecture X generate Inter with architecture X</span>
<span class="plain-syntax">-binary X write to file X in binary format</span>
<span class="plain-syntax">-build-kit X build Inter kit X for the current architecture</span>
<span class="plain-syntax">-constructs print out table of all constructs in the Inter language</span>
<span class="plain-syntax">-domain X specify folder to read/write inter files from/to</span>
<span class="plain-syntax">-format=X code-generate -o output to format X (default is Text)</span>
<span class="plain-syntax">-internal X specify folder of internal Inform resources</span>
<span class="plain-syntax">-o X code-generate to file X</span>
<span class="plain-syntax">-pipeline-file X specify pipeline as file X</span>
<span class="plain-syntax">-pipeline-text X specify pipeline textually, with X being a comma-separated list of stages</span>
<span class="plain-syntax">-primitives print out table of all primitive invocations in the Inter language</span>
<span class="plain-syntax">-textual X write to file X in textual format</span>
<span class="plain-syntax">-trace print out all pipeline steps as they are followed (default is -no-trace)</span>
<span class="plain-syntax">-variable X set pipeline variable X (in form name=value)</span>
<span class="plain-syntax">-at X specify that this tool is installed at X</span>

View file

@ -186,7 +186,7 @@ use semantically meaningful type names like <span class="extract"><span class="e
types are special: <span class="extract"><span class="extract-syntax">_code</span></span>, which as we have seen marks that a package is a
function, and <span class="extract"><span class="extract-syntax">_linkage</span></span>, which is used only for a special package called
<span class="extract"><span class="extract-syntax">connectors</span></span>. Stand-alone programs never contain that package: see
<a href="../bytecode-module/P-wtmd.html" class="internal">What This Module Does (in bytecode)</a> for an explanation of what it is for.
<a href="../bytecode-module/index.html" class="internal">bytecode</a> for an explanation of what it is for.
</p>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. </b><span class="extract"><span class="extract-syntax">primitive !PRIMITIVE SIGNATURE</span></span> declares that a primitive invocation of

View file

@ -12,6 +12,11 @@
<link href="../docs-assets/Navigation.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Fonts.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Base.css" rel="stylesheet" rev="stylesheet" type="text/css">
<script src="http://code.jquery.com/jquery-1.12.4.min.js"
integrity="sha256-ZosEbRLbNQzLpnKIkEdrPv7lOy9C27hHQ+Xp8a4MxAQ=" crossorigin="anonymous"></script>
<script src="../docs-assets/Bigfoot.js"></script>
<link href="../docs-assets/Bigfoot.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
<link href="../docs-assets/ConsoleText-Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
@ -66,24 +71,61 @@
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Compiler Tools</a></li><li><a href="index.html">inter</a></li><li><a href="index.html#M">Manual</a></li><li><b>Using Inter</b></li></ul></div>
<p class="purpose">Using Inter at the command line.</p>
<ul class="toc"><li><a href="M-ui.html#SP1">&#167;1. What Inter does</a></li><li><a href="M-ui.html#SP2">&#167;2. Command-line usage</a></li><li><a href="M-ui.html#SP5">&#167;5. Assimilation</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="M-ui.html#SP1">&#167;1. What Inter does</a></li><li><a href="M-ui.html#SP3">&#167;3. Verify only</a></li><li><a href="M-ui.html#SP4">&#167;4. Format conversion</a></li><li><a href="M-ui.html#SP5">&#167;5. Running a pipeline</a></li><li><a href="M-ui.html#SP9">&#167;9. Assimilation</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. What Inter does. </b>The command-line executable Inter packages up the back end of the Inform 7
compiler into a stand-alone tool, and enables that back end to be used more
flexibly. For example, it can read or write either textual or binary inter
code, and can convert between them. It can also perform any of the numerous
code-generation stages on the code it reads, in any sequence. In short, it
aims to be a Swiss Army knife for inter code.
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. What Inter does. </b>"Inter" is the intermediate representation of a program used in the Inform
compiler toolchain. Most compilers have one of these: for example, Microsoft
compilers mostly use "CIL" (common intermediate language), while <span class="extract"><span class="extract-syntax">gcc</span></span> uses
something called GIMPLE, and so on. See <a href="../bytecode-module/index.html" class="internal">bytecode</a> for a longer discussion
of what motivates the design of Inter.
</p>
<p class="commentary">Because of that, it's possible to test code-generation stages individually:
we can read in some inter code from a text file, perform a single stage on
it, and write it out as text again. This gives us a very helpful window into
what Inform is doing; it also provides a test-bed for future optimisation,
or for future applications of inter code.
<p class="commentary">The practical effect is that the back end of the Inform compiler deals only
with Inter code. This back end exists as part of the executable <a href="../inform7/index.html" class="internal">inform7</a>,
but also as a stand-alone program called <a href="index.html" class="internal">inter</a>, which comes with its
own command-line interface. Whereas <a href="../inform7/index.html" class="internal">inform7</a> has a specific task to perform
and uses Inter code only as a means to an end, <a href="index.html" class="internal">inter</a> is designed to be
as flexible as possible.
</p>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Command-line usage. </b>If you have compiled the standard distribution of the command-line tools
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>Inter code can exist in memory, or in a human-readable text file, or in a
rapid-access binary file. The tool <a href="index.html" class="internal">inter</a> can convert between these formats:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="element-syntax">textual</span><span class="plain-syntax"> </span><span class="element-syntax">textual</span>
<span class="plain-syntax"> </span><span class="element-syntax">inter</span><span class="plain-syntax"> ---+ +---&gt; </span><span class="element-syntax">inter</span>
<span class="plain-syntax"> \ /</span>
<span class="plain-syntax"> \ /</span>
<span class="plain-syntax"> ----&gt; </span><span class="element-syntax">memory</span><span class="plain-syntax"> ----</span>
<span class="plain-syntax"> / </span><span class="element-syntax">inter</span><span class="plain-syntax"> \</span>
<span class="plain-syntax"> </span><span class="element-syntax">binary</span><span class="plain-syntax"> / \ </span><span class="element-syntax">binary</span>
<span class="plain-syntax"> </span><span class="element-syntax">inter</span><span class="plain-syntax"> ---+ +---&gt; </span><span class="element-syntax">inter</span>
</pre>
<p class="commentary">However, Inter can do much more than simply convert between these forms. It
has a "pipeline" design, meaning that it can run memory inter through any
desired series of compilation stages, one at a time:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; </span><span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; </span><span class="element-syntax">T</span><span class="plain-syntax"> --------&gt; ... --------&gt; </span><span class="element-syntax">T</span>
<span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span><span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span><span class="plain-syntax"> </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span><span class="plain-syntax"> ... </span><span class="element-syntax">step</span><span class="plain-syntax"> </span><span class="element-syntax">N</span>
</pre>
<p class="commentary">The Inter tree <span class="extract"><span class="extract-syntax">T</span></span> starts out empty,<sup id="fnref:1"><a href="#fn:1" rel="footnote">1</a></sup> and at the end it is thrown away. So any
useful pipeline will begin by loading something in (usually as step 1), and
end by producing some useful output (usually in its last step or steps).
</p>
<p class="commentary">The advantage of this design is that it enables us to build what amount to
entirely different compilers, just by using different pipelines &mdash; see
"assimilation" below for an example of a pipeline very different to the one
used in normal Inform 7 compilations. Pipelines also allow us to test existing
or proposed code-generation stages individually.
</p>
<ul class="footnotetexts"><li class="footnote" id="fn:1"><p class="inwebfootnote"><sup id="fnref:1"><a href="#fn:1" rel="footnote">1</a></sup> Programs in Inter format are called "Inter trees".
<a href="#fnref:1" title="return to text"> &#x21A9;</a></p></li></ul>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Verify only. </b>If you have compiled the standard distribution of the command-line tools
for Inform then the Inter executable will be at <span class="extract"><span class="extract-syntax">inter/Tangled/inter</span></span>.
</p>
@ -105,66 +147,142 @@ have the filename extension <span class="extract"><span class="ConsoleText-extra
not how Inter decides.)
</p>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. </b>In the second mode, Inter converts from textual to binary form or vice
versa. The option <span class="extract"><span class="ConsoleText-extract-syntax">-binary X</span></span> writes a binary form of the inter to file <span class="extract"><span class="ConsoleText-extract-syntax">X</span></span>,
and <span class="extract"><span class="ConsoleText-extract-syntax">-textual X</span></span> writes a text form. So, for example,
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Format conversion. </b>In the second mode, Inter not only loads (and verifies) the named file, but
then converts it to a different format and writes that out. For example,
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -binary</span><span class="ConsoleText-plain-syntax"> my.interb</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.interb</span><span class="ConsoleText-identifier-syntax"> -format</span><span class="ConsoleText-plain-syntax">=binary</span>
</pre>
<p class="commentary">converts <span class="extract"><span class="ConsoleText-extract-syntax">my.intert</span></span> (a textual inter file) to its binary equivalent
<span class="extract"><span class="ConsoleText-extract-syntax">my.interb</span></span>, and conversely:
<p class="commentary">converts <span class="extract"><span class="ConsoleText-extract-syntax">my.intert</span></span> (a textual inter file) to its binary equivalent <span class="extract"><span class="ConsoleText-extract-syntax">my.interb</span></span>,
and conversely:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.interb</span><span class="ConsoleText-identifier-syntax"> -textual</span><span class="ConsoleText-plain-syntax"> my.intert</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.interb</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -format</span><span class="ConsoleText-plain-syntax">=text</span>
</pre>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. </b>In the third and most flexible mode, Inter runs the supplied code through
a pipeline of processing stages. The pipeline, which must contain at least
one stage, can be quite elaborate (see later), but for example:
<p class="commentary">Two parameters must be specified: <span class="extract"><span class="ConsoleText-extract-syntax">-o</span></span> giving the output file, and <span class="extract"><span class="ConsoleText-extract-syntax">-format=F</span></span>
to say what format <span class="extract"><span class="ConsoleText-extract-syntax">F</span></span> this should have. Formats are in the same notation as
those used by <a href="../inbuild/index.html" class="internal">inbuild</a>, which similarly supports <span class="extract"><span class="ConsoleText-extract-syntax">-o</span></span> and <span class="extract"><span class="ConsoleText-extract-syntax">-format</span></span>.
In fact, <span class="extract"><span class="ConsoleText-extract-syntax">-format=text</span></span> is the default.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> read </span><span class="reserved-syntax">&lt;-</span><span class="plain-syntax"> myfile.inter, resolve-conditional-compilation, generate inform6 </span><span class="reserved-syntax">-&gt;</span><span class="plain-syntax"> myfile.i6</span>
</pre>
<p class="commentary">is a valid three-stage pipeline. The command to do this is then:
<p class="commentary">To take an elaborate example,
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -pipeline-text</span><span class="ConsoleText-plain-syntax"> 'PIPELINE'</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.interb</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -format</span><span class="ConsoleText-plain-syntax">=C/32d/nomain</span>
</pre>
<p class="commentary">where <span class="extract"><span class="ConsoleText-extract-syntax">PIPELINE</span></span> is a textual description like the one above. In practice,
it may not be convenient to spell the pipeline out on the command line, so
one can also put it into a text file:
<p class="commentary">generates a 32-bit-word, debugging-enabled ANSI C program from the Inter tree
in <span class="extract"><span class="ConsoleText-extract-syntax">my.interb</span></span>, with no <span class="extract"><span class="ConsoleText-extract-syntax">main</span></span> function included in it.
</p>
<p class="commentary">As a special case, if <span class="extract"><span class="ConsoleText-extract-syntax">-o</span></span> is given just as <span class="extract"><span class="ConsoleText-extract-syntax">-</span></span>, then the output is printed
to the console rather than to a file.
</p>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Running a pipeline. </b>If we specify <span class="extract"><span class="ConsoleText-extract-syntax">-trace</span></span> as a command-line switch, Inter prints out every step
of the pipeline(s) it is following. This reveals that even the simple commands
above are, in fact, running pipelines, albeit short ones:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -trace</span>
<span class="ConsoleText-plain-syntax"> step 1/1: read &lt;- my.intert</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.interb</span><span class="ConsoleText-identifier-syntax"> -format</span><span class="ConsoleText-plain-syntax">=binary</span><span class="ConsoleText-identifier-syntax"> -trace</span>
<span class="ConsoleText-plain-syntax"> step 1/2: read &lt;- my.intert</span>
<span class="ConsoleText-plain-syntax"> step 2/2: generate binary -&gt; my.interb</span>
</pre>
<p class="commentary">As this shows, a one or two-step pipeline was running:
</p>
<ul class="items"><li>(1) The first step used the <span class="extract"><span class="ConsoleText-extract-syntax">read</span></span> compilation stage, which reads some Inter
code into memory. Here, it comes from the file <span class="extract"><span class="ConsoleText-extract-syntax">my.intert</span></span>.
</li><li>(2) The second step used the <span class="extract"><span class="ConsoleText-extract-syntax">generate</span></span> stage, which writes out Inter code
in the format of one's choice &mdash; here "binary".
</li></ul>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. </b>However, we don't have to use this default pipeline. <span class="extract"><span class="ConsoleText-extract-syntax">-pipeline-text 'PIPELINE'</span></span>
reads in a textual description of the pipeline to follow, with the steps divided
by commas. The examples above used a pipeline which in this notation would
be written as:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> -pipeline-text 'read &lt;- *in, generate -&gt; *out'</span>
</pre>
<p class="commentary"><span class="extract"><span class="ConsoleText-extract-syntax">*in</span></span> and <span class="extract"><span class="ConsoleText-extract-syntax">*out</span></span> are examples of "pipeline variables". <span class="extract"><span class="ConsoleText-extract-syntax">*in</span></span> is the filename
of whatever file is to be read in, and <span class="extract"><span class="ConsoleText-extract-syntax">*out</span></span> is whatever was specified by <span class="extract"><span class="ConsoleText-extract-syntax">-o</span></span>
at the command line, or in other words, the filename to write the output to.
</p>
<p class="commentary">This is not quite the smallest possible pipeline. Consider:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -pipeline-text</span><span class="ConsoleText-plain-syntax"> 'new, generate -&gt; *out'</span><span class="ConsoleText-identifier-syntax"> -trace</span>
<span class="ConsoleText-plain-syntax"> step 1/2: new</span>
<span class="ConsoleText-plain-syntax"> step 2/2: generate text -&gt; my.intert</span>
</pre>
<p class="commentary">Here we didn't specify any Inter file to read in, so <span class="extract"><span class="ConsoleText-extract-syntax">*in</span></span> does not appear.
Instead wevbegan the pipeline with the <span class="extract"><span class="ConsoleText-extract-syntax">new</span></span> compilation stage, which creates
a minimal Inter program from nothing.
</p>
<p class="commentary">Even three-step pipelines can be very useful. For example:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -o</span><span class="ConsoleText-plain-syntax"> my.intert</span><span class="ConsoleText-identifier-syntax"> -pipeline-text</span><span class="ConsoleText-plain-syntax"> 'read &lt;- *in, eliminate-redundant-labels, generate -&gt; *out'</span><span class="ConsoleText-identifier-syntax"> -trace</span>
<span class="ConsoleText-plain-syntax"> step 1/3: read &lt;- my.intert</span>
<span class="ConsoleText-plain-syntax"> step 2/3: eliminate-redundant-labels</span>
<span class="ConsoleText-plain-syntax"> step 3/3: generate text -&gt; my.intert</span>
</pre>
<p class="commentary">This could be used to test that the <span class="extract"><span class="ConsoleText-extract-syntax">eliminate-redundant-labels</span></span> compilation
stage is working as it should. We can feed our choice of Inter code into it,
and examine its direct output, in isolation from the working of the rest of
the compiler (and, of course, more quickly).
</p>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. </b>In practice, it becomes cumbersome to spell the pipeline out longhand on
the command line, so we can also put it into a text file:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -pipeline-file</span><span class="ConsoleText-plain-syntax"> mypl.interpipeline</span>
</pre>
<p class="commentary">Pipelines can contain variables, and their values can be set at the command
line with e.g.:
<p class="commentary">It's not allowed to specify both <span class="extract"><span class="ConsoleText-extract-syntax">-pipeline-file</span></span> and <span class="extract"><span class="ConsoleText-extract-syntax">-pipeline-text</span></span>.
The text file, however, specifies pipelines with one step on each line, not
using commas. So <span class="extract"><span class="ConsoleText-extract-syntax">-pipeline-text 'read &lt;- *in, eliminate-redundant-labels, generate -&gt; *out'</span></span>
is equivalent to <span class="extract"><span class="ConsoleText-extract-syntax">-pipeline-file</span></span> with the file:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> -variable '*out=myfile.i6'</span>
<span class="plain-syntax">read &lt;- *in</span>
<span class="plain-syntax">eliminate-redundant-labels</span>
<span class="plain-syntax">generate -&gt; *out</span>
</pre>
<p class="commentary">It is also possible to set the default directory for reading and writing files:
<p class="commentary">For more on how to write and use pipeline files, see <a href="M-pas.html" class="internal">Pipelines and Stages</a>.
</p>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. </b>In general, filenames follow the usual Unix conventions: they are taken as
relative to the current working directory, unless given as absolute filenames
beginning with <span class="extract"><span class="extract-syntax">/</span></span>. But we can also set a "default directory" to take the
place of the CWD, using <span class="extract"><span class="extract-syntax">-domain</span></span>:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> -domain D</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Assimilation. </b>Inform makes use of what are called "kits" of pre-compiled Inter code:
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Assimilation. </b>Inform makes use of what are called "kits" of pre-compiled Inter code:
for example, <span class="extract"><span class="extract-syntax">CommandParserKit</span></span> contains code for the traditional interactive
fiction command parser. For speed, Inter loads these as binary Inter, but
that means they have to be compiled from time to time. This is called
"assimilation".
fiction command parser. That pre-compilation is called "assimilation", and
is performed by the <a href="index.html" class="internal">inter</a> tool alone: it does not require, or use, the
bulk of the <a href="../inform7/index.html" class="internal">inform7</a> compiler.
</p>
<p class="commentary">The source code for these could in priniple be textual Inter, but that's too
<p class="commentary">The source code for a kit could in principle be textual Inter, but that's too
verbose to write comfortably. In practice we use Inform 6 code as a notation,
and therefore assimilation is really a cross-compilation from I6 to Inter.
and therefore assimilation is really compilation from I6 to Inter.
</p>
<p class="commentary">Kits are like so-called "fat binaries", in that they contain binary Inter
@ -174,9 +292,14 @@ which is wanted. For example:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -architecture</span><span class="ConsoleText-plain-syntax"> 16</span><span class="ConsoleText-identifier-syntax"> -build-kit</span><span class="ConsoleText-plain-syntax"> K</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -architecture</span><span class="ConsoleText-plain-syntax"> 32d</span><span class="ConsoleText-identifier-syntax"> -build-kit</span><span class="ConsoleText-plain-syntax"> K</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -architecture</span><span class="ConsoleText-plain-syntax"> 16</span><span class="ConsoleText-identifier-syntax"> -build-kit</span><span class="ConsoleText-plain-syntax"> inform7/Internal/Inter/BasicInformKit</span>
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inter/Tangled/inter</span><span class="ConsoleText-identifier-syntax"> -architecture</span><span class="ConsoleText-plain-syntax"> 32d</span><span class="ConsoleText-identifier-syntax"> -build-kit</span><span class="ConsoleText-plain-syntax"> inform7/Internal/Inter/BasicInformKit</span>
</pre>
<p class="commentary">At present there are four architectures: <span class="extract"><span class="ConsoleText-extract-syntax">16</span></span>, <span class="extract"><span class="ConsoleText-extract-syntax">16d</span></span>, <span class="extract"><span class="ConsoleText-extract-syntax">32</span></span> and <span class="extract"><span class="ConsoleText-extract-syntax">32d</span></span>.
Note that an architecture is not the same thing as a format: it specifies
only the word size (16 or 32 bit) and the presence, or not, of debugging data.
</p>
<p class="commentary">Incrementally building kits as needed could be done with something like
the Unix tool <span class="extract"><span class="ConsoleText-extract-syntax">make</span></span>, but in fact Inbuild has this ability: the command
</p>
@ -184,7 +307,7 @@ the Unix tool <span class="extract"><span class="ConsoleText-extract-syntax">mak
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inbuild/Tangled/inbuild</span><span class="ConsoleText-identifier-syntax"> -build</span><span class="ConsoleText-plain-syntax"> K</span>
</pre>
<p class="commentary">looks at the kit, works out which architectures need rebuilding, and
<p class="commentary">looks at the kit <span class="extract"><span class="ConsoleText-extract-syntax">K</span></span>, works out which architectures need rebuilding, and
then issues commands like the above to instruct <span class="extract"><span class="ConsoleText-extract-syntax">inter</span></span> to do so. Indeed,
multiple kits can be managed with a single command:
</p>
@ -192,6 +315,23 @@ multiple kits can be managed with a single command:
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-element-syntax">$</span><span class="ConsoleText-plain-syntax"> </span><span class="ConsoleText-function-syntax">inbuild/Tangled/inbuild</span><span class="ConsoleText-identifier-syntax"> -build -contents-of</span><span class="ConsoleText-plain-syntax"> inform7/Internal/Inter</span>
</pre>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. </b>Under the hood, assimilation is just another use of pipeline processing. If we
run one of these <span class="extract"><span class="ConsoleText-extract-syntax">-build-kit</span></span> commands with <span class="extract"><span class="ConsoleText-extract-syntax">-trace</span></span> switched on, we see
something like this:
</p>
<pre class="ConsoleText-displayed-code all-displayed-code code-font">
<span class="ConsoleText-plain-syntax">step 1/6: new</span>
<span class="ConsoleText-plain-syntax">step 2/6: load-kit-source &lt;- BasicInformKit</span>
<span class="ConsoleText-plain-syntax">step 3/6: parse-insertions</span>
<span class="ConsoleText-plain-syntax">step 4/6: resolve-conditional-compilation</span>
<span class="ConsoleText-plain-syntax">step 5/6: compile-splats</span>
<span class="ConsoleText-plain-syntax">step 6/6: generate binary -&gt; inform7/Internal/Inter/BasicInformKit/arch-32.interb</span>
</pre>
<p class="commentary">This is in fact the result of running a pipeline file called <span class="extract"><span class="ConsoleText-extract-syntax">build-kit.interpipeline</span></span>
which is included in the standard Inter distribution.
</p>
<nav role="progress"><div class="progresscontainer">
<ul class="progressbar"><li class="progressprevoff">&#10094;</li><li class="progresscurrentchapter">M</li><li class="progresscurrent">ui</li><li class="progresssection"><a href="M-ti.html">ti</a></li><li class="progresssection"><a href="M-dpiti.html">dpiti</a></li><li class="progresssection"><a href="M-cpiti.html">cpiti</a></li><li class="progresssection"><a href="M-ip.html">ip</a></li><li class="progresssection"><a href="M-ia.html">ia</a></li><li class="progresssection"><a href="M-io.html">io</a></li><li class="progresssection"><a href="M-pas.html">pas</a></li><li class="progresssection"><a href="M-rc.html">rc</a></li><li class="progresschapter"><a href="1-mn.html">1</a></li><li class="progressnext"><a href="M-ti.html">&#10095;</a></li></ul></div>
</nav><!--End of weave-->

View file

@ -139,7 +139,7 @@ steps in turn, timing how long each one took us.
<span class="reserved-syntax">pipeline_step</span><span class="plain-syntax"> *</span><span class="identifier-syntax">currently_running_pipeline_step</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">RunningPipelines::run</span><span class="plain-syntax">(</span><span class="identifier-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="reserved-syntax">inter_pipeline</span><span class="plain-syntax"> *</span><span class="identifier-syntax">S</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_tree</span><span class="plain-syntax"> *</span><span class="identifier-syntax">I</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">the_kit</span><span class="plain-syntax">, </span><span class="identifier-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">target_vm</span><span class="plain-syntax"> *</span><span class="identifier-syntax">VM</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">the_kit</span><span class="plain-syntax">, </span><span class="identifier-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">target_vm</span><span class="plain-syntax"> *</span><span class="identifier-syntax">VM</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tracing</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">S</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">I</span><span class="plain-syntax">) </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ephemera</span><span class="plain-syntax">.</span><span class="element-syntax">memory_repository</span><span class="plain-syntax"> = </span><span class="identifier-syntax">I</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">stopwatch_timer</span><span class="plain-syntax"> *</span><span class="identifier-syntax">within</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
@ -170,9 +170,10 @@ steps in turn, timing how long each one took us.
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="2-rp.html#SP3_1_1" class="named-paragraph-link"><span class="named-paragraph">Prepare ephemeral data for this step</span><span class="named-paragraph-number">3.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Time::stop_stopwatch</span><span class="plain-syntax">(</span><span class="identifier-syntax">prep_timer</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">, </span><span class="string-syntax">"inter step %d/%d: "</span><span class="plain-syntax">, ++</span><span class="identifier-syntax">step_count</span><span class="plain-syntax">, </span><span class="identifier-syntax">step_total</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">, </span><span class="string-syntax">"step %d/%d: "</span><span class="plain-syntax">, ++</span><span class="identifier-syntax">step_count</span><span class="plain-syntax">, </span><span class="identifier-syntax">step_total</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-pp.html#SP12" class="function-link"><span class="function-syntax">ParsingPipelines::write_step</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">, </span><span class="identifier-syntax">step</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::new_stage</span><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">tracing</span><span class="plain-syntax">) </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">STDOUT</span><span class="plain-syntax">, </span><span class="string-syntax">"%S\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">stopwatch_timer</span><span class="plain-syntax"> *</span><span class="identifier-syntax">step_timer</span><span class="plain-syntax"> =</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Time::start_stopwatch</span><span class="plain-syntax">(</span><span class="identifier-syntax">pipeline_timer</span><span class="plain-syntax">, </span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">STAGE_NAME</span><span class="plain-syntax">)</span>
@ -234,6 +235,9 @@ steps in turn, timing how long each one took us.
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">step</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">step_argument</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"*log"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">step</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ephemera</span><span class="plain-syntax">.</span><span class="element-syntax">to_stream</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="2-rp.html#SP3_1_2_2" class="named-paragraph-link"><span class="named-paragraph">Call the stage execution function</span><span class="named-paragraph-number">3.1.2.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">step</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">step_argument</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"-"</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">step</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">ephemera</span><span class="plain-syntax">.</span><span class="element-syntax">to_stream</span><span class="plain-syntax"> = </span><span class="identifier-syntax">STDOUT</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="2-rp.html#SP3_1_2_2" class="named-paragraph-link"><span class="named-paragraph">Call the stage execution function</span><span class="named-paragraph-number">3.1.2.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="2-rp.html#SP3_1_2_1" class="named-paragraph-link"><span class="named-paragraph">Work out the filename</span><span class="named-paragraph-number">3.1.2.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> </span><span class="identifier-syntax">text_output_struct</span><span class="plain-syntax">;</span>
@ -295,7 +299,7 @@ whichever comes first.
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="identifier-syntax">active</span><span class="plain-syntax"> = (*(</span><span class="identifier-syntax">step</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">step_stage</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">execute</span><span class="plain-syntax">))(</span><span class="identifier-syntax">step</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="2-rp.html#SP3_1_2">&#167;3.1.2</a> (four times).</li></ul>
<ul class="endnotetexts"><li>This code is used in <a href="2-rp.html#SP3_1_2">&#167;3.1.2</a> (five times).</li></ul>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. </b>In an ideal world, we would not track this in a global variable, but it is
not simple to remove the need for this (though, at the same time, it is needed
very little in practice, and never when this code runs in Inform 7).

View file

@ -194,7 +194,7 @@ better way to choose a virtual machine to compile to.
<span class="plain-syntax"> </span><span class="identifier-syntax">CommandLine::declare_boolean_switch</span><span class="plain-syntax">(</span><span class="constant-syntax">RELEASE_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"release"</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"compile a version suitable for a Release build"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">CommandLine::declare_textual_switch</span><span class="plain-syntax">(</span><span class="constant-syntax">FORMAT_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"format"</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"compile I6 code suitable for the virtual machine X"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"compile to the format X (default is Inform6/32)"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">CommandLine::declare_switch</span><span class="plain-syntax">(</span><span class="constant-syntax">SOURCE_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"source"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="string-syntax">"use file X as the Inform source text"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">CommandLine::declare_switch</span><span class="plain-syntax">(</span><span class="constant-syntax">O_CLSW</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"o"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">,</span>
@ -270,7 +270,7 @@ set appropriately.
<span class="identifier-syntax">pathname</span><span class="plain-syntax"> *</span><span class="identifier-syntax">shared_transient_resources</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">this_is_a_debug_compile</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; </span><span class="comment-syntax"> Destined to be compiled with debug features</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">this_is_a_release_compile</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; </span><span class="comment-syntax"> Omit sections of source text marked not for release</span>
<span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">story_filename_extension</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="comment-syntax"> What story file we will eventually have</span>
<span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">output_format</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="comment-syntax"> What story file we will eventually have</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">census_mode</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; </span><span class="comment-syntax"> Running only to update extension documentation</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">rng_seed_at_start_of_play</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="comment-syntax"> The seed value, or 0 if not seeded</span>
@ -309,7 +309,7 @@ it doesn't know about, that will be one of ours, so it should call the following
<span class="plain-syntax"> </span><span class="identifier-syntax">RUN_ONLY_IN_PHASE</span><span class="plain-syntax">(</span><span class="constant-syntax">CONFIGURATION_INBUILD_PHASE</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">id</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DEBUG_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">this_is_a_debug_compile</span><span class="plain-syntax"> = </span><span class="identifier-syntax">val</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">FORMAT_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">story_filename_extension</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::duplicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">FORMAT_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">output_format</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::duplicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">RELEASE_CLSW:</span><span class="plain-syntax"> </span><span class="identifier-syntax">this_is_a_release_compile</span><span class="plain-syntax"> = </span><span class="identifier-syntax">val</span><span class="plain-syntax">; </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEST_CLSW:</span>
<span class="plain-syntax"> </span><a href="1-ic.html#SP12" class="function-link"><span class="function-syntax">Supervisor::add_nest</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Pathnames::from_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">), </span><span class="constant-syntax">GENERIC_NEST_TAG</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
@ -424,7 +424,7 @@ line, which is why we couldn't work this out earlier:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ext</span><span class="plain-syntax"> = </span><span class="identifier-syntax">story_filename_extension</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ext</span><span class="plain-syntax"> = </span><span class="identifier-syntax">output_format</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">with_debugging</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">this_is_a_release_compile</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">this_is_a_debug_compile</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">with_debugging</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>

View file

@ -154,7 +154,7 @@ should be, so the effect is the same.
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">SS</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">linked_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NEW_LINKED_LIST</span><span class="plain-syntax">(</span><span class="identifier-syntax">attachment_instruction</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">RunningPipelines::run</span><span class="plain-syntax">(</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">SS</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">associated_copy</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">location_if_path</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">for_vm</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">requirements_list</span><span class="plain-syntax">, </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">for_vm</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Errors::nowhere</span><span class="plain-syntax">(</span><span class="string-syntax">"build-kit pipeline could not be parsed"</span><span class="plain-syntax">);</span>
@ -216,7 +216,7 @@ it defaults to <span class="extract"><span class="extract-syntax">compile</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">RunningPipelines::run</span><span class="plain-syntax">(</span><span class="identifier-syntax">Filenames::up</span><span class="plain-syntax">(</span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">vertex</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">as_file</span><span class="plain-syntax">), </span><span class="identifier-syntax">pipeline</span><span class="plain-syntax">, </span><span class="identifier-syntax">Emit::tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><a href="5-ps2.html#SP24" class="function-link"><span class="function-syntax">Projects::list_of_attachment_instructions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">project</span><span class="plain-syntax">), </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">for_vm</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="5-ps2.html#SP24" class="function-link"><span class="function-syntax">Projects::list_of_attachment_instructions</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">project</span><span class="plain-syntax">), </span><span class="identifier-syntax">S</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">for_vm</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Back end elapsed time: %dcs\n"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> ((</span><span class="reserved-syntax">int</span><span class="plain-syntax">) (</span><span class="identifier-syntax">clock</span><span class="plain-syntax">() - </span><span class="identifier-syntax">back_end</span><span class="plain-syntax">)) / (</span><span class="identifier-syntax">CLOCKS_PER_SEC</span><span class="plain-syntax">/100));</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">CORE_MODULE</span>

View file

@ -116,7 +116,7 @@ better way to choose a virtual machine to compile to.
CommandLine::declare_boolean_switch(RELEASE_CLSW, L"release", 1,
L"compile a version suitable for a Release build", FALSE);
CommandLine::declare_textual_switch(FORMAT_CLSW, L"format", 1,
L"compile I6 code suitable for the virtual machine X");
L"compile to the format X (default is Inform6/32)");
CommandLine::declare_switch(SOURCE_CLSW, L"source", 2,
L"use file X as the Inform source text");
CommandLine::declare_switch(O_CLSW, L"o", 2,
@ -182,7 +182,7 @@ dictionary *pipeline_vars = NULL;
pathname *shared_transient_resources = NULL;
int this_is_a_debug_compile = FALSE; /* Destined to be compiled with debug features */
int this_is_a_release_compile = FALSE; /* Omit sections of source text marked not for release */
text_stream *story_filename_extension = NULL; /* What story file we will eventually have */
text_stream *output_format = NULL; /* What story file we will eventually have */
int census_mode = FALSE; /* Running only to update extension documentation */
int rng_seed_at_start_of_play = 0; /* The seed value, or 0 if not seeded */
@ -217,7 +217,7 @@ void Supervisor::option(int id, int val, text_stream *arg, void *state) {
RUN_ONLY_IN_PHASE(CONFIGURATION_INBUILD_PHASE)
switch (id) {
case DEBUG_CLSW: this_is_a_debug_compile = val; break;
case FORMAT_CLSW: story_filename_extension = Str::duplicate(arg); break;
case FORMAT_CLSW: output_format = Str::duplicate(arg); break;
case RELEASE_CLSW: this_is_a_release_compile = val; break;
case NEST_CLSW:
Supervisor::add_nest(Pathnames::from_text(arg), GENERIC_NEST_TAG); break;
@ -316,7 +316,7 @@ void Supervisor::optioneering_complete(inbuild_copy *C, int compile_only,
line, which is why we couldn't work this out earlier:
@<Find the virtual machine@> =
text_stream *ext = story_filename_extension;
text_stream *ext = output_format;
int with_debugging = FALSE;
if ((this_is_a_release_compile == FALSE) || (this_is_a_debug_compile))
with_debugging = TRUE;

View file

@ -80,7 +80,7 @@ int InterSkill::build_kit_internally(build_skill *skill, build_step *S,
if (SS) {
linked_list *requirements_list = NEW_LINKED_LIST(attachment_instruction);
RunningPipelines::run(NULL, SS, NULL, S->associated_copy->location_if_path,
requirements_list, S->for_vm);
requirements_list, S->for_vm, FALSE);
return TRUE;
} else {
Errors::nowhere("build-kit pipeline could not be parsed");
@ -141,7 +141,7 @@ int InterSkill::code_generate_internally(build_skill *skill, build_step *S,
return FALSE;
}
RunningPipelines::run(Filenames::up(S->vertex->as_file), pipeline, Emit::tree(), NULL,
Projects::list_of_attachment_instructions(project), S->for_vm);
Projects::list_of_attachment_instructions(project), S->for_vm, FALSE);
LOG("Back end elapsed time: %dcs\n",
((int) (clock() - back_end)) / (CLOCKS_PER_SEC/100));
#ifdef CORE_MODULE

View file

@ -1,10 +1,10 @@
Total memory consumption was 379100K = 370 MB
Total memory consumption was 379106K = 370 MB
66.6% was used for 2005764 objects, in 360735 frames in 316 x 800K = 252800K = 246 MB:
66.6% was used for 2005888 objects, in 360760 frames in 316 x 800K = 252800K = 246 MB:
10.7% inter_tree_node_array 58 x 8192 = 475136 objects, 41813824 bytes
6.2% text_stream_array 4340 x 100 = 434000 objects, 24442880 bytes
6.2% linked_list 43264 objects, 24227840 bytes
6.2% text_stream_array 4341 x 100 = 434100 objects, 24448512 bytes
6.2% linked_list 43276 objects, 24234560 bytes
3.6% inter_symbol_array 132 x 1024 = 135168 objects, 14061696 bytes
3.4% inter_error_stash_array 101 x 1024 = 103424 objects, 13241504 bytes
2.6% parse_node 129462 objects, 10356960 bytes
@ -106,8 +106,8 @@ Total memory consumption was 379100K = 370 MB
---- parse_node_tree 20 objects, 17280 bytes
---- understanding_reference_array 2 x 100 = 200 objects, 16064 bytes
---- to_phrase_request 59 objects, 16048 bytes
---- action_name_list_array 1 x 1000 objects, 16032 bytes
---- match_avinue_array 1 x 1000 objects, 16032 bytes
---- action_name_list_array 1 x 1000 objects, 16032 bytes
---- adjective 137 objects, 15344 bytes
---- generated_segment 14 objects, 14784 bytes
---- booking_list 407 objects, 13024 bytes
@ -144,9 +144,10 @@ Total memory consumption was 379100K = 370 MB
---- definition 44 objects, 3168 bytes
---- semver_range 29 objects, 3016 bytes
---- either_or_property_data 62 objects, 2976 bytes
---- target_vm 20 objects, 2880 bytes
---- use_option 29 objects, 2552 bytes
---- parentage_inference_data 79 objects, 2528 bytes
---- part_of_inference_data 79 objects, 2528 bytes
---- parentage_inference_data 79 objects, 2528 bytes
---- kind_constructor_instance_array 1 x 100 objects, 2432 bytes
---- kind_constructor_casting_rule_array 1 x 100 objects, 2432 bytes
---- equation_symbol 30 objects, 2400 bytes
@ -163,7 +164,6 @@ Total memory consumption was 379100K = 370 MB
---- table_column 16 objects, 1280 bytes
---- invocation_options_array 1 x 100 objects, 1224 bytes
---- direction_inference_data 30 objects, 1200 bytes
---- target_vm 8 objects, 1152 bytes
---- tree_inventory_item 28 objects, 1120 bytes
---- runtime_kind_structure 13 objects, 1040 bytes
---- quantifier 16 objects, 1024 bytes
@ -188,22 +188,22 @@ Total memory consumption was 379100K = 370 MB
---- i6_memory_setting 14 objects, 448 bytes
---- inference_family 11 objects, 440 bytes
---- inter_annotation_form 10 objects, 400 bytes
---- article_usage 8 objects, 384 bytes
---- bp_family 12 objects, 384 bytes
---- article_usage 8 objects, 384 bytes
---- source_file 5 objects, 360 bytes
---- inbuild_genre 7 objects, 336 bytes
---- grammatical_category 8 objects, 320 bytes
---- module_request 8 objects, 320 bytes
---- door_dir_notice 5 objects, 320 bytes
---- cached_kind_declaration 8 objects, 320 bytes
---- pronoun 8 objects, 320 bytes
---- grammatical_category 8 objects, 320 bytes
---- module_request 8 objects, 320 bytes
---- tree_inventory 1 object, 312 bytes
---- up_family 9 objects, 288 bytes
---- build_step 4 objects, 288 bytes
---- compilation_unit 5 objects, 280 bytes
---- contents_entry 7 objects, 280 bytes
---- explicit_bp_data 5 objects, 280 bytes
---- door_to_notice 5 objects, 280 bytes
---- contents_entry 7 objects, 280 bytes
---- compilation_unit 5 objects, 280 bytes
---- verb_usage_tier 5 objects, 240 bytes
---- inter_pipeline 1 object, 232 bytes
---- adjective_meaning_family 7 objects, 224 bytes
@ -211,13 +211,13 @@ Total memory consumption was 379100K = 370 MB
---- release_instructions 1 object, 208 bytes
---- build_skill 5 objects, 200 bytes
---- code_generator 5 objects, 200 bytes
---- plural_dictionary_entry 4 objects, 192 bytes
---- kit_dependency 4 objects, 192 bytes
---- inform_project 1 object, 192 bytes
---- plural_dictionary_entry 4 objects, 192 bytes
---- attachment_instruction 4 objects, 160 bytes
---- inter_architecture 4 objects, 160 bytes
---- inference_subject_family 5 objects, 160 bytes
---- imperative_defn_family 4 objects, 160 bytes
---- inference_subject_family 5 objects, 160 bytes
---- attachment_instruction 4 objects, 160 bytes
---- element_activation 4 objects, 128 bytes
---- inbuild_nest 3 objects, 120 bytes
---- local_block_value 2 objects, 112 bytes
@ -225,19 +225,19 @@ Total memory consumption was 379100K = 370 MB
---- compile_task_data 1 object, 80 bytes
---- article 2 objects, 80 bytes
---- group_together_function 2 objects, 80 bytes
---- build_methodology 1 object, 56 bytes
---- figures_data 1 object, 56 bytes
---- inter_warehouse 1 object, 56 bytes
---- build_methodology 1 object, 56 bytes
---- star_invention 1 object, 48 bytes
---- HTML_file_state 1 object, 48 bytes
---- I6_generation_data 1 object, 40 bytes
---- by_function_bp_data 1 object, 40 bytes
---- kind_template_definition 1 object, 40 bytes
---- loop_over_scope 1 object, 40 bytes
---- by_function_bp_data 1 object, 40 bytes
33.3% was used for memory not allocated for objects:
19.7% text stream storage 76619108 bytes in 452033 claims
19.7% text stream storage 76625232 bytes in 452123 claims
1.1% dictionary storage 4544512 bytes in 6619 claims
---- sorting 744 bytes in 3 claims
1.8% source text 7200000 bytes in 3 claims
@ -246,7 +246,7 @@ Total memory consumption was 379100K = 370 MB
---- linguistic stock array 81920 bytes in 2 claims
---- small word set array 105600 bytes in 22 claims
1.1% inter symbols storage 4521792 bytes in 27920 claims
4.3% inter bytecode storage 16767748 bytes in 14 claims
4.3% inter bytecode storage 16767756 bytes in 14 claims
1.6% inter links storage 6222976 bytes in 11 claims
---- inter tree location list storage 191232 bytes in 32 claims
0.4% instance-of-kind counting 1695204 bytes in 1 claim
@ -255,5 +255,5 @@ Total memory consumption was 379100K = 370 MB
---- code generation workspace for objects 1336 bytes in 4 claims
---- emitter array storage 279776 bytes in 1995 claims
19.8% was overhead - 77076304 bytes = 75269K = 73 MB
19.8% was overhead - 77062224 bytes = 75256K = 73 MB

View file

@ -1,34 +1,33 @@
100.0% in inform7 run
69.0% in compilation to Inter
48.1% in //Sequence::undertake_queued_tasks//
48.3% in //Sequence::undertake_queued_tasks//
4.6% in //MajorNodes::pre_pass//
3.5% in //MajorNodes::pass_1//
2.3% in //RTPhrasebook::compile_entries//
2.4% in //RTPhrasebook::compile_entries//
1.8% in //ImperativeDefinitions::assess_all//
1.4% in //RTKindConstructors::compile//
0.9% in //Sequence::lint_inter//
0.5% in //ImperativeDefinitions::compile_first_block//
0.5% in //MajorNodes::pass_2//
0.5% in //Sequence::undertake_queued_tasks//
0.5% in //World::stage_V//
0.3% in //ImperativeDefinitions::compile_first_block//
0.3% in //Sequence::undertake_queued_tasks//
0.1% in //CompletionModule::compile//
0.1% in //InferenceSubjects::emit_all//
0.1% in //RTKindConstructors::compile_permissions//
0.1% in //Task::make_built_in_kind_constructors//
0.1% in //World::stages_II_and_III//
2.6% not specifically accounted for
28.4% in running Inter pipeline
10.1% in inter step 14/14: generate inform6 -> auto.inf
7.3% in inter step 5/14: load-binary-kits
6.2% in inter step 6/14: make-synoptic-module
1.4% in inter step 9/14: make-identifiers-unique
0.3% in inter step 12/14: eliminate-redundant-operations
0.3% in inter step 4/14: compile-splats
0.3% in inter step 7/14: shorten-wiring
0.3% in inter step 8/14: detect-indirect-calls
0.1% in inter step 10/14: reconcile-verbs
0.1% in inter step 11/14: eliminate-redundant-labels
1.3% not specifically accounted for
2.4% not specifically accounted for
28.1% in running Inter pipeline
10.0% in step 14/14: generate inform6 -> auto.inf
7.4% in step 5/14: load-binary-kits
6.3% in step 6/14: make-synoptic-module
1.4% in step 9/14: make-identifiers-unique
0.3% in step 12/14: eliminate-redundant-operations
0.3% in step 4/14: compile-splats
0.3% in step 7/14: shorten-wiring
0.3% in step 8/14: detect-indirect-calls
0.1% in step 11/14: eliminate-redundant-labels
1.1% not specifically accounted for
2.2% in supervisor
0.4% not specifically accounted for
0.6% not specifically accounted for

View file

@ -12,12 +12,13 @@ pathname *path_to_inter = NULL;
pathname *kit_to_build = NULL;
pathname *domain_path = NULL;
linked_list *inter_file_list = NULL; /* of |filename| */
filename *output_textually = NULL;
filename *output_binarily = NULL;
filename *output_file = NULL;
dictionary *pipeline_vars = NULL;
filename *pipeline_as_file = NULL;
text_stream *pipeline_as_text = NULL;
pathname *internal_path = NULL;
text_stream *output_format = NULL; /* for any |-o| output */
int tracing = FALSE;
void Main::add_pipeline_variable(text_stream *name, text_stream *value) {
Str::copy(Dictionaries::create_text(pipeline_vars, name), value);
@ -43,11 +44,8 @@ int main(int argc, char **argv) {
@<Start up the modules@>;
@<Begin with an empty file list and variables dictionary@>;
@<Read the command line@>;
if (kit_to_build) @<Set up a pipeline for kit-building@>;
if ((pipeline_as_file) || (pipeline_as_text))
@<Run the pipeline@>
else
@<Read the list of inter files, and perhaps transcode them@>;
if (kit_to_build) @<Select the build-kit pipeline@>;
@<Run the pipeline@>;
@<Shut down the modules@>;
if (Errors::have_occurred()) return 1;
return 0;
@ -67,12 +65,7 @@ int main(int argc, char **argv) {
pipeline_vars = ParsingPipelines::basic_dictionary(I"output.i6");
internal_path = Pathnames::from_text(I"inform7/Internal");
@ This pipeline is supplied built in to the installation of |inter|. In fact,
it only ever writes the binary form of the code it produces, so only |*out|
is used. But at times in the past it has been useful to debug with the text
form, which would be written to |*outt|.
@<Set up a pipeline for kit-building@> =
@<Select the build-kit pipeline@> =
inter_architecture *A = PipelineModule::get_architecture();
if (A == NULL) Errors::fatal("no -architecture given");
@ -84,41 +77,48 @@ form, which would be written to |*outt|.
Pathnames::directory_name(kit_to_build));
Main::add_pipeline_variable_from_filename(I"*out",
Architectures::canonical_binary(kit_to_build, A));
Main::add_pipeline_variable_from_filename(I"*outt",
Architectures::canonical_textual(kit_to_build, A));
@<Run the pipeline@> =
if (LinkedLists::len(inter_file_list) > 0)
Errors::fatal("-pipeline-text and -pipeline-file cannot be combined with inter files");
if ((pipeline_as_file) && (pipeline_as_text))
Errors::fatal("-pipeline-text and -pipeline-file are mutually exclusive");
inter_pipeline *SS;
if (pipeline_as_file)
SS = ParsingPipelines::from_file(pipeline_as_file, pipeline_vars, NULL);
else
SS = ParsingPipelines::from_text(pipeline_as_text, pipeline_vars);
linked_list *requirements_list = NEW_LINKED_LIST(attachment_instruction);
if (SS) RunningPipelines::run(domain_path, SS, NULL, kit_to_build, requirements_list, NULL);
else Errors::fatal("pipeline could not be parsed");
if (Str::len(output_format) == 0) output_format = I"Text";
target_vm *VM = TargetVMs::find(output_format);
if (VM == NULL) Errors::fatal("unrecognised compilation -format");
PipelineModule::set_architecture(
Architectures::to_codename(TargetVMs::get_architecture(VM)));
@<Read the list of inter files, and perhaps transcode them@> =
inter_tree *I = InterTree::new();
filename *F;
LOOP_OVER_LINKED_LIST(F, filename, inter_file_list) {
if (BinaryInter::test_file(F))
BinaryInter::read(I, F);
else
TextualInter::read(I, F);
if (LinkedLists::len(inter_file_list) > 0) {
if (LinkedLists::len(inter_file_list) > 1)
Errors::fatal("only one file of Inter can be supplied");
filename *F;
LOOP_OVER_LINKED_LIST(F, filename, inter_file_list)
Main::add_pipeline_variable_from_filename(I"*in", F);
}
if (output_textually) {
text_stream C_struct; text_stream *OUT = &C_struct;
if (STREAM_OPEN_TO_FILE(OUT, output_textually, UTF8_ENC) == FALSE)
Errors::fatal_with_file("unable to open textual inter file for output: %f",
output_textually);
TextualInter::write(OUT, I, NULL);
STREAM_CLOSE(OUT);
if (output_file) {
Main::add_pipeline_variable_from_filename(I"*out", output_file);
}
inter_pipeline *SS = NULL;
@<Compile the pipeline@>;
if (SS) {
linked_list *req_list = NEW_LINKED_LIST(attachment_instruction);
RunningPipelines::run(domain_path, SS, I, kit_to_build, req_list, VM, tracing);
}
@<Compile the pipeline@> =
if (pipeline_as_file) {
SS = ParsingPipelines::from_file(pipeline_as_file, pipeline_vars, NULL);
if (SS == NULL) Errors::fatal("pipeline could not be parsed");
} else if (pipeline_as_text) {
SS = ParsingPipelines::from_text(pipeline_as_text, pipeline_vars);
if (SS == NULL) Errors::fatal("pipeline could not be parsed");
} else if (output_file) {
SS = ParsingPipelines::from_text(I"read <- *in, generate -> *out", pipeline_vars);
if (SS == NULL) Errors::fatal("pipeline could not be parsed");
} else if (LinkedLists::len(inter_file_list) > 0) {
SS = ParsingPipelines::from_text(I"read <- *in", pipeline_vars);
if (SS == NULL) Errors::fatal("pipeline could not be parsed");
}
if (output_binarily) BinaryInter::write(output_binarily, I);
@<Shut down the modules@> =
BytecodeModule::end();
@ -133,8 +133,6 @@ form, which would be written to |*outt|.
@d PROGRAM_NAME "inter"
@e TEXTUAL_CLSW
@e BINARY_CLSW
@e PIPELINE_CLSW
@e PIPELINE_FILE_CLSW
@e PIPELINE_VARIABLE_CLSW
@ -145,16 +143,19 @@ form, which would be written to |*outt|.
@e CONSTRUCTS_CLSW
@e ANNOTATIONS_CLSW
@e PRIMITIVES_CLSW
@e FORMAT_CLSW
@e O_CLSW
@e TRACE_CLSW
@<Read the command line@> =
CommandLine::declare_heading(
L"[[Purpose]]\n\n"
L"usage: inter file1 file2 ... [options]\n");
CommandLine::declare_switch(TEXTUAL_CLSW, L"textual", 2,
L"write to file X in textual format");
CommandLine::declare_switch(BINARY_CLSW, L"binary", 2,
L"write to file X in binary format");
CommandLine::declare_switch(O_CLSW, L"o", 2,
L"code-generate to file X");
CommandLine::declare_textual_switch(FORMAT_CLSW, L"format", 1,
L"code-generate -o output to format X (default is Text)");
CommandLine::declare_switch(PIPELINE_CLSW, L"pipeline-text", 2,
L"specify pipeline textually, with X being a comma-separated list of stages");
CommandLine::declare_switch(PIPELINE_FILE_CLSW, L"pipeline-file", 2,
@ -175,7 +176,9 @@ form, which would be written to |*outt|.
L"print out table of all symbol annotations in the Inter language");
CommandLine::declare_switch(PRIMITIVES_CLSW, L"primitives", 1,
L"print out table of all primitive invocations in the Inter language");
CommandLine::declare_boolean_switch(TRACE_CLSW, L"trace", 1,
L"print out all pipeline steps as they are followed", FALSE);
CommandLine::read(argc, argv, NULL, &Main::respond, &Main::add_file);
path_to_inter = Pathnames::installation_path("INTER_PATH", I"inter");
@ -183,8 +186,8 @@ form, which would be written to |*outt|.
@ =
void Main::respond(int id, int val, text_stream *arg, void *state) {
switch (id) {
case TEXTUAL_CLSW: output_textually = Filenames::from_text(arg); break;
case BINARY_CLSW: output_binarily = Filenames::from_text(arg); break;
case O_CLSW: output_file = Filenames::from_text(arg); break;
case FORMAT_CLSW: output_format = Str::duplicate(arg); break;
case PIPELINE_CLSW: pipeline_as_text = Str::duplicate(arg); break;
case PIPELINE_FILE_CLSW: pipeline_as_file = Filenames::from_text(arg); break;
case PIPELINE_VARIABLE_CLSW: @<Add a pipeline variable to the dictionary@>; break;
@ -198,6 +201,7 @@ void Main::respond(int id, int val, text_stream *arg, void *state) {
case CONSTRUCTS_CLSW: InterInstruction::show_constructs(STDOUT); break;
case ANNOTATIONS_CLSW: SymbolAnnotation::show_annotations(STDOUT); break;
case PRIMITIVES_CLSW: Primitives::show_primitives(STDOUT); break;
case TRACE_CLSW: tracing = (val)?TRUE:FALSE; break;
}
}

View file

@ -4,15 +4,16 @@ usage: inter file1 file2 ... [options]
-annotations print out table of all symbol annotations in the Inter language
-architecture X generate Inter with architecture X
-binary X write to file X in binary format
-build-kit X build Inter kit X for the current architecture
-constructs print out table of all constructs in the Inter language
-domain X specify folder to read/write inter files from/to
-format=X code-generate -o output to format X (default is Text)
-internal X specify folder of internal Inform resources
-o X code-generate to file X
-pipeline-file X specify pipeline as file X
-pipeline-text X specify pipeline textually, with X being a comma-separated list of stages
-primitives print out table of all primitive invocations in the Inter language
-textual X write to file X in textual format
-trace print out all pipeline steps as they are followed (default is -no-trace)
-variable X set pipeline variable X (in form name=value)
-at X specify that this tool is installed at X

View file

@ -2,38 +2,34 @@ Pipelines and Stages.
Sequences of named code-generation stages are called pipelines.
@h Stages and pipelines.
Inter has a pipeline design, meaning that it expects to work on Inter trees by
running a series of modifying "steps", one at a time.
= (text as BoxArt)
T --------> T --------> T --------> ... --------> T
step 1 step 2 step 3 ... step N
=
The Inter tree |T| starts out empty, and at the end it is thrown away. So any
useful pipeline will begin by loading something in (usually as step 1), and
end by producing some useful output (usually in its last step or steps).
@h Variables and filenames.
For an introduction to pipelines, first read the section //Using Inter//.
@ Formally, a pipeline is a list of steps, with each step being a usage of
a "stage". If a pipeline is spelled out textually on the Inter command line,
then commas are used to divide the stages:
= (text as ConsoleText)
$ inter/Tangled/inter -pipeline-text 'plugh, xyzzy, plover'
=
If the pipeline is in an external file, we would instead write:
= (text as ConsoleText)
$ inter/Tangled/inter -pipeline-file mypl.interpipeline
=
and the file |mypl.interpipeline| would have one stage listed on each line,
so that the commas are not needed:
= (text as Inter Pipeline)
plugh
xyzzy
plover
In that section, two variables |*in| and |*out| appeared, but no others.
Those were automatically set as needed: |*in| was the file specified first
in the command, while |*out| was the value of the |-o| output file switch.
@ A pipeline description can make use of "variables". These hold only text,
and generally represent filenames. Variable names begin with a star |*|.
The pipeline cannot create variables: instead, the user of the pipeline has
to make them before use. For example,
In fact, though, any number of variables can be set at the command line.
|-variable '*magicword=zooge'|, for example, creates the variable |*magicword|
and sets its initial value to "zooge".
Of course, this has no practical effect unless the pipeline we are running
makes use of such a variable. But we might imagine running:
= (text as ConsoleText)
$ inter/Tangled/inter my.intert -pipeline-file mypl.interpipeline -variable '*textual=v1.intert' -variable '*binary=v2.interb'
=
where |mypl.interpipeline| reads:
= (text)
read <- *in
generate text -> *textual
generate binary -> *binary
=
This will then write out the same Inter program in two different formats, to
two different files.
@ Variables hold only text, and generally represent filenames. Variable names
begin with a star |*|. When a pipeline runs, the value of a variable is
substituted for its name. For example,
= (text as ConsoleText)
$ inter/Tangled/inter -variable '*X=ex/why' -pipeline-file mypl.interpipeline
=
@ -51,11 +47,14 @@ description are interpreted as follows:
(a) If a filename contains a slash character, it is considered a literal
filename.
(b) If not, it is considered to be a leafname inside the "domain" directory.
(b) If the filename is just |-|, it is considered to mean the console, that
is, what in Unix is usually called |stdout|. In other words, output is printed
rather than saved.
(c) If not, it is considered to be a leafname inside the "domain" directory.
By default this is the current working directory, but using |-domain| at
the Inter command line changes that.
The special variable |*log|, which always exists, means the debugging log.
@ The special variable |*log|, which always exists, means the debugging log.
A command to write a text file to |*log| is interpreted instead to mean
"spool the output you would otherwise write to the debugging log instead".
For example,
@ -63,23 +62,7 @@ For example,
generate inventory -> *log
@h Pipelines run by Inform.
As the above implies, Inter pipelines normally begin with a clean slate:
no trees, no variables.
When a pipeline is being run by the main Inform 7 compiler, however,
two variables are created in advance. |*in| is set to the Inter code
which Inform has generated on the current run, and |*out| is set to the
filename to which final code needs to be generated. The practical
effect is that any useful pipeline for Inform will begin and end thus:
= (text as Inter Pipeline)
read <- *in
...
generate -> *out
=
In addition, the "domain" is set to the directory containing the |*out|
file.
@ To Inbuild and Inform, pipelines are resources in their own right, rather
To Inbuild and Inform, pipelines are resources in their own right, rather
like extensions or kits. So, for example, the standard distribution includes
= (text)
inform7/Internal/Pipelines/compile.interpipeline
@ -126,8 +109,6 @@ Note that Inbuild and Inform 7 respond to all three of |-pipeline|,
last two. (It can't find pipelines by name because it doesn't contain the
supervisor module for sorting out resources.)
@ For more on this, see //pipeline: What This Module Does//.
@h Syntax of pipeline descriptions.
Pipelines are, roughly speaking, just lists of steps. Each step occupies a single
line: blank lines are ignored, and so are lines whose first non-white-space
@ -165,7 +146,7 @@ The |[TREE]| is optional. For example:
read 2 <- *in
generate 3 -> *out
=
Pipeline descriptios allow us to manage up to 10 different Inter trees, and
Pipeline descriptions allow us to manage up to 10 different Inter trees, and
these are called |0| to |9|. These are all initially empty. Any stage which
doesn't specify a tree is considered to apply to |0|; so pipelines often never
mention the digits |0| to |9| at all because they always work inside |0|.

View file

@ -103,7 +103,7 @@ use semantically meaningful type names like |_adjective|. Only two package
types are special: |_code|, which as we have seen marks that a package is a
function, and |_linkage|, which is used only for a special package called
|connectors|. Stand-alone programs never contain that package: see
//bytecode: What This Module Does// for an explanation of what it is for.
//bytecode// for an explanation of what it is for.
@ |primitive !PRIMITIVE SIGNATURE| declares that a primitive invocation of
this name and signature can be used in the program. Primitives occur only

View file

@ -3,20 +3,52 @@ Using Inter.
Using Inter at the command line.
@h What Inter does.
The command-line executable Inter packages up the back end of the Inform 7
compiler into a stand-alone tool, and enables that back end to be used more
flexibly. For example, it can read or write either textual or binary inter
code, and can convert between them. It can also perform any of the numerous
code-generation stages on the code it reads, in any sequence. In short, it
aims to be a Swiss Army knife for inter code.
"Inter" is the intermediate representation of a program used in the Inform
compiler toolchain. Most compilers have one of these: for example, Microsoft
compilers mostly use "CIL" (common intermediate language), while |gcc| uses
something called GIMPLE, and so on. See //bytecode// for a longer discussion
of what motivates the design of Inter.
Because of that, it's possible to test code-generation stages individually:
we can read in some inter code from a text file, perform a single stage on
it, and write it out as text again. This gives us a very helpful window into
what Inform is doing; it also provides a test-bed for future optimisation,
or for future applications of inter code.
The practical effect is that the back end of the Inform compiler deals only
with Inter code. This back end exists as part of the executable //inform7//,
but also as a stand-alone program called //inter//, which comes with its
own command-line interface. Whereas //inform7// has a specific task to perform
and uses Inter code only as a means to an end, //inter// is designed to be
as flexible as possible.
@h Command-line usage.
@ Inter code can exist in memory, or in a human-readable text file, or in a
rapid-access binary file. The tool //inter// can convert between these formats:
= (text as BoxArt)
textual textual
inter ---+ +---> inter
\ /
\ /
----> memory ----
/ inter \
binary / \ binary
inter ---+ +---> inter
=
However, Inter can do much more than simply convert between these forms. It
has a "pipeline" design, meaning that it can run memory inter through any
desired series of compilation stages, one at a time:
= (text as BoxArt)
T --------> T --------> T --------> ... --------> T
step 1 step 2 step 3 ... step N
=
The Inter tree |T| starts out empty,[1] and at the end it is thrown away. So any
useful pipeline will begin by loading something in (usually as step 1), and
end by producing some useful output (usually in its last step or steps).
The advantage of this design is that it enables us to build what amount to
entirely different compilers, just by using different pipelines -- see
"assimilation" below for an example of a pipeline very different to the one
used in normal Inform 7 compilations. Pipelines also allow us to test existing
or proposed code-generation stages individually.
[1] Programs in Inter format are called "Inter trees".
@h Verify only.
If you have compiled the standard distribution of the command-line tools
for Inform then the Inter executable will be at |inter/Tangled/inter|.
@ -34,68 +66,151 @@ detects which by looking at their contents. (Conventionally, such files
have the filename extension |.intert| or |.interb| respectively, but that's
not how Inter decides.)
@ In the second mode, Inter converts from textual to binary form or vice
versa. The option |-binary X| writes a binary form of the inter to file |X|,
and |-textual X| writes a text form. So, for example,
@h Format conversion.
In the second mode, Inter not only loads (and verifies) the named file, but
then converts it to a different format and writes that out. For example,
= (text as ConsoleText)
$ inter/Tangled/inter my.intert -binary my.interb
$ inter/Tangled/inter my.intert -o my.interb -format=binary
=
converts |my.intert| (a textual inter file) to its binary equivalent
|my.interb|, and conversely:
converts |my.intert| (a textual inter file) to its binary equivalent |my.interb|,
and conversely:
= (text as ConsoleText)
$ inter/Tangled/inter my.interb -textual my.intert
$ inter/Tangled/inter my.interb -o my.intert -format=text
=
@ In the third and most flexible mode, Inter runs the supplied code through
a pipeline of processing stages. The pipeline, which must contain at least
one stage, can be quite elaborate (see later), but for example:
= (text as Inter Pipeline)
read <- myfile.inter, resolve-conditional-compilation, generate inform6 -> myfile.i6
=
is a valid three-stage pipeline. The command to do this is then:
Two parameters must be specified: |-o| giving the output file, and |-format=F|
to say what format |F| this should have. Formats are in the same notation as
those used by //inbuild//, which similarly supports |-o| and |-format|.
In fact, |-format=text| is the default.
To take an elaborate example,
= (text as ConsoleText)
$ inter/Tangled/inter -pipeline-text 'PIPELINE'
$ inter/Tangled/inter my.interb -o my.intert -format=C/32d/nomain
=
where |PIPELINE| is a textual description like the one above. In practice,
it may not be convenient to spell the pipeline out on the command line, so
one can also put it into a text file:
generates a 32-bit-word, debugging-enabled ANSI C program from the Inter tree
in |my.interb|, with no |main| function included in it.
As a special case, if |-o| is given just as |-|, then the output is printed
to the console rather than to a file.
@h Running a pipeline.
If we specify |-trace| as a command-line switch, Inter prints out every step
of the pipeline(s) it is following. This reveals that even the simple commands
above are, in fact, running pipelines, albeit short ones:
= (text as ConsoleText)
$ inter/Tangled/inter my.intert -trace
step 1/1: read <- my.intert
$ inter/Tangled/inter my.intert -o my.interb -format=binary -trace
step 1/2: read <- my.intert
step 2/2: generate binary -> my.interb
=
As this shows, a one or two-step pipeline was running:
(1) The first step used the |read| compilation stage, which reads some Inter
code into memory. Here, it comes from the file |my.intert|.
(2) The second step used the |generate| stage, which writes out Inter code
in the format of one's choice -- here "binary".
@ However, we don't have to use this default pipeline. |-pipeline-text 'PIPELINE'|
reads in a textual description of the pipeline to follow, with the steps divided
by commas. The examples above used a pipeline which in this notation would
be written as:
= (text as ConsoleText)
-pipeline-text 'read <- *in, generate -> *out'
=
|*in| and |*out| are examples of "pipeline variables". |*in| is the filename
of whatever file is to be read in, and |*out| is whatever was specified by |-o|
at the command line, or in other words, the filename to write the output to.
This is not quite the smallest possible pipeline. Consider:
= (text as ConsoleText)
$ inter/Tangled/inter -o my.intert -pipeline-text 'new, generate -> *out' -trace
step 1/2: new
step 2/2: generate text -> my.intert
=
Here we didn't specify any Inter file to read in, so |*in| does not appear.
Instead wevbegan the pipeline with the |new| compilation stage, which creates
a minimal Inter program from nothing.
Even three-step pipelines can be very useful. For example:
= (text as ConsoleText)
$ inter/Tangled/inter -o my.intert -pipeline-text 'read <- *in, eliminate-redundant-labels, generate -> *out' -trace
step 1/3: read <- my.intert
step 2/3: eliminate-redundant-labels
step 3/3: generate text -> my.intert
=
This could be used to test that the |eliminate-redundant-labels| compilation
stage is working as it should. We can feed our choice of Inter code into it,
and examine its direct output, in isolation from the working of the rest of
the compiler (and, of course, more quickly).
@ In practice, it becomes cumbersome to spell the pipeline out longhand on
the command line, so we can also put it into a text file:
= (text as ConsoleText)
$ inter/Tangled/inter -pipeline-file mypl.interpipeline
=
Pipelines can contain variables, and their values can be set at the command
line with e.g.:
It's not allowed to specify both |-pipeline-file| and |-pipeline-text|.
The text file, however, specifies pipelines with one step on each line, not
using commas. So |-pipeline-text 'read <- *in, eliminate-redundant-labels, generate -> *out'|
is equivalent to |-pipeline-file| with the file:
= (text)
-variable '*out=myfile.i6'
read <- *in
eliminate-redundant-labels
generate -> *out
=
It is also possible to set the default directory for reading and writing files:
For more on how to write and use pipeline files, see //Pipelines and Stages//.
@ In general, filenames follow the usual Unix conventions: they are taken as
relative to the current working directory, unless given as absolute filenames
beginning with |/|. But we can also set a "default directory" to take the
place of the CWD, using |-domain|:
= (text)
-domain D
@h Assimilation.
Inform makes use of what are called "kits" of pre-compiled Inter code:
for example, |CommandParserKit| contains code for the traditional interactive
fiction command parser. For speed, Inter loads these as binary Inter, but
that means they have to be compiled from time to time. This is called
"assimilation".
fiction command parser. That pre-compilation is called "assimilation", and
is performed by the //inter// tool alone: it does not require, or use, the
bulk of the //inform7// compiler.
The source code for these could in priniple be textual Inter, but that's too
The source code for a kit could in principle be textual Inter, but that's too
verbose to write comfortably. In practice we use Inform 6 code as a notation,
and therefore assimilation is really a cross-compilation from I6 to Inter.
and therefore assimilation is really compilation from I6 to Inter.
Kits are like so-called "fat binaries", in that they contain binary Inter
for each different architecture with which they are compatible. Inter can
build kits for only one architecture at a time, so a command must specify
which is wanted. For example:
= (text as ConsoleText)
$ inter/Tangled/inter -architecture 16 -build-kit K
$ inter/Tangled/inter -architecture 32d -build-kit K
$ inter/Tangled/inter -architecture 16 -build-kit inform7/Internal/Inter/BasicInformKit
$ inter/Tangled/inter -architecture 32d -build-kit inform7/Internal/Inter/BasicInformKit
=
At present there are four architectures: |16|, |16d|, |32| and |32d|.
Note that an architecture is not the same thing as a format: it specifies
only the word size (16 or 32 bit) and the presence, or not, of debugging data.
Incrementally building kits as needed could be done with something like
the Unix tool |make|, but in fact Inbuild has this ability: the command
= (text as ConsoleText)
$ inbuild/Tangled/inbuild -build K
=
looks at the kit, works out which architectures need rebuilding, and
looks at the kit |K|, works out which architectures need rebuilding, and
then issues commands like the above to instruct |inter| to do so. Indeed,
multiple kits can be managed with a single command:
= (text as ConsoleText)
$ inbuild/Tangled/inbuild -build -contents-of inform7/Internal/Inter
@ Under the hood, assimilation is just another use of pipeline processing. If we
run one of these |-build-kit| commands with |-trace| switched on, we see
something like this:
= (text as ConsoleText)
step 1/6: new
step 2/6: load-kit-source <- BasicInformKit
step 3/6: parse-insertions
step 4/6: resolve-conditional-compilation
step 5/6: compile-splats
step 6/6: generate binary -> inform7/Internal/Inter/BasicInformKit/arch-32.interb
=
This is in fact the result of running a pipeline file called |build-kit.interpipeline|
which is included in the standard Inter distribution.

View file

@ -61,7 +61,7 @@ steps in turn, timing how long each one took us.
pipeline_step *currently_running_pipeline_step = NULL;
void RunningPipelines::run(pathname *P, inter_pipeline *S, inter_tree *I,
pathname *the_kit, linked_list *requirements_list, target_vm *VM) {
pathname *the_kit, linked_list *requirements_list, target_vm *VM, int tracing) {
if (S == NULL) return;
if (I) S->ephemera.memory_repository = I;
stopwatch_timer *within = NULL;
@ -89,9 +89,10 @@ void RunningPipelines::run(pathname *P, inter_pipeline *S, inter_tree *I,
@<Prepare ephemeral data for this step@>;
Time::stop_stopwatch(prep_timer);
TEMPORARY_TEXT(STAGE_NAME)
WRITE_TO(STAGE_NAME, "inter step %d/%d: ", ++step_count, step_total);
WRITE_TO(STAGE_NAME, "step %d/%d: ", ++step_count, step_total);
ParsingPipelines::write_step(STAGE_NAME, step);
Log::new_stage(STAGE_NAME);
if (tracing) WRITE_TO(STDOUT, "%S\n", STAGE_NAME);
stopwatch_timer *step_timer =
Time::start_stopwatch(pipeline_timer, STAGE_NAME);
DISCARD_TEXT(STAGE_NAME)
@ -145,6 +146,9 @@ void RunningPipelines::run(pathname *P, inter_pipeline *S, inter_tree *I,
if (Str::eq(step->step_argument, I"*log")) {
step->ephemera.to_stream = DL;
@<Call the stage execution function@>;
} else if (Str::eq(step->step_argument, I"-")) {
step->ephemera.to_stream = STDOUT;
@<Call the stage execution function@>;
} else {
@<Work out the filename@>;
text_stream text_output_struct;

View file

@ -30,11 +30,40 @@ void TargetVMs::create(void) {
TargetVMs::new(Architectures::from_codename(I"32d"), I"Inform6",
VersionNumbers::from_text(I"3.1.2"), I"i6", I"ulx", I"gblorb", I"Quixe", NULL);
/* hat tip: modesty forbids */
TargetVMs::new(Architectures::from_codename(I"16"), I"Binary",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"16d"), I"Binary",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32"), I"Binary",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32d"), I"Binary",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"16"), I"Text",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"16d"), I"Text",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32"), I"Text",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32d"), I"Text",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
/* C support added September 2021 */
TargetVMs::new(Architectures::from_codename(I"32"), I"C",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32d"), I"C",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
/* Inventory support added March 2022 */
TargetVMs::new(Architectures::from_codename(I"16"), I"Inventory",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"16d"), I"Inventory",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32"), I"Inventory",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
TargetVMs::new(Architectures::from_codename(I"32d"), I"Inventory",
VersionNumbers::from_text(I"1"), I"c", I"", I"", I"", NULL);
}
@ The //target_vm// structure contains two arguably architectural doohickies: