mirror of
https://github.com/ganelson/inform.git
synced 2024-06-26 04:00:43 +03:00
Improved command-line interface for inter
This commit is contained in:
Graham Nelson
parent
fdbb235a63
commit
c876a87d40
|
|
@ -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>§2. </b>The <a href="2-tvm.html#SP2" class="internal">target_vm</a> structure contains two arguably architectural doohickies:
|
||||
|
|
|
|||
|
|
@ -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">§1. Settings variables</a></li><li><a href="1-mn.html#SP2">§2. Main routine</a></li><li><a href="1-mn.html#SP2_7">§2.7. Command line</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="1-mn.html#SP1">§1. Settings variables</a></li><li><a href="1-mn.html#SP2">§2. Main routine</a></li><li><a href="1-mn.html#SP2_6">§2.6. Command line</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§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">§2.3</a>, <a href="1-mn.html#SP3_1">§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">§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">§2.3</a>, <a href="1-mn.html#SP2_4">§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">§2</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_3" class="paragraph-anchor"></a><b>§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>§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">§2</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_4" class="paragraph-anchor"></a><b>§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">) > </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">) && (</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">) > </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">) > </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">§2</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_5" class="paragraph-anchor"></a><b>§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>§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 <- *in, generate -> *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">) > </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 <- *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"> = &</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">§2</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_6" class="paragraph-anchor"></a><b>§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">§2.4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_5" class="paragraph-anchor"></a><b>§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">§2</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2_7" class="paragraph-anchor"></a><b>§2.7. Command line. </b></p>
|
||||
<p class="commentary firstcommentary"><a id="SP2_6" class="paragraph-anchor"></a><b>§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">, &</span><a href="1-mn.html#SP3" class="function-link"><span class="function-syntax">Main::respond</span></a><span class="plain-syntax">, &</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>§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">§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">§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>§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">§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">§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>
|
||||
|
|
|
|||
|
|
@ -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">§1. Stages and pipelines</a></li><li><a href="M-pas.html#SP4">§4. Pipelines run by Inform</a></li><li><a href="M-pas.html#SP7">§7. Syntax of pipeline descriptions</a></li><li><a href="M-pas.html#SP9">§9. Dictionary of stages</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="M-pas.html#SP1">§1. Variables and filenames</a></li><li><a href="M-pas.html#SP4">§4. Pipelines run by Inform</a></li><li><a href="M-pas.html#SP5">§5. Syntax of pipeline descriptions</a></li><li><a href="M-pas.html#SP7">§7. Dictionary of stages</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§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>§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"> --------> </span><span class="element-syntax">T</span><span class="plain-syntax"> --------> </span><span class="element-syntax">T</span><span class="plain-syntax"> --------> ... --------> </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>§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 <- *in</span>
|
||||
<span class="plain-syntax">generate text -> *textual</span>
|
||||
<span class="plain-syntax">generate binary -> *binary</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§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>§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>§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">-></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>§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"><-</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">-></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>§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>§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>§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>§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>§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"><-</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">-></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>§8. </b>Pipelines can also include each other. For example, the step:
|
||||
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>§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">-></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>§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>§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>§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>§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>§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>§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>§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>§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>§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>§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>§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>§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>§15. </b><span class="extract"><span class="extract-syntax">generate [FORMAT] -> [DESTINATION]</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>§13. </b><span class="extract"><span class="extract-syntax">generate [FORMAT] -> [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>§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>§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>§17. </b><span class="extract"><span class="extract-syntax">load-kit-source <- [SOURCE]</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP15" class="paragraph-anchor"></a><b>§15. </b><span class="extract"><span class="extract-syntax">load-kit-source <- [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>§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>§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>§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>§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>§20. </b><span class="extract"><span class="extract-syntax">move <- LOCATION</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>§18. </b><span class="extract"><span class="extract-syntax">move <- 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 <- 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>§21. </b><span class="extract"><span class="extract-syntax">new</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>§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>§22. </b><span class="extract"><span class="extract-syntax">optionally-generate [FORMAT] -> DESTINATION</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>§20. </b><span class="extract"><span class="extract-syntax">optionally-generate [FORMAT] -> 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>§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>§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>§24. </b><span class="extract"><span class="extract-syntax">read <- SOURCE</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>§22. </b><span class="extract"><span class="extract-syntax">read <- 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>§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>§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>§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>§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>§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>§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>§28. </b><span class="extract"><span class="extract-syntax">stop</span></span>.
|
||||
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>§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
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -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>§7. </b><span class="extract"><span class="extract-syntax">primitive !PRIMITIVE SIGNATURE</span></span> declares that a primitive invocation of
|
||||
|
|
|
|||
|
|
@ -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">§1. What Inter does</a></li><li><a href="M-ui.html#SP2">§2. Command-line usage</a></li><li><a href="M-ui.html#SP5">§5. Assimilation</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="M-ui.html#SP1">§1. What Inter does</a></li><li><a href="M-ui.html#SP3">§3. Verify only</a></li><li><a href="M-ui.html#SP4">§4. Format conversion</a></li><li><a href="M-ui.html#SP5">§5. Running a pipeline</a></li><li><a href="M-ui.html#SP9">§9. Assimilation</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§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>§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>§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>§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"> ---+ +---> </span><span class="element-syntax">inter</span>
|
||||
<span class="plain-syntax"> \ /</span>
|
||||
<span class="plain-syntax"> \ /</span>
|
||||
<span class="plain-syntax"> ----> </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"> ---+ +---> </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"> --------> </span><span class="element-syntax">T</span><span class="plain-syntax"> --------> </span><span class="element-syntax">T</span><span class="plain-syntax"> --------> ... --------> </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 — 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"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§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>§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>§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>§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"><-</span><span class="plain-syntax"> myfile.inter, resolve-conditional-compilation, generate inform6 </span><span class="reserved-syntax">-></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>§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 <- 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 <- my.intert</span>
|
||||
<span class="ConsoleText-plain-syntax"> step 2/2: generate binary -> 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 — here "binary".
|
||||
</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>§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 <- *in, generate -> *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 -> *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 -> 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 <- *in, eliminate-redundant-labels, generate -> *out'</span><span class="ConsoleText-identifier-syntax"> -trace</span>
|
||||
<span class="ConsoleText-plain-syntax"> step 1/3: read <- 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 -> 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>§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 <- *in, eliminate-redundant-labels, generate -> *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 <- *in</span>
|
||||
<span class="plain-syntax">eliminate-redundant-labels</span>
|
||||
<span class="plain-syntax">generate -> *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>§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>§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>§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>§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 <- 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 -> 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">❮</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">❯</a></li></ul></div>
|
||||
</nav><!--End of weave-->
|
||||
|
|
|
|||
|
|
@ -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">-></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">-></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">-></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">-></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">-></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">-></span><span class="element-syntax">step_stage</span><span class="plain-syntax">-></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">§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">§3.1.2</a> (five times).</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§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).
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -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">-></span><span class="element-syntax">associated_copy</span><span class="plain-syntax">-></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">-></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">-></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">-></span><span class="element-syntax">vertex</span><span class="plain-syntax">-></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">-></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">-></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>
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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|.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
Loading…
Reference in a new issue