ifhub/inform7
1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-06-26 04:00:43 +03:00
Code Issues Projects Releases Wiki Activity

Further kit refactoring

Browse source
This commit is contained in:
Graham Nelson 2023-06-09 11:15:21 +01:00
parent fbfbf6f8d6
commit 109df1dfa2
32 changed files with 251 additions and 198 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,6 +1,6 @@
# Inform 7
[Version](notes/versioning.md): 10.2.0-beta+6W58 'Krypton' (8 June 2023)
[Version](notes/versioning.md): 10.2.0-beta+6W59 'Krypton' (9 June 2023)
## About Inform

4
build.txt
View file

@ -1,3 +1,3 @@
Prerelease: beta
Build Date: 8 June 2023
Build Number: 6W58
Build Date: 9 June 2023
Build Number: 6W59

39
docs/Architecture16Kit/S-io.html
View file

@ -65,7 +65,7 @@ MathJax = {
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../extensions.html">Kits</a></li><li><a href="index.html">Architecture16Kit</a></li><li><b>Input Output Template</b></li></ul></div>
<p class="purpose">Access to the keyboard and to textual windows.</p>
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Variables and Arrays</a></li><li><a href="S-io.html#SP2">&#167;2. Keyboard Input</a></li><li><a href="S-io.html#SP3">&#167;3. Buffer Functions</a></li><li><a href="S-io.html#SP4">&#167;4. Dictionary Functions</a></li><li><a href="S-io.html#SP5">&#167;5. Command Tables</a></li><li><a href="S-io.html#SP6">&#167;6. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP7">&#167;7. The Screen</a></li><li><a href="S-io.html#SP8">&#167;8. Window Colours</a></li><li><a href="S-io.html#SP9">&#167;9. Main Window</a></li><li><a href="S-io.html#SP10">&#167;10. Status Line</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Variables and Arrays</a></li><li><a href="S-io.html#SP2">&#167;2. Dictionary words</a></li><li><a href="S-io.html#SP3">&#167;3. Keyboard Input</a></li><li><a href="S-io.html#SP4">&#167;4. Buffer Functions</a></li><li><a href="S-io.html#SP5">&#167;5. Dictionary Functions</a></li><li><a href="S-io.html#SP6">&#167;6. Command Tables</a></li><li><a href="S-io.html#SP7">&#167;7. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP8">&#167;8. The Screen</a></li><li><a href="S-io.html#SP9">&#167;9. Window Colours</a></li><li><a href="S-io.html#SP10">&#167;10. Main Window</a></li><li><a href="S-io.html#SP11">&#167;11. Status Line</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Variables and Arrays. </b></p>
@ -88,7 +88,19 @@ MathJax = {
<span class="identifier-syntax">Global</span><span class="plain-syntax"> </span><span class="identifier-syntax">dict_entry_size</span><span class="plain-syntax">;</span>
<span class="identifier-syntax">Global</span><span class="plain-syntax"> </span><span class="identifier-syntax">dict_end</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Keyboard Input. </b>The VM must provide three routines for keyboard input:
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Dictionary words. </b>This tests whether an address is probably that of a dictionary word. It's used
only for debugging output, so the false positives here (where an address is in
the dictionary table, but mid-word) really do not matter.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_ProbablyDictionaryAddress</span><span class="plain-syntax"> </span><span class="identifier-syntax">addr</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">UnsignedCompare</span><span class="plain-syntax">(</span><span class="identifier-syntax">addr</span><span class="plain-syntax">, </span><span class="identifier-syntax">HDR_DICTIONARY</span><span class="plain-syntax">--&gt;0) &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax"> &amp;&amp;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">UnsignedCompare</span><span class="plain-syntax">(</span><span class="identifier-syntax">addr</span><span class="plain-syntax">, </span><span class="identifier-syntax">HDR_HIGHMEMORY</span><span class="plain-syntax">--&gt;0) &lt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">rfalse</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Keyboard Input. </b>The VM must provide three routines for keyboard input:
</p>
<ul class="items"><li>(a) <span class="extract"><span class="extract-syntax">VM_KeyChar()</span></span> waits for a key to be pressed and then returns the
@ -115,16 +127,11 @@ to document all of that.
<span class="plain-syntax">];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_KeyDelay_Interrupt</span><span class="plain-syntax">; </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">; ];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_ReadKeyboard</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</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">VM_ReadKeyboard</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">read</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</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">BasicInformKit</span><span class="plain-syntax">`</span><span class="identifier-syntax">ECHO_COMMANDS_CFGF</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"** "</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=2: </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;=(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">-&gt;1)+1: </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">char</span><span class="plain-syntax">) </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"^"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
typed from the keyboard; a "parse buffer" is an array which resolves this
into individual words, pointing to the relevant entries in the dictionary
structure. Because each VM has its own format for each of these arrays (not
@ -187,7 +194,7 @@ languages of play.
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">b</span><span class="plain-syntax">-&gt;1 &lt; </span><span class="identifier-syntax">b</span><span class="plain-syntax">-&gt;0) (</span><span class="identifier-syntax">b</span><span class="plain-syntax">-&gt;1)++;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
This is a data structure containing, in compressed form, the text of all the
words to be recognised by tokenisation (above). In I6 for Z, a dictionary word
value is represented at run-time by its record number in the dictionary,
@ -213,7 +220,7 @@ convert between record numbers and dictionary addresses.
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_DictionaryAddressToNumber</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax"> (</span><span class="identifier-syntax">w</span><span class="plain-syntax">-(</span><span class="identifier-syntax">HDR_DICTIONARY</span><span class="plain-syntax">--&gt;0 + </span><span class="constant-syntax">7</span><span class="plain-syntax">))/</span><span class="identifier-syntax">DICT_ENTRY_BYTES</span><span class="plain-syntax">; ];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_NumberToDictionaryAddress</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">HDR_DICTIONARY</span><span class="plain-syntax">--&gt;0 + </span><span class="constant-syntax">7</span><span class="plain-syntax"> + </span><span class="identifier-syntax">DICT_ENTRY_BYTES</span><span class="plain-syntax">*</span><span class="identifier-syntax">n</span><span class="plain-syntax">; ];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Command Tables. </b>The VM is also generated containing a data structure for the grammar
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Command Tables. </b>The VM is also generated containing a data structure for the grammar
produced by I6's <span class="extract"><span class="extract-syntax">Verb</span></span> and <span class="extract"><span class="extract-syntax">Extend</span></span> directives: this is essentially a
list of command verbs such as DROP or PUSH, together with a list of
synonyms, and then the grammar for the subsequent commands to be
@ -232,7 +239,7 @@ recognised by the parser.
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"'"</span><span class="plain-syntax">, (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">VM_NumberToDictionaryAddress</span><span class="plain-syntax">(</span><span class="identifier-syntax">j</span><span class="plain-syntax">), </span><span class="string-syntax">"' "</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Extracting Verb Numbers. </b>A long tale of woe lies behind the following. Infocom games stored verb numbers
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Extracting Verb Numbers. </b>A long tale of woe lies behind the following. Infocom games stored verb numbers
in a single byte in dictionary entries, but they did so counting downwards, so
that verb number 0 was stored as 255, 1 as 254, and so on. Inform followed
suit so that debugging of Inform 1 could be aided by using the then-available
@ -253,7 +260,7 @@ routine was added to concentrate lookups of this field in one place.
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">$ff</span><span class="plain-syntax">-(</span><span class="identifier-syntax">dword</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par2</span><span class="plain-syntax">);</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. The Screen. </b>Our generic screen model is that the screen is made up of windows: we tend
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. The Screen. </b>Our generic screen model is that the screen is made up of windows: we tend
to refer only to two of these, the main window and the status line, but
others may also exist from time to time. Windows have unique ID numbers:
the special window ID \(-1\) means "all windows" or "the entire screen",
@ -284,7 +291,7 @@ in order to keep it accurate.
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_ScreenHeight</span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax"> (</span><span class="identifier-syntax">HDR_SCREENHLINES</span><span class="plain-syntax">-&gt;0); ];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. Window Colours. </b>Each window can have its own foreground and background colours.
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Window Colours. </b>Each window can have its own foreground and background colours.
</p>
<p class="commentary">The colour of individual letters or words of type is not controllable in
@ -323,7 +330,7 @@ which is greatly superior in this respect).
<span class="plain-syntax"> }</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Main Window. </b>The part of the screen on which commands and responses are printed, which
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. Main Window. </b>The part of the screen on which commands and responses are printed, which
ordinarily occupies almost all of the screen area.
</p>
@ -342,7 +349,7 @@ emulates the Glulx model of window rather than text colours.
<span class="plain-syntax"> </span><span class="identifier-syntax">statuswin_current</span><span class="plain-syntax"> = </span><span class="reserved-syntax">false</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. Status Line. </b>Despite the name, the status line need not be a single line at the top of
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. Status Line. </b>Despite the name, the status line need not be a single line at the top of
the screen: that's only the conventional default arrangement. It can expand
to become the equivalent of an old-fashioned VT220 terminal, with menus
and grids and mazes displayed lovingly in character graphics, or it can

45
docs/Architecture32Kit/S-io.html
View file

@ -65,7 +65,7 @@ MathJax = {
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../extensions.html">Kits</a></li><li><a href="index.html">Architecture32Kit</a></li><li><b>Input Output Template</b></li></ul></div>
<p class="purpose">Access to the keyboard and to textual windows.</p>
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Variables and Arrays</a></li><li><a href="S-io.html#SP2">&#167;2. Rocks</a></li><li><a href="S-io.html#SP3">&#167;3. Keyboard Input</a></li><li><a href="S-io.html#SP4">&#167;4. Buffer Functions</a></li><li><a href="S-io.html#SP5">&#167;5. Dictionary Functions</a></li><li><a href="S-io.html#SP6">&#167;6. Command Tables</a></li><li><a href="S-io.html#SP7">&#167;7. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP8">&#167;8. Glulx-Only Printing Routines</a></li><li><a href="S-io.html#SP9">&#167;9. The Screen</a></li><li><a href="S-io.html#SP10">&#167;10. Window Colours</a></li><li><a href="S-io.html#SP11">&#167;11. Main Window</a></li><li><a href="S-io.html#SP12">&#167;12. Status Line</a></li><li><a href="S-io.html#SP13">&#167;13. Quotation Boxes</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Variables and Arrays</a></li><li><a href="S-io.html#SP2">&#167;2. Rocks</a></li><li><a href="S-io.html#SP3">&#167;3. Dictionary words</a></li><li><a href="S-io.html#SP4">&#167;4. Keyboard Input</a></li><li><a href="S-io.html#SP5">&#167;5. Buffer Functions</a></li><li><a href="S-io.html#SP6">&#167;6. Dictionary Functions</a></li><li><a href="S-io.html#SP7">&#167;7. Command Tables</a></li><li><a href="S-io.html#SP8">&#167;8. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP9">&#167;9. Glulx-Only Printing Routines</a></li><li><a href="S-io.html#SP10">&#167;10. The Screen</a></li><li><a href="S-io.html#SP11">&#167;11. Window Colours</a></li><li><a href="S-io.html#SP12">&#167;12. Main Window</a></li><li><a href="S-io.html#SP13">&#167;13. Status Line</a></li><li><a href="S-io.html#SP14">&#167;14. Quotation Boxes</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Variables and Arrays. </b></p>
@ -113,7 +113,17 @@ cookies.
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">GG_FOREGROUNDCHAN_ROCK</span><span class="plain-syntax"> </span><span class="constant-syntax">410</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">GG_BACKGROUNDCHAN_ROCK</span><span class="plain-syntax"> </span><span class="constant-syntax">411</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Keyboard Input. </b>The VM must provide three routines for keyboard input:
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Dictionary words. </b>This tests whether an address is probably that of a dictionary word. It's used
only for debugging output, so the false positives here really do not matter.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">VM_ProbablyDictionaryAddress</span><span class="plain-syntax"> </span><span class="identifier-syntax">addr</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">addr</span><span class="plain-syntax">-&gt;0 == </span><span class="constant-syntax">$60</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">rfalse</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Keyboard Input. </b>The VM must provide three routines for keyboard input:
</p>
<ul class="items"><li>(a) <span class="extract"><span class="extract-syntax">VM_KeyChar()</span></span> waits for a key to be pressed and then returns the
@ -220,8 +230,7 @@ to document all of that.
<span class="character-syntax"> if (ix == 2) {</span>
<span class="character-syntax"> key = gg_arguments--&gt;0;</span>
<span class="character-syntax"> done = true;</span>
<span class="character-syntax"> }</span>
<span class="character-syntax"> else if (ix &gt;= 0 &amp;&amp; gg_event--&gt;0 == 1 or 2) {</span>
<span class="character-syntax"> } else if (ix &gt;= 0 &amp;&amp; gg_event--&gt;0 == 1 or 2) {</span>
<span class="character-syntax"> key = gg_event--&gt;2;</span>
<span class="character-syntax"> done = true;</span>
<span class="character-syntax"> }</span>
@ -239,8 +248,7 @@ to document all of that.
<span class="character-syntax"> glk_stream_close(gg_commandstr, 0);</span>
<span class="character-syntax"> gg_commandstr = 0;</span>
<span class="character-syntax"> gg_command_reading = false;</span>
<span class="character-syntax"> }</span>
<span class="character-syntax"> else {</span>
<span class="character-syntax"> } else {</span>
<span class="character-syntax"> </span><span class="comment-syntax">Trim the trailing newline</span>
<span class="character-syntax"> if ((a_buffer+WORDSIZE)--&gt;(done-1) == 10) done = done-1;</span>
<span class="character-syntax"> a_buffer--&gt;0 = done;</span>
@ -279,14 +287,9 @@ to document all of that.
<span class="character-syntax"> glk_window_close(gg_quotewin, 0);</span>
<span class="character-syntax"> gg_quotewin = 0;</span>
<span class="character-syntax"> }</span>
<span class="character-syntax"> if (BasicInformKit`ECHO_COMMANDS_CFGF) {</span>
<span class="character-syntax"> print "** ";</span>
<span class="character-syntax"> for (ix=0: ix&lt;(a_buffer--&gt;0): ix++) print (char) a_buffer--&gt;(1+ix);</span>
<span class="character-syntax"> print "^";</span>
<span class="character-syntax"> }</span>
<span class="character-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
typed from the keyboard; a "parse buffer" is an array which resolves this
into individual words, pointing to the relevant entries in the dictionary
structure. Because each VM has its own format for each of these arrays (not
@ -419,7 +422,7 @@ languages of play, and is not called in the template.
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">b</span><span class="plain-syntax">--&gt;0 &lt; </span><span class="identifier-syntax">INPUT_BUFFER_LEN</span><span class="plain-syntax">) (</span><span class="identifier-syntax">b</span><span class="plain-syntax">--&gt;0)++;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
This is a data structure containing, in compressed form, the text of all the
words to be recognised by tokenisation (above). In I6 for Glulx, a dictionary
word is represented at run-time by its record's address in the dictionary.
@ -456,7 +459,7 @@ since, on Glulx, they are the same, these are each the identity function.
<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>
</pre>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Command Tables. </b>The VM is also generated containing a data structure for the grammar
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Command Tables. </b>The VM is also generated containing a data structure for the grammar
produced by I6's <span class="extract"><span class="extract-syntax">Verb</span></span> and <span class="extract"><span class="extract-syntax">Extend</span></span> directives: this is essentially a
list of command verbs such as DROP or PUSH, together with a list of
synonyms, and then the grammar for the subsequent commands to be
@ -478,7 +481,7 @@ recognised by the parser.
<span class="plain-syntax"> }</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Extracting Verb Numbers. </b>A long tale of woe lies behind the following. Infocom games stored verb numbers
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. Extracting Verb Numbers. </b>A long tale of woe lies behind the following. Infocom games stored verb numbers
in a single byte in dictionary entries, but they did so counting downwards, so
that verb number 0 was stored as 255, 1 as 254, and so on. Inform followed
suit so that debugging of Inform 1 could be aided by using the then-available
@ -502,7 +505,7 @@ routine was added to concentrate lookups of this field in one place.
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. Glulx-Only Printing Routines. </b>Partly because of the smallness of the range of representable values in
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Glulx-Only Printing Routines. </b>Partly because of the smallness of the range of representable values in
the Z-machine, there is little run-time type-checking that can be done:
for instance a dictionary address cannot be distinguished from a function
address because they are encoded differently, so that a function address
@ -655,7 +658,7 @@ set stored here is once again ZSCII, not Unicode.
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">AnyToStrArr</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. The Screen. </b>Our generic screen model is that the screen is made up of windows: we tend
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. The Screen. </b>Our generic screen model is that the screen is made up of windows: we tend
to refer only to two of these, the main window and the status line, but
others may also exist from time to time. Windows have unique ID numbers:
the special window ID \(-1\) means "all windows" or "the entire screen",
@ -692,7 +695,7 @@ make little sense there.
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">gg_arguments</span><span class="plain-syntax">--&gt;0;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. Window Colours. </b>Our generic screen model is that the screen is made up of windows, each of
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. Window Colours. </b>Our generic screen model is that the screen is made up of windows, each of
which can have its own foreground and background colours.
</p>
@ -760,7 +763,7 @@ which is greatly superior in this respect).
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">$ff0000</span><span class="plain-syntax">*(</span><span class="identifier-syntax">c</span><span class="plain-syntax">&amp;1) + </span><span class="constant-syntax">$ff00</span><span class="plain-syntax">*(</span><span class="identifier-syntax">c</span><span class="plain-syntax">&amp;2 ~= </span><span class="constant-syntax">0</span><span class="plain-syntax">) + </span><span class="constant-syntax">$ff</span><span class="plain-syntax">*(</span><span class="identifier-syntax">c</span><span class="plain-syntax">&amp;4 ~= </span><span class="constant-syntax">0</span><span class="plain-syntax">);</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. Main Window. </b>The part of the screen on which commands and responses are printed, which
<p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. Main Window. </b>The part of the screen on which commands and responses are printed, which
ordinarily occupies almost all of the screen area.
</p>
@ -774,7 +777,7 @@ status line, to the main window.
<span class="plain-syntax"> </span><span class="identifier-syntax">statuswin_current</span><span class="plain-syntax">=0;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP12" class="paragraph-anchor"></a><b>&#167;12. Status Line. </b>Despite the name, the status line need not be a single line at the top of
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>&#167;13. Status Line. </b>Despite the name, the status line need not be a single line at the top of
the screen: that's only the conventional default arrangement. It can expand
to become the equivalent of an old-fashioned VT220 terminal, with menus
and grids and mazes displayed lovingly in character graphics, or it can
@ -810,7 +813,7 @@ line; line 2 is underneath, and so on; columns are similarly numbered from
<span class="plain-syntax"> </span><span class="identifier-syntax">statuswin_current</span><span class="plain-syntax">=1;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP13" class="paragraph-anchor"></a><b>&#167;13. Quotation Boxes. </b>On the Z-machine, quotation boxes are produced by stretching the status line,
<p class="commentary firstcommentary"><a id="SP14" class="paragraph-anchor"></a><b>&#167;14. Quotation Boxes. </b>On the Z-machine, quotation boxes are produced by stretching the status line,
but on Glulx they usually occupy windows of their own. If it isn't possible
to create such a window, so that <span class="extract"><span class="extract-syntax">gg_quotewin</span></span> is zero below, the quotation
text just appears in the main window.

54
docs/CommandParserKit/S-prs.html
View file

@ -486,14 +486,32 @@ the text in the walk-through provided is fed into the buffer as if it had
been typed at the keyboard.)
</p>
<p class="commentary">If a <span class="extract"><span class="extract-syntax">fn</span></span> is provided, it is called to redraw the status line at the top of
the main text window.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">;</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax"> </span><span class="identifier-syntax">fn</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">DEBUG</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">TestKeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">TestKeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">, </span><span class="identifier-syntax">fn</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</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">VM_ReadKeyboard</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardMorePrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">, </span><span class="identifier-syntax">fn</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">KeyboardMorePrimitive</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax"> </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> </span><span class="identifier-syntax">ix</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">fn</span><span class="plain-syntax">) </span><span class="identifier-syntax">fn</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_ReadKeyboard</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</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">BasicInformKit</span><span class="plain-syntax">`</span><span class="identifier-syntax">ECHO_COMMANDS_CFGF</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"** "</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Iftrue</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHARSIZE</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">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">ix</span><span class="plain-syntax">=2: </span><span class="identifier-syntax">ix</span><span class="plain-syntax">&lt;=(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">-&gt;1)+1: </span><span class="identifier-syntax">ix</span><span class="plain-syntax">++) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">char</span><span class="plain-syntax">) </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">ix</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">ix</span><span class="plain-syntax">=0: </span><span class="identifier-syntax">ix</span><span class="plain-syntax">&lt;(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">--&gt;0): </span><span class="identifier-syntax">ix</span><span class="plain-syntax">++) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">char</span><span class="plain-syntax">) </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">--&gt;(1+</span><span class="identifier-syntax">ix</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"^"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>&#167;11. Reading the Command. </b>The <span class="extract"><span class="extract-syntax">Keyboard</span></span> routine actually receives the player's words, putting the
words in <span class="extract"><span class="extract-syntax">a_buffer</span></span> and their dictionary addresses in <span class="extract"><span class="extract-syntax">a_table</span></span>. It is
@ -538,8 +556,7 @@ yes/no questions and the like, without invoking the rest of the parser.
<span class="plain-syntax"> </span><span class="comment-syntax">Print the prompt, and read in the words and dictionary addresses</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">PrintPrompt</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">, </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="comment-syntax">Set nw to the number of words</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Iftrue</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHARSIZE</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
@ -788,17 +805,8 @@ fairly thorough description of its output, which is written into the
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</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">j</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"?"</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">Ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">TARGET_ZCODE</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">UnsignedCompare</span><span class="plain-syntax">(</span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">HDR_DICTIONARY</span><span class="plain-syntax">--&gt;0) &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax"> &amp;&amp;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">UnsignedCompare</span><span class="plain-syntax">(</span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">HDR_HIGHMEMORY</span><span class="plain-syntax">--&gt;0) &lt; </span><span class="constant-syntax">0</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">j</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">print</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_GLULX</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">-&gt;0 == </span><span class="constant-syntax">$60</span><span class="plain-syntax">) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">j</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">print</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_</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">VM_ProbablyDictionaryAddress</span><span class="plain-syntax">(</span><span class="identifier-syntax">j</span><span class="plain-syntax">)) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">j</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">print</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</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">num_words</span><span class="plain-syntax">-1) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">" / "</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">" ]^"</span><span class="plain-syntax">;</span>
@ -2677,7 +2685,7 @@ because we want to allow duplicates).
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">TARGET_ZCODE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">k</span><span class="plain-syntax"> = </span><span class="identifier-syntax">buffer</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">output_stream</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span><span class="plain-syntax"> </span><span class="identifier-syntax">k</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;1;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">address</span><span class="plain-syntax">) </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;1;</span>
<span class="plain-syntax"> @</span><span class="identifier-syntax">output_stream</span><span class="plain-syntax"> -3;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">k</span><span class="plain-syntax"> = </span><span class="identifier-syntax">k</span><span class="plain-syntax">--&gt;0;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">l</span><span class="plain-syntax">=</span><span class="identifier-syntax">i</span><span class="plain-syntax"> : </span><span class="identifier-syntax">l</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">i</span><span class="plain-syntax">+</span><span class="identifier-syntax">k</span><span class="plain-syntax"> : </span><span class="identifier-syntax">l</span><span class="plain-syntax">++) </span><span class="identifier-syntax">buffer</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">buffer</span><span class="plain-syntax">-&gt;(</span><span class="identifier-syntax">l</span><span class="plain-syntax">+2);</span>
@ -4079,15 +4087,13 @@ Manual}, 4th edition.
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">YesOrNo</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (::) {</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">TARGET_ZCODE</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">location</span><span class="plain-syntax"> == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> || </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="reserved-syntax">read</span><span class="plain-syntax"> </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse2</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">read</span><span class="plain-syntax"> </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse2</span><span class="plain-syntax"> </span><span class="identifier-syntax">DrawStatusLine</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">location</span><span class="plain-syntax"> == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> || </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</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">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">, </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Iftrue</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHARSIZE</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">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">-&gt;1;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_GLULX;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">location</span><span class="plain-syntax"> ~= </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> &amp;&amp; </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) ~= </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;0;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</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">j</span><span class="plain-syntax">) { </span><span class="comment-syntax">at least one word entered</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;1;</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">YES1__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">YES2__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">YES3__WD</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</span>

12
docs/DialogueKit/S-prg.html
View file

@ -661,19 +661,17 @@ this to be typed at the keyboard, then returns the choice made.
<span class="plain-syntax">[ </span><span class="identifier-syntax">DirectorPickANumber</span><span class="plain-syntax"> </span><span class="identifier-syntax">max</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> </span><span class="identifier-syntax">wa</span><span class="plain-syntax"> </span><span class="identifier-syntax">wl</span><span class="plain-syntax"> </span><span class="identifier-syntax">sign</span><span class="plain-syntax"> </span><span class="identifier-syntax">base</span><span class="plain-syntax"> </span><span class="identifier-syntax">digit_count</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> </span><span class="identifier-syntax">digit</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (::) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"&gt;"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">TARGET_ZCODE</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">location</span><span class="plain-syntax"> == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> || </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="reserved-syntax">read</span><span class="plain-syntax"> </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse2</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">read</span><span class="plain-syntax"> </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse2</span><span class="plain-syntax"> </span><span class="identifier-syntax">DrawStatusLine</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">location</span><span class="plain-syntax"> == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> || </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) == </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</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">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">, </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Iftrue</span><span class="plain-syntax"> </span><span class="identifier-syntax">CHARSIZE</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">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">-&gt;1;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wa</span><span class="plain-syntax"> = </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> + </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">-&gt;5;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wl</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">-&gt;4;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_GLULX;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">location</span><span class="plain-syntax"> ~= </span><span class="reserved-syntax">nothing</span><span class="plain-syntax"> &amp;&amp; </span><span class="reserved-syntax">parent</span><span class="plain-syntax">(</span><span class="identifier-syntax">player</span><span class="plain-syntax">) ~= </span><span class="reserved-syntax">nothing</span><span class="plain-syntax">) </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;0;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wa</span><span class="plain-syntax"> = </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax"> + </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;3;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wl</span><span class="plain-syntax"> = </span><span class="identifier-syntax">parse2</span><span class="plain-syntax">--&gt;2;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</span><span class="plain-syntax">; </span><span class="comment-syntax">TARGET_</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Endif</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">j</span><span class="plain-syntax">) { </span><span class="comment-syntax">at least one word entered</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">sign</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="identifier-syntax">base</span><span class="plain-syntax"> = </span><span class="constant-syntax">10</span><span class="plain-syntax">; </span><span class="identifier-syntax">digit_count</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><span class="identifier-syntax">wa</span><span class="plain-syntax">-&gt;0 ~= </span><span class="character-syntax">'-'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'$'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'0'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'1'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'2'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'3'</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="character-syntax">'4'</span>

3
docs/WorldModelKit/S-ord.html
View file

@ -651,8 +651,7 @@ same buffers for the final question as for game commands.
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">READ_FINAL_ANSWER_R</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">KeyboardPrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse</span><span class="plain-syntax">, </span><span class="identifier-syntax">DrawStatusLine</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">players_command</span><span class="plain-syntax"> = </span><span class="constant-syntax">100</span><span class="plain-syntax"> + </span><span class="identifier-syntax">WordCount</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">num_words</span><span class="plain-syntax"> = </span><span class="identifier-syntax">WordCount</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wn</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>

2
docs/WorldModelKit/S-prn.html
View file

@ -272,8 +272,6 @@ buffer and then altering the first character.
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=</span><span class="identifier-syntax">WORDSIZE</span><span class="plain-syntax">: </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">length</span><span class="plain-syntax">+</span><span class="identifier-syntax">WORDSIZE</span><span class="plain-syntax">: </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> (</span><span class="identifier-syntax">char</span><span class="plain-syntax">) </span><span class="identifier-syntax">StorageForShortName</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">Ifnot</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">length</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">SHORT_NAME_BUFFER_LEN</span><span class="plain-syntax">) </span><span class="identifier-syntax">length</span><span class="plain-syntax"> = </span><span class="identifier-syntax">SHORT_NAME_BUFFER_LEN</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="comment-syntax">ODO: length = glk_buffer_to_title_case_uni(StorageForShortName, SHORT_NAME_BUFFER_LEN, length, false);</span>
<span class="plain-syntax"> </span><span class="comment-syntax">ODO: glk_put_buffer_uni(StorageForShortName, length);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">length</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StorageForShortName</span><span class="plain-syntax">--&gt;0 = </span><span class="identifier-syntax">VM_LowerToUpperCase</span><span class="plain-syntax">(</span><span class="identifier-syntax">StorageForShortName</span><span class="plain-syntax">--&gt;0);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">glk_put_buffer_uni</span><span class="plain-syntax">(</span><span class="identifier-syntax">StorageForShortName</span><span class="plain-syntax">, </span><span class="identifier-syntax">length</span><span class="plain-syntax">);</span>

9
docs/WorldModelKit/S-tst.html
View file

@ -460,12 +460,11 @@ out the I6 command verb grammar for the supplied command.
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"(Testing.)^"</span><span class="plain-syntax">; </span><span class="identifier-syntax">say__p</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">TestKeyboardPrimitive</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> </span><span class="identifier-syntax">l</span><span class="plain-syntax"> </span><span class="identifier-syntax">spaced</span><span class="plain-syntax"> </span><span class="identifier-syntax">ch</span><span class="plain-syntax">;</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">TestKeyboardPrimitive</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax"> </span><span class="identifier-syntax">a_table</span><span class="plain-syntax"> </span><span class="identifier-syntax">fn</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> </span><span class="identifier-syntax">l</span><span class="plain-syntax"> </span><span class="identifier-syntax">spaced</span><span class="plain-syntax"> </span><span class="identifier-syntax">ch</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">test_sp</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">test_stack</span><span class="plain-syntax">--&gt;2 = </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="identifier-syntax">VM_ReadKeyboard</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">);</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">KeyboardMorePrimitive</span><span class="plain-syntax">(</span><span class="identifier-syntax">a_buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">a_table</span><span class="plain-syntax">, </span><span class="identifier-syntax">fn</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">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">test_stack</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">test_sp</span><span class="plain-syntax">-4);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> = </span><span class="identifier-syntax">test_stack</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">test_sp</span><span class="plain-syntax">-3);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">test_stack</span><span class="plain-syntax">--&gt;(</span><span class="identifier-syntax">test_sp</span><span class="plain-syntax">-1);</span>
@ -480,7 +479,7 @@ out the I6 command verb grammar for the supplied command.
<span class="plain-syntax"> #</span><span class="identifier-syntax">ifnot</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">ch</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">--&gt;</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">endif</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">ch</span><span class="plain-syntax"> == </span><span class="character-syntax">'/'</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">ch</span><span class="plain-syntax"> == </span><span class="character-syntax">'/'</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">spaced</span><span class="plain-syntax"> || (</span><span class="identifier-syntax">ch</span><span class="plain-syntax"> ~= </span><span class="character-syntax">' '</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> #</span><span class="identifier-syntax">iftrue</span><span class="plain-syntax"> (</span><span class="identifier-syntax">CHARSIZE</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">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="character-syntax">'['</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;(</span><span class="identifier-syntax">i</span><span class="plain-syntax">+1) == </span><span class="character-syntax">'/'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;(</span><span class="identifier-syntax">i</span><span class="plain-syntax">+2) == </span><span class="character-syntax">']'</span><span class="plain-syntax">)) {</span>

3
docs/building-module/2-eis.html
View file

@ -269,7 +269,8 @@ all conditionals are resolved.
<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><span class="identifier-syntax">dir_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">dir_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">IFDEF_I6RW</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">dir_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">dir_clarifier</span><span class="plain-syntax"> == </span><span class="constant-syntax">IFNDEF_I6RW</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">dir_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</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">dir_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</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">dir_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">child_node</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">expression_tokens</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-i6se.html#SP4" class="function-link"><span class="function-syntax">I6Errors::issue_at_node</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">dir_node</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"bare '#ifdef' or '#ifndef'"</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">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>

26
inform7/Figures/memory-diagnostics.txt
View file

@ -1,10 +1,10 @@
Total memory consumption was 137301K = 134 MB
Total memory consumption was 137315K = 134 MB
---- was used for 2100478 objects, in 372208 frames in 0 x 800K = 0K = 0 MB:
---- was used for 2100591 objects, in 372222 frames in 0 x 800K = 0K = 0 MB:
30.2% inter_tree_node_array 59 x 8192 = 483328 objects, 42534752 bytes
19.2% text_stream_array 4810 x 100 = 481000 objects, 27089920 bytes
17.8% linked_list 44813 objects, 25095280 bytes
19.2% text_stream_array 4811 x 100 = 481100 objects, 27095552 bytes
17.8% linked_list 44815 objects, 25096400 bytes
10.1% inter_symbol_array 134 x 1024 = 137216 objects, 14274752 bytes
9.7% inter_error_stash_array 105 x 1024 = 107520 objects, 13765920 bytes
7.5% parse_node 133417 objects, 10673360 bytes
@ -20,9 +20,9 @@ Total memory consumption was 137301K = 134 MB
1.3% vocabulary_entry_array 164 x 100 = 16400 objects, 1842048 bytes
1.1% dict_entry_array 481 x 100 = 48100 objects, 1554592 bytes
1.0% match_trie_array 11 x 1000 = 11000 objects, 1496352 bytes
1.0% inter_symbols_table 26707 objects, 1495592 bytes
1.0% inter_symbols_table 26711 objects, 1495816 bytes
1.0% i6_schema_array 24 x 100 = 2400 objects, 1440768 bytes
0.9% inter_package 26707 objects, 1281936 bytes
0.9% inter_package 26711 objects, 1282128 bytes
0.8% map_data 672 objects, 1128960 bytes
0.7% id_body 955 objects, 1092520 bytes
0.7% adjective_meaning 208 objects, 1030016 bytes
@ -36,13 +36,13 @@ Total memory consumption was 137301K = 134 MB
0.3% local_variable_array 48 x 100 = 4800 objects, 462336 bytes
0.2% verb_usage 1148 objects, 394912 bytes
0.2% rule 472 objects, 370048 bytes
0.2% dictionary 7688 objects, 369024 bytes
0.2% dictionary 7689 objects, 369072 bytes
0.2% verb_form 388 objects, 350752 bytes
0.2% noun 2388 objects, 286560 bytes
0.1% compilation_subtask 3369 objects, 269520 bytes
0.1% inter_annotation_array 2 x 8192 = 16384 objects, 262208 bytes
0.1% inference_subject 667 objects, 261464 bytes
0.1% vanilla_function 3742 objects, 239488 bytes
0.1% vanilla_function 3744 objects, 239616 bytes
0.1% binary_predicate 326 objects, 172128 bytes
0.1% hierarchy_location 1179 objects, 169776 bytes
0.1% linguistic_stock_item 3331 objects, 159888 bytes
@ -249,17 +249,17 @@ Total memory consumption was 137301K = 134 MB
---- loop_over_scope 1 object, 40 bytes
---- I6_generation_data 1 object, 40 bytes
99.9% was used for memory not allocated for objects:
100.0% was used for memory not allocated for objects:
61.8% text stream storage 86992816 bytes in 504029 claims
3.8% dictionary storage 5360640 bytes in 7688 claims
61.8% text stream storage 87006012 bytes in 504091 claims
3.8% dictionary storage 5361152 bytes in 7689 claims
---- sorting 2792 bytes in 403 claims
5.1% source text 7200000 bytes in 3 claims
7.6% source text details 10800000 bytes in 2 claims
0.1% documentation fragments 262144 bytes in 1 claim
---- linguistic stock array 81920 bytes in 2 claims
---- small word set array 105600 bytes in 22 claims
3.2% inter symbols storage 4587072 bytes in 28082 claims
3.2% inter symbols storage 4587584 bytes in 28086 claims
11.9% inter bytecode storage 16761584 bytes in 15 claims
4.4% inter links storage 6222976 bytes in 11 claims
0.1% inter tree location list storage 191232 bytes in 32 claims
@ -269,5 +269,5 @@ Total memory consumption was 137301K = 134 MB
---- code generation workspace for objects 3480 bytes in 19 claims
0.1% emitter array storage 280672 bytes in 2002 claims
-136.-7% was overhead - -192283472 bytes = -187776K = -183 MB
-136.-7% was overhead - -192290816 bytes = -187784K = -183 MB

58
inform7/Figures/timings-diagnostics.txt
View file

@ -1,32 +1,32 @@
100.0% in inform7 run
69.6% in compilation to Inter
49.0% in //Sequence::undertake_queued_tasks//
4.9% in //MajorNodes::pre_pass//
3.3% in //MajorNodes::pass_1//
1.7% in //ImperativeDefinitions::assess_all//
1.5% in //RTKindConstructors::compile//
1.3% in //RTPhrasebook::compile_entries//
0.9% in //Sequence::lint_inter//
0.5% in //ImperativeDefinitions::compile_first_block//
0.5% in //MajorNodes::pass_2//
0.5% in //World::stage_V//
0.3% in //InferenceSubjects::emit_all//
0.3% in //Sequence::undertake_queued_tasks//
0.3% in //Sequence::undertake_queued_tasks//
0.1% in //CompletionModule::compile//
0.1% in //RTKindConstructors::compile_permissions//
0.1% in //Task::make_built_in_kind_constructors//
3.0% not specifically accounted for
26.7% in running Inter pipeline
11.1% in step 14/15: generate inform6 -> auto.inf
5.7% in step 5/15: load-binary-kits
5.1% in step 6/15: make-synoptic-module
1.7% in step 9/15: make-identifiers-unique
0.3% in step 12/15: eliminate-redundant-operations
0.3% in step 4/15: compile-splats
0.3% in step 7/15: shorten-wiring
0.3% in step 8/15: detect-indirect-calls
0.1% in step 11/15: eliminate-redundant-labels
68.8% in compilation to Inter
48.8% in //Sequence::undertake_queued_tasks//
4.8% in //MajorNodes::pre_pass//
3.2% in //MajorNodes::pass_1//
1.8% in //ImperativeDefinitions::assess_all//
1.4% in //RTKindConstructors::compile//
1.4% in //RTPhrasebook::compile_entries//
1.0% in //Sequence::lint_inter//
0.6% in //ImperativeDefinitions::compile_first_block//
0.6% in //World::stage_V//
0.4% in //MajorNodes::pass_2//
0.4% in //Sequence::undertake_queued_tasks//
0.4% in //Sequence::undertake_queued_tasks//
0.2% in //CompletionModule::compile//
0.2% in //InferenceSubjects::emit_all//
0.2% in //RTKindConstructors::compile_permissions//
0.2% in //Task::make_built_in_kind_constructors//
3.2% not specifically accounted for
27.8% in running Inter pipeline
11.8% in step 14/15: generate inform6 -> auto.inf
6.0% in step 5/15: load-binary-kits
5.2% in step 6/15: make-synoptic-module
1.8% in step 9/15: make-identifiers-unique
0.4% in step 12/15: eliminate-redundant-operations
0.4% in step 4/15: compile-splats
0.4% in step 7/15: shorten-wiring
0.4% in step 8/15: detect-indirect-calls
0.2% in step 11/15: eliminate-redundant-labels
1.2% not specifically accounted for
3.1% in supervisor
3.0% in supervisor
0.4% not specifically accounted for

21
inform7/Internal/Inter/Architecture16Kit/Sections/Input Output.i6t
View file

@ -23,6 +23,18 @@ Global dict_start;
Global dict_entry_size;
Global dict_end;
@h Dictionary words.
This tests whether an address is probably that of a dictionary word. It's used
only for debugging output, so the false positives here (where an address is in
the dictionary table, but mid-word) really do not matter.
=
[ VM_ProbablyDictionaryAddress addr;
if (UnsignedCompare(addr, HDR_DICTIONARY-->0) >= 0 &&
UnsignedCompare(addr, HDR_HIGHMEMORY-->0) < 0) rtrue;
rfalse;
];
@h Keyboard Input.
The VM must provide three routines for keyboard input:
@ -49,13 +61,8 @@ to document all of that.
];
[ VM_KeyDelay_Interrupt; rtrue; ];
[ VM_ReadKeyboard a_buffer a_table i;
read a_buffer a_table;
if (BasicInformKit`ECHO_COMMANDS_CFGF) {
print "** ";
for (i=2: i<=(a_buffer->1)+1: i++) print (char) a_buffer->i;
print "^";
}
[ VM_ReadKeyboard a_buffer a_table;
read a_buffer a_table;
];
@h Buffer Functions.

2
inform7/Internal/Inter/Architecture16Kit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "Architecture16Kit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"compatibility": "16-bit",
"kit-details": {

21
inform7/Internal/Inter/Architecture32Kit/Sections/Input Output.i6t
View file

@ -48,6 +48,16 @@ Constant GG_SCRIPTFREF_ROCK 401;
Constant GG_FOREGROUNDCHAN_ROCK 410;
Constant GG_BACKGROUNDCHAN_ROCK 411;
@h Dictionary words.
This tests whether an address is probably that of a dictionary word. It's used
only for debugging output, so the false positives here really do not matter.
=
[ VM_ProbablyDictionaryAddress addr;
if (addr->0 == $60) rtrue;
rfalse;
];
@h Keyboard Input.
The VM must provide three routines for keyboard input:
@ -154,8 +164,7 @@ to document all of that.
if (ix == 2) {
key = gg_arguments-->0;
done = true;
}
else if (ix >= 0 && gg_event-->0 == 1 or 2) {
} else if (ix >= 0 && gg_event-->0 == 1 or 2) {
key = gg_event-->2;
done = true;
}
@ -173,8 +182,7 @@ to document all of that.
glk_stream_close(gg_commandstr, 0);
gg_commandstr = 0;
gg_command_reading = false;
}
else {
} else {
! Trim the trailing newline
if ((a_buffer+WORDSIZE)-->(done-1) == 10) done = done-1;
a_buffer-->0 = done;
@ -213,11 +221,6 @@ to document all of that.
glk_window_close(gg_quotewin, 0);
gg_quotewin = 0;
}
if (BasicInformKit`ECHO_COMMANDS_CFGF) {
print "** ";
for (ix=0: ix<(a_buffer-->0): ix++) print (char) a_buffer-->(1+ix);
print "^";
}
];
@h Buffer Functions.

2
inform7/Internal/Inter/Architecture32Kit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "Architecture32Kit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"compatibility": "32-bit",
"kit-details": {

2
inform7/Internal/Inter/BasicInformExtrasKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "BasicInformExtrasKit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"kit-details": {
"has-priority": 1

2
inform7/Internal/Inter/BasicInformKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "BasicInformKit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"needs": [ {
"unless": {

53
inform7/Internal/Inter/CommandParserKit/Sections/Parser.i6t
View file

@ -413,15 +413,32 @@ uses a hacked version to allow TEST commands to work. (When a TEST is running,
the text in the walk-through provided is fed into the buffer as if it had
been typed at the keyboard.)
If a |fn| is provided, it is called to redraw the status line at the top of
the main text window.
=
[ KeyboardPrimitive a_buffer a_table;
[ KeyboardPrimitive a_buffer a_table fn;
#Ifdef DEBUG;
return TestKeyboardPrimitive(a_buffer, a_table);
TestKeyboardPrimitive(a_buffer, a_table, fn);
#Ifnot;
return VM_ReadKeyboard(a_buffer, a_table);
KeyboardMorePrimitive(a_buffer, a_table, fn);
#Endif;
];
[ KeyboardMorePrimitive a_buffer a_table fn ix;
if (fn) fn();
VM_ReadKeyboard(a_buffer, a_table);
if (BasicInformKit`ECHO_COMMANDS_CFGF) {
print "** ";
#Iftrue CHARSIZE == 1;
for (ix=2: ix<=(a_buffer->1)+1: ix++) print (char) a_buffer->ix;
#Ifnot;
for (ix=0: ix<(a_buffer-->0): ix++) print (char) a_buffer-->(1+ix);
#Endif;
print "^";
}
];
@h Reading the Command.
The |Keyboard| routine actually receives the player's words, putting the
words in |a_buffer| and their dictionary addresses in |a_table|. It is
@ -463,8 +480,7 @@ The return value is the number of words typed.
! Print the prompt, and read in the words and dictionary addresses
PrintPrompt();
DrawStatusLine();
KeyboardPrimitive(a_buffer, a_table);
KeyboardPrimitive(a_buffer, a_table, DrawStatusLine);
! Set nw to the number of words
#Iftrue CHARSIZE == 1;
@ -711,17 +727,8 @@ Get the input, do OOPS and AGAIN.
#Endif;
if (j == 0) print "?";
else {
#Ifdef TARGET_ZCODE;
if (UnsignedCompare(j, HDR_DICTIONARY-->0) >= 0 &&
UnsignedCompare(j, HDR_HIGHMEMORY-->0) < 0)
print (address) j;
else print j;
#Ifnot; ! TARGET_GLULX
if (j->0 == $60) print (address) j;
else print j;
#Endif; ! TARGET_
}
else if (VM_ProbablyDictionaryAddress(j)) print (address) j;
else print j;
if (i ~= num_words-1) print " / ";
}
print " ]^";
@ -2589,7 +2596,7 @@ because we want to allow duplicates).
#Ifdef TARGET_ZCODE;
k = buffer + i;
@output_stream 3 k;
print (address) parse2-->1;
print (address) parse2-->1;
@output_stream -3;
k = k-->0;
for (l=i : l<i+k : l++) buffer->l = buffer->(l+2);
@ -3967,15 +3974,13 @@ Manual}, 4th edition.
=
[ YesOrNo i j;
for (::) {
#Ifdef TARGET_ZCODE;
if (location == nothing || parent(player) == nothing) read buffer2 parse2;
else read buffer2 parse2 DrawStatusLine;
if (location == nothing || parent(player) == nothing) KeyboardPrimitive(buffer2, parse2);
else KeyboardPrimitive(buffer2, parse2, DrawStatusLine);
#Iftrue CHARSIZE == 1;
j = parse2->1;
#Ifnot; ! TARGET_GLULX;
if (location ~= nothing && parent(player) ~= nothing) DrawStatusLine();
KeyboardPrimitive(buffer2, parse2);
#Ifnot;
j = parse2-->0;
#Endif; ! TARGET_
#Endif;
if (j) { ! at least one word entered
i = parse2-->1;
if (i == YES1__WD or YES2__WD or YES3__WD) rtrue;

2
inform7/Internal/Inter/CommandParserKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "CommandParserKit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"needs": [ {
"need": {

12
inform7/Internal/Inter/DialogueKit/Sections/Programs.i6t
View file

@ -588,19 +588,17 @@ this to be typed at the keyboard, then returns the choice made.
[ DirectorPickANumber max i j wa wl sign base digit_count n digit;
for (::) {
print ">";
#Ifdef TARGET_ZCODE;
if (location == nothing || parent(player) == nothing) read buffer2 parse2;
else read buffer2 parse2 DrawStatusLine;
if (location == nothing || parent(player) == nothing) KeyboardPrimitive(buffer2, parse2);
else KeyboardPrimitive(buffer2, parse2, DrawStatusLine);
#Iftrue CHARSIZE == 1;
j = parse2->1;
wa = buffer2 + parse2->5;
wl = parse2->4;
#Ifnot; ! TARGET_GLULX;
if (location ~= nothing && parent(player) ~= nothing) DrawStatusLine();
KeyboardPrimitive(buffer2, parse2);
#Ifnot;
j = parse2-->0;
wa = buffer2 + parse2-->3;
wl = parse2-->2;
#Endif; ! TARGET_
#Endif;
if (j) { ! at least one word entered
sign = 1; base = 10; digit_count = 0;
if (wa->0 ~= '-' or '$' or '0' or '1' or '2' or '3' or '4'

2
inform7/Internal/Inter/EnglishLanguageKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "EnglishLanguageKit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"needs": [ {
"need": {

3
inform7/Internal/Inter/WorldModelKit/Sections/OrderOfPlay.i6t
View file

@ -593,8 +593,7 @@ same buffers for the final question as for game commands.
=
[ READ_FINAL_ANSWER_R;
DrawStatusLine();
KeyboardPrimitive(buffer, parse);
KeyboardPrimitive(buffer, parse, DrawStatusLine);
players_command = 100 + WordCount();
num_words = WordCount();
wn = 1;

2
inform7/Internal/Inter/WorldModelKit/Sections/Printing.i6t
View file

@ -220,8 +220,6 @@ Array StorageForShortName --> SHORT_NAME_BUFFER_LEN;
for (i=WORDSIZE: i<length+WORDSIZE: i++) print (char) StorageForShortName->i;
#Ifnot;
if (length > SHORT_NAME_BUFFER_LEN) length = SHORT_NAME_BUFFER_LEN;
!TODO: length = glk_buffer_to_title_case_uni(StorageForShortName, SHORT_NAME_BUFFER_LEN, length, false);
!TODO: glk_put_buffer_uni(StorageForShortName, length);
if (length)
StorageForShortName-->0 = VM_LowerToUpperCase(StorageForShortName-->0);
glk_put_buffer_uni(StorageForShortName, length);

9
inform7/Internal/Inter/WorldModelKit/Sections/Tests.i6t
View file

@ -408,12 +408,11 @@ Global test_sp = 0;
}
print "(Testing.)^"; say__p = 1;
];
[ TestKeyboardPrimitive a_buffer a_table p i j l spaced ch;
[ TestKeyboardPrimitive a_buffer a_table fn p i j l spaced ch;
if (test_sp == 0) {
test_stack-->2 = 1;
return VM_ReadKeyboard(a_buffer, a_table);
}
else {
KeyboardMorePrimitive(a_buffer, a_table, fn);
} else {
p = test_stack-->(test_sp-4);
i = test_stack-->(test_sp-3);
l = test_stack-->(test_sp-1);
@ -428,7 +427,7 @@ Global test_sp = 0;
#ifnot;
ch = p-->i;
#endif;
if (ch == '/') break;
if (ch == '/') break;
if (spaced || (ch ~= ' ')) {
#iftrue (CHARSIZE == 1);
if ((p->i == '[') && (p->(i+1) == '/') && (p->(i+2) == ']')) {

2
inform7/Internal/Inter/WorldModelKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "WorldModelKit",
"version": "10.2.0-beta+6W58"
"version": "10.2.0-beta+6W59"
},
"needs": [ {
"need": {

14
inform7/Tests/Test Cases/_Results_Ideal/Dialogue.txt
View file

@ -43,6 +43,7 @@
(Option 2) My favourite cheese is camembert.
> >
** 2
My favourite cheese is camembert.
(Okay, select from white seeded choice, black choice and poison choice here.)
@ -51,6 +52,7 @@
(Option 3) My preferred grapes are arsenic-laced.
> > Laboratory
** 1
My preferred grapes are white yet seeded.
You would appear to have selected: camembert choice and white seeded choice.
@ -278,7 +280,7 @@
** perform fourth wall breaker beat
This is all just fiction.
> > Laboratory
> > Experimental Zone
** w
Helmuth: "Are you, or are you in league with, Star A Star of the Galactic Patrol?"
@ -286,7 +288,8 @@
(Option 1) No.
(Option 2) I don't know who that is.
> > Laboratory
> > Experimental Zone
** 1
No.
Gharlane: "A likely story."
@ -294,7 +297,8 @@
(Okay, select from choice-21 here.)
(Option 1) I don't know who that is.
> > Laboratory
> > Experimental Zone
** 1
I don't know who that is.
Gharlane: "A mere worm."
@ -303,6 +307,7 @@
(Option 1) Admit frankly that you've run out of answers.
> > Experimental Zone
** 1
Admit frankly that you've run out of answers.
Gharlane: "Well, I've always respected honesty."
@ -344,4 +349,5 @@
> > Laboratory
** quit
> Are you sure you want to quit?
> Are you sure you want to quit? Laboratory
** y

8
inform7/Tests/Test Cases/_Results_Ideal/FastRouteFinding1.txt
View file

@ -1,12 +1,12 @@
Barn
Welcome
An Interactive Fiction
Release 1 / Serial number 150512 / Inform 7 build 6M22 (I6/v6.33 lib 6/12N) SD
Release 1 / Serial number 160428 / Inform 7 v10.2.0 / D
Barn
You can see Larry, Curly, Moe, George, Mike, Bob, Jayson, Crito and Pheidippides here.
> > Encircled Plateau
> > Barn
(Testing.)
>[1] go to plateau
@ -244,7 +244,7 @@
Jayson hikes from Landing to Farm in 9 moves.
Crito arrives from the east.
Encircled Plateau
Barn
Crito goes west.
Crito hikes from Rookery to Cathedral in 11 moves.
@ -481,7 +481,7 @@
Curly hikes from Dungbeetle Feeding Station to Dangerous Descent in 7 moves.
Moe hikes from Dungbeetle Harnessing Station to Divine Palace in 2 moves.
Encircled Plateau
Barn
George hikes from Vista Over Clouds to Scrubland in 7 moves.
Mike hikes from Feather Heap to Wilderness in 3 moves.

15
inform7/Tests/Test Cases/_Results_Ideal/LBW.txt
View file

@ -19,9 +19,11 @@
(5) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** x bat
(Please type an option in the range 1 to 5 and press return.)
> > Cricket History Museum
** 4
Look at the watch Q gave you.
The watch says it is now 9:00 am in Melbourne.
@ -33,6 +35,7 @@
(5) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** 1
Fix Honey with your Scottish stare.
Honey looks suddenly abashed and resolves to tell the truth.
@ -43,6 +46,7 @@
(4) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** 1
Listen politely.
Honey Maiden: "The first ever cricket match is thought to have taken place in 18th-century Hampshire."
@ -91,9 +95,11 @@
(5) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** x bat
(Please type an option in the range 1 to 5 and press return.)
> > Cricket History Museum
** 3
Enquire about the bat and ball.
Honey Maiden tries to pick up the bat, but it's magically glued down!
@ -110,6 +116,7 @@
(4) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** 2
Listen politely.
Honey Maiden: "The first ever cricket match is thought to have taken place in stone-age Dresden."
@ -172,6 +179,7 @@
(5) Make feeble wordplay, light of it, and an escape.
> > Cricket History Museum
** 5
Make feeble wordplay, light of it, and an escape.
You: "Sorry, Honey, it's time for a "run out"."
@ -180,6 +188,7 @@
(2) Use my rocket-pack.
> > Cricket History Museum
** 1
Hurl myself at the window.
Honey Maiden: "That glass is strong enough to withstand a six from a full toss at a distance of ten feet! You wouldn't stand a chance."
@ -187,6 +196,7 @@
(1) Use my rocket-pack.
> > Cricket History Museum
** 1
Use my rocket-pack.
Is this supposed to be like the cold open of Thunderball, where you're suddenly carrying a huge jet-pack even though you came into the room in a regular dinner suit?
@ -195,6 +205,7 @@
(2) No.
> > Cricket History Museum
** 2
No.
Then find some other way out of here.
@ -202,6 +213,7 @@
(1) Admit to being out of ideas.
> > Cricket History Museum
** 1
Admit to being out of ideas.
Honey Maiden: "I have permitted this charade for one reason only, Mr Bond, to demonstrate its futility."
@ -210,4 +222,5 @@
> > Cricket History Museum
** quit
> Are you sure you want to quit?
> Are you sure you want to quit? Cricket History Museum
** y

1
inform7/Tests/Test Cases/_Results_Ideal/TalkingAbout.txt
View file

@ -14,6 +14,7 @@
(2). Any view on whether science is a social construct?
> > Laboratory
** 2
You: "Any view on whether science is a social construct?"
Liza: "Only that it's not a falsifiable hypothesis."

3
inter/building-module/Chapter 2/Emitting Inter Schemas.w
View file

@ -177,7 +177,8 @@ all conditionals are resolved.
@<Work out what the condition is@> =
if ((dir_node->dir_clarifier == IFDEF_I6RW) ||
(dir_node->dir_clarifier == IFNDEF_I6RW)) {
if (dir_node->child_node == NULL) {
if ((dir_node->child_node == NULL) ||
(dir_node->child_node->expression_tokens == NULL)) {
I6Errors::issue_at_node(dir_node, I"bare '#ifdef' or '#ifndef'");
return FALSE;
}

16
resources/Documentation/Examples/_Results_Ideal/Wight.txt
View file

@ -1,7 +1,7 @@
Crypt 0/1
The Unexamined Life
An Interactive Fiction
Release 1 / Serial number 150512 / Inform 7 build 6M22 (I6/v6.33 lib 6/12N) SD
Release 1 / Serial number 160428 / Inform 7 v10.2.0 / D
Crypt
This squat, barrel-vaulted chamber runs roughly north-south. Along either side are the graves of Saxon kings and early bishops of the church long since gone to dust -- one tomb in particular looks undisturbed.
@ -16,4 +16,16 @@
>[1] hint about wight
You're missing an object that might be useful to resolving this problem.
> Shall I go on? >
Shall I go on? > [2] north
Please answer yes or no.> [3] get bar
Please answer yes or no.> [4] south
Please answer yes or no.> [5] open tomb
Please answer yes or no.> [6] get dagger
Please answer yes or no.> [7] south
Please answer yes or no.> [8] hint about wight
Please answer yes or no.> [9] read inscription
Please answer yes or no.> [10] hint about wight
Please answer yes or no.> [11] attack wight
Please answer yes or no.> [12] throw dagger at wight
Please answer yes or no.> [13] south
> Please answer yes or no.>