ifhub/inform7
1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-05-03 17:49:39 +03:00
Code Issues Projects Releases Wiki Activity

Tidying up

Browse source
This commit is contained in:
Graham Nelson 2024-03-12 11:37:45 +00:00
parent 8ba38acec7
commit d4a5c98840
10 changed files with 252 additions and 183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -64,7 +64,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. Transcript support</a></li><li><a href="S-io.html#SP2">&#167;2. Dictionary Parameters</a></li><li><a href="S-io.html#SP3">&#167;3. Variables and Arrays</a></li><li><a href="S-io.html#SP4">&#167;4. Dictionary words</a></li><li><a href="S-io.html#SP5">&#167;5. Keyboard Input</a></li><li><a href="S-io.html#SP6">&#167;6. Buffer Functions</a></li><li><a href="S-io.html#SP7">&#167;7. Dictionary Functions</a></li><li><a href="S-io.html#SP8">&#167;8. Command Tables</a></li><li><a href="S-io.html#SP9">&#167;9. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP10">&#167;10. Action functions</a></li><li><a href="S-io.html#SP11">&#167;11. The Screen</a></li><li><a href="S-io.html#SP12">&#167;12. Window Colours</a></li><li><a href="S-io.html#SP13">&#167;13. Main Window</a></li><li><a href="S-io.html#SP14">&#167;14. Status Line</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Transcript support</a></li><li><a href="S-io.html#SP2">&#167;2. Dictionary Parameters</a></li><li><a href="S-io.html#SP3">&#167;3. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP4">&#167;4. Variables and Arrays</a></li><li><a href="S-io.html#SP5">&#167;5. Dictionary words</a></li><li><a href="S-io.html#SP6">&#167;6. Keyboard Input</a></li><li><a href="S-io.html#SP7">&#167;7. Buffer Functions</a></li><li><a href="S-io.html#SP8">&#167;8. Dictionary Functions</a></li><li><a href="S-io.html#SP9">&#167;9. Command Tables</a></li><li><a href="S-io.html#SP10">&#167;10. Action functions</a></li><li><a href="S-io.html#SP11">&#167;11. The Screen</a></li><li><a href="S-io.html#SP12">&#167;12. Window Colours</a></li><li><a href="S-io.html#SP13">&#167;13. Main Window</a></li><li><a href="S-io.html#SP14">&#167;14. Status Line</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Transcript support. </b>This is a mode in which the transcript of text in the main window is being
written out to an external file.
@ -92,7 +92,17 @@ only if scripting is on.
<span class="plain-syntax"> </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Dictionary Parameters. </b></p>
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. Dictionary Parameters. </b>Each word in the dictionary data structure has two metadata fields, known
for traditional Inform 6 reasons as "dictionary parameters 1 and 2". Number 1
is a bitmap: some of the higher bits are written by the I6 compiler only when
certain compile options are set, but they will be for the code which I7
generates. Bit 6 is currently never written by I6; bit 5, marking singular
nouns, is never used by this parser.
</p>
<p class="commentary">(For speed reasons, reading of <span class="extract"><span class="extract-syntax">DICTPAR1_NOUN</span></span> and <span class="extract"><span class="extract-syntax">DICTPAR1_PREP</span></span> is done
directly by <span class="extract"><span class="extract-syntax">ParserKit</span></span> rather than by calling functions here.)
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> #</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax"> = </span><span class="constant-syntax">6</span><span class="plain-syntax">;</span>
@ -106,8 +116,40 @@ only if scripting is on.
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_BIT6</span><span class="plain-syntax"> = </span><span class="constant-syntax">32</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_TRUNC</span><span class="plain-syntax"> = </span><span class="constant-syntax">64</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_NOUN</span><span class="plain-syntax"> = </span><span class="constant-syntax">128</span><span class="plain-syntax">;</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WordMarkedAsVerb</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</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">w</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</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>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WordMarkedAsMeta</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</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">w</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_META</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>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WorkMarkedAsUntruncatedPlural</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> </span><span class="identifier-syntax">b</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">w</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">b</span><span class="plain-syntax"> = </span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</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">b</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">DICTPAR1_TRUNC</span><span class="plain-syntax">) </span><span class="reserved-syntax">rfalse</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">b</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">DICTPAR1_PLURAL</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</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. Variables and Arrays. </b></p>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Extracting Verb Numbers. </b>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 tools for dumping dictionaries from Infocom
story files; by using the Infocom format for dictionary tables, Inform's life
was easier.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">DictionaryWordToVerbNum</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">$ff</span><span class="plain-syntax">-(</span><span class="identifier-syntax">w</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="SP4" class="paragraph-anchor"></a><b>&#167;4. Variables and Arrays. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="identifier-syntax">Global</span><span class="plain-syntax"> </span><span class="identifier-syntax">xcommsdir</span><span class="plain-syntax">; </span><span class="comment-syntax">true if command recording is on</span>
@ -124,7 +166,7 @@ only if scripting is on.
<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="SP4" class="paragraph-anchor"></a><b>&#167;4. Dictionary words. </b>This tests whether an address is probably that of a dictionary word. It's used
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. 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>
@ -136,7 +178,7 @@ the dictionary table, but mid-word) really do not matter.
<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="SP5" class="paragraph-anchor"></a><b>&#167;5. Keyboard Input. </b>The VM must provide three routines for keyboard input:
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. 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
@ -167,7 +209,7 @@ to document all of that.
<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>
</pre>
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. 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
@ -230,7 +272,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="SP7" class="paragraph-anchor"></a><b>&#167;7. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. 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,
@ -256,7 +298,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="SP8" class="paragraph-anchor"></a><b>&#167;8. Command Tables. </b>The VM is also generated containing a data structure for the grammar
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. 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
@ -275,27 +317,6 @@ 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="SP9" class="paragraph-anchor"></a><b>&#167;9. 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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
</p>
<p class="commentary">But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">DictionaryWordToVerbNum</span><span class="plain-syntax"> </span><span class="identifier-syntax">dword</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">$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="SP10" class="paragraph-anchor"></a><b>&#167;10. Action functions. </b>This looks up the address of a function like <span class="extract"><span class="extract-syntax">TakeSub</span></span> from the table of
"action subroutines".
</p>

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

@ -64,7 +64,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. Rocks</a></li><li><a href="S-io.html#SP2">&#167;2. Transcript support</a></li><li><a href="S-io.html#SP3">&#167;3. Dictionary Parameters</a></li><li><a href="S-io.html#SP4">&#167;4. Variables and Arrays</a></li><li><a href="S-io.html#SP5">&#167;5. Dictionary words</a></li><li><a href="S-io.html#SP6">&#167;6. Keyboard Input</a></li><li><a href="S-io.html#SP7">&#167;7. Buffer Functions</a></li><li><a href="S-io.html#SP8">&#167;8. Dictionary Functions</a></li><li><a href="S-io.html#SP9">&#167;9. Command Tables</a></li><li><a href="S-io.html#SP10">&#167;10. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP11">&#167;11. Action functions</a></li><li><a href="S-io.html#SP12">&#167;12. Glulx-Only Printing Routines</a></li><li><a href="S-io.html#SP13">&#167;13. The Screen</a></li><li><a href="S-io.html#SP14">&#167;14. Window Colours</a></li><li><a href="S-io.html#SP15">&#167;15. Main Window</a></li><li><a href="S-io.html#SP16">&#167;16. Status Line</a></li><li><a href="S-io.html#SP17">&#167;17. Quotation Boxes</a></li></ul><hr class="tocbar">
<ul class="toc"><li><a href="S-io.html#SP1">&#167;1. Rocks</a></li><li><a href="S-io.html#SP2">&#167;2. Transcript support</a></li><li><a href="S-io.html#SP3">&#167;3. Dictionary Parameters</a></li><li><a href="S-io.html#SP4">&#167;4. Extracting Verb Numbers</a></li><li><a href="S-io.html#SP5">&#167;5. Variables and Arrays</a></li><li><a href="S-io.html#SP6">&#167;6. Dictionary words</a></li><li><a href="S-io.html#SP7">&#167;7. Keyboard Input</a></li><li><a href="S-io.html#SP8">&#167;8. Buffer Functions</a></li><li><a href="S-io.html#SP9">&#167;9. Dictionary Functions</a></li><li><a href="S-io.html#SP10">&#167;10. Command Tables</a></li><li><a href="S-io.html#SP11">&#167;11. Action functions</a></li><li><a href="S-io.html#SP12">&#167;12. Glulx-Only Printing Routines</a></li><li><a href="S-io.html#SP13">&#167;13. The Screen</a></li><li><a href="S-io.html#SP14">&#167;14. Window Colours</a></li><li><a href="S-io.html#SP15">&#167;15. Main Window</a></li><li><a href="S-io.html#SP16">&#167;16. Status Line</a></li><li><a href="S-io.html#SP17">&#167;17. Quotation Boxes</a></li></ul><hr class="tocbar">
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>&#167;1. Rocks. </b>These are unique ID codes used to mark resources; think of them as inedible
cookies.
@ -126,7 +126,17 @@ only if scripting is on: this always succeeds.
<span class="plain-syntax"> </span><span class="reserved-syntax">rtrue</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. Dictionary Parameters. </b></p>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. Dictionary Parameters. </b>Each word in the dictionary data structure has two metadata fields, known
for traditional Inform 6 reasons as "dictionary parameters 1 and 2". Number 1
is a bitmap: some of the higher bits are written by the I6 compiler only when
certain compile options are set, but they will be for the code which I7
generates. Bit 6 is currently never written by I6; bit 5, marking singular
nouns, is never used by this parser.
</p>
<p class="commentary">(For speed reasons, reading of <span class="extract"><span class="extract-syntax">DICTPAR1_NOUN</span></span> and <span class="extract"><span class="extract-syntax">DICTPAR1_PREP</span></span> is done
directly by <span class="extract"><span class="extract-syntax">ParserKit</span></span> rather than by calling functions here.)
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICT_ENTRY_BYTES</span><span class="plain-syntax"> = </span><span class="constant-syntax">12</span><span class="plain-syntax">+</span><span class="identifier-syntax">DICT_WORD_SIZE</span><span class="plain-syntax">*</span><span class="identifier-syntax">WORDSIZE</span><span class="plain-syntax">;</span>
@ -141,8 +151,51 @@ only if scripting is on: this always succeeds.
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_BIT6</span><span class="plain-syntax"> = </span><span class="constant-syntax">32</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_TRUNC</span><span class="plain-syntax"> = </span><span class="constant-syntax">64</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Constant</span><span class="plain-syntax"> </span><span class="identifier-syntax">DICTPAR1_NOUN</span><span class="plain-syntax"> = </span><span class="constant-syntax">128</span><span class="plain-syntax">;</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WordMarkedAsVerb</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</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">w</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</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>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WordMarkedAsMeta</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</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">w</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_META</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>
<span class="plain-syntax">[ </span><span class="identifier-syntax">WorkMarkedAsUntruncatedPlural</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> </span><span class="identifier-syntax">b</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">w</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">b</span><span class="plain-syntax"> = </span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</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">b</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">DICTPAR1_TRUNC</span><span class="plain-syntax">) </span><span class="reserved-syntax">rfalse</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">b</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">DICTPAR1_PLURAL</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</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. Variables and Arrays. </b></p>
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>&#167;4. 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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
</p>
<p class="commentary">But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">DictionaryWordToVerbNum</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> = </span><span class="identifier-syntax">w</span><span class="plain-syntax"> + #</span><span class="identifier-syntax">dict_par2</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">aloads</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax"> = </span><span class="constant-syntax">$ffff</span><span class="plain-syntax">-</span><span class="identifier-syntax">verbnum</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">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Variables and Arrays. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">Array</span><span class="plain-syntax"> </span><span class="identifier-syntax">gg_event</span><span class="plain-syntax"> --&gt; </span><span class="constant-syntax">4</span><span class="plain-syntax">;</span>
@ -166,7 +219,7 @@ only if scripting is on: this always succeeds.
<span class="reserved-syntax">Array</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse</span><span class="plain-syntax"> --&gt; </span><span class="identifier-syntax">PARSE_BUFFER_LEN</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">Array</span><span class="plain-syntax"> </span><span class="identifier-syntax">parse2</span><span class="plain-syntax"> --&gt; </span><span class="identifier-syntax">PARSE_BUFFER_LEN</span><span class="plain-syntax">;</span>
</pre>
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>&#167;5. Dictionary words. </b>This tests whether an address is probably that of a dictionary word. It's used
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>&#167;6. 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>
@ -176,7 +229,7 @@ only for debugging output, so the false positives here really do not matter.
<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="SP6" class="paragraph-anchor"></a><b>&#167;6. Keyboard Input. </b>The VM must provide three routines for keyboard input:
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. 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
@ -342,7 +395,7 @@ to document all of that.
<span class="character-syntax"> }</span>
<span class="character-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>&#167;7. Buffer Functions. </b>A "buffer", in this sense, is an array containing a stream of characters
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. 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
@ -475,7 +528,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="SP8" class="paragraph-anchor"></a><b>&#167;8. Dictionary Functions. </b>Again, the dictionary structure is differently arranged on the different VMs.
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. 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.
@ -512,7 +565,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="SP9" class="paragraph-anchor"></a><b>&#167;9. Command Tables. </b>The VM is also generated containing a data structure for the grammar
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. 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
@ -534,30 +587,6 @@ recognised by the parser.
<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. 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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
</p>
<p class="commentary">But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">DictionaryWordToVerbNum</span><span class="plain-syntax"> </span><span class="identifier-syntax">dword</span><span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">dword</span><span class="plain-syntax"> = </span><span class="identifier-syntax">dword</span><span class="plain-syntax"> + #</span><span class="identifier-syntax">dict_par2</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">aloads</span><span class="plain-syntax"> </span><span class="identifier-syntax">dword</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">verbnum</span><span class="plain-syntax"> = </span><span class="constant-syntax">$ffff</span><span class="plain-syntax">-</span><span class="identifier-syntax">verbnum</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">verbnum</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. Action functions. </b>This looks up the address of a function like <span class="extract"><span class="extract-syntax">TakeSub</span></span> from the table of
"action subroutines".
</p>

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

@ -931,7 +931,7 @@ fairly thorough description of its output, which is written into the
<span class="plain-syntax"> </span><span class="comment-syntax">If the first word is not listed as a verb, it must be a direction</span>
<span class="plain-syntax"> </span><span class="comment-syntax">or the name of someone to talk to</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax"> || ((</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</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">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">) == </span><span class="reserved-syntax">false</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="comment-syntax">So is the first word an object contained in the special object "compass"</span>
<span class="plain-syntax"> </span><span class="comment-syntax">(i.e., a direction)? This needs use of NounDomain, a routine which</span>
<span class="plain-syntax"> </span><span class="comment-syntax">does the object matching, returning the object number, or 0 if none found,</span>
@ -990,7 +990,7 @@ fairly thorough description of its output, which is written into the
<span class="plain-syntax"> </span><span class="identifier-syntax">scope_reason</span><span class="plain-syntax"> = </span><span class="identifier-syntax">PARSING_REASON</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">l</span><span class="plain-syntax"> == </span><span class="identifier-syntax">REPARSE_CODE</span><span class="plain-syntax">) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">ReParse</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">l</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">verb_word</span><span class="plain-syntax"> &amp;&amp; ((</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</span><span class="plain-syntax">)) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">NotConversation</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">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">)) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">NotConversation</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">best_etype</span><span class="plain-syntax"> = </span><span class="identifier-syntax">MISSINGPERSON_PE</span><span class="plain-syntax">; </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">GiveError</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
@ -1008,7 +1008,7 @@ fairly thorough description of its output, which is written into the
<span class="plain-syntax"> </span><span class="comment-syntax">name and the comma (eg, throw out "dwarf sdfgsdgs, go north").</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">wn</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">verb_word</span><span class="plain-syntax"> &amp;&amp; ((</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</span><span class="plain-syntax">)) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">NotConversation</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">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">)) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">NotConversation</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">best_etype</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TOTALK_PE</span><span class="plain-syntax">; </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">GiveError</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
@ -1044,7 +1044,7 @@ fairly thorough description of its output, which is written into the
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> .</span><span class="identifier-syntax">NotConversation</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">verb_word</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax"> || ((</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</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">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">) == </span><span class="reserved-syntax">false</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">verb_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">UnknownVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</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">verb_word</span><span class="plain-syntax"> ~= </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">VerbAccepted</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">best_etype</span><span class="plain-syntax"> = </span><span class="identifier-syntax">VERB_PE</span><span class="plain-syntax">;</span>
@ -1055,7 +1055,7 @@ fairly thorough description of its output, which is written into the
<span class="plain-syntax"> </span><span class="comment-syntax">We now definitely have a verb, not a direction, whether we got here by the</span>
<span class="plain-syntax"> </span><span class="comment-syntax">"take ..." or "person, take ..." method. Get the meta flag for this verb:</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">meta</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_META</span><span class="plain-syntax">)/2;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">meta</span><span class="plain-syntax"> = </span><span class="identifier-syntax">WordMarkedAsMeta</span><span class="plain-syntax">(</span><span class="identifier-syntax">verb_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="comment-syntax">You can't order other people to "full score" for you, and so on...</span>
@ -2555,11 +2555,9 @@ because we want to allow duplicates).
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first_word</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">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">wn</span><span class="plain-syntax">; </span><span class="identifier-syntax">first_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">LanguageIsVerb</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="constant-syntax">1</span><span class="plain-syntax">); </span><span class="identifier-syntax">wn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">j</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first_word</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">first_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</span><span class="plain-syntax">) &amp;&amp; ~~</span><span class="identifier-syntax">LanguageVerbMayBeName</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_CopyBuffer</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">RECONSTRUCT_INPUT</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) &amp;&amp; ~~</span><span class="identifier-syntax">LanguageVerbMayBeName</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_CopyBuffer</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">RECONSTRUCT_INPUT</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="comment-syntax">Now we insert the answer into the original typed command, as</span>
@ -2639,11 +2637,9 @@ because we want to allow duplicates).
<span class="plain-syntax"> </span><span class="comment-syntax">Once again, if the reply looks like a command, give it to the</span>
<span class="plain-syntax"> </span><span class="comment-syntax">parser to get on with and forget about the question...</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first_word</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">first_word</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</span><span class="plain-syntax">) &amp;&amp; ~~</span><span class="identifier-syntax">LanguageVerbMayBeName</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_CopyBuffer</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">RECONSTRUCT_INPUT</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) &amp;&amp; ~~</span><span class="identifier-syntax">LanguageVerbMayBeName</span><span class="plain-syntax">(</span><span class="identifier-syntax">first_word</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_CopyBuffer</span><span class="plain-syntax">(</span><span class="identifier-syntax">buffer</span><span class="plain-syntax">, </span><span class="identifier-syntax">buffer2</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">RECONSTRUCT_INPUT</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="comment-syntax">...but if we have a genuine answer, then:</span>
@ -3874,28 +3870,18 @@ if it was a match because of inadequate input).
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">threshold</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">current_noun_is_plural</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TreatNounAsPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">current_noun_is_plural</span><span class="plain-syntax"> = </span><span class="identifier-syntax">WorkMarkedAsUntruncatedPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NextWord</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Refers</span><span class="plain-syntax">(</span><span class="identifier-syntax">obj</span><span class="plain-syntax">, </span><span class="identifier-syntax">wn</span><span class="plain-syntax">-1)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">threshold</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">w</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">current_noun_is_plural</span><span class="plain-syntax"> = </span><span class="identifier-syntax">current_noun_is_plural</span><span class="plain-syntax"> | (</span><span class="identifier-syntax">TreatNounAsPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">current_noun_is_plural</span><span class="plain-syntax"> = </span><span class="identifier-syntax">current_noun_is_plural</span><span class="plain-syntax"> | (</span><span class="identifier-syntax">WorkMarkedAsUntruncatedPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NextWord</span><span class="plain-syntax">();</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">threshold</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">jump</span><span class="plain-syntax"> </span><span class="identifier-syntax">MMbyPN</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">TreatNounAsPlural</span><span class="plain-syntax"> </span><span class="identifier-syntax">w</span><span class="plain-syntax"> </span><span class="identifier-syntax">b</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">w</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">b</span><span class="plain-syntax"> = </span><span class="identifier-syntax">w</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">;</span>
<span class="comment-syntax"> if (b &amp; DICTPAR1_SING) rfalse;</span>
<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"> &amp; </span><span class="identifier-syntax">DICTPAR1_TRUNC</span><span class="plain-syntax">) </span><span class="reserved-syntax">rfalse</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">b</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">DICTPAR1_PLURAL</span><span class="plain-syntax">) </span><span class="reserved-syntax">rtrue</span><span class="plain-syntax">;</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="SP56" class="paragraph-anchor"></a><b>&#167;56. Refers. </b><span class="extract"><span class="extract-syntax">Refers</span></span> works out whether the word at number wnum can refer to the object
<span class="extract"><span class="extract-syntax">obj</span></span>, returning true or false. The standard method is to see if the word
@ -4051,7 +4037,7 @@ Manual}, 4th edition.
<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">=0:</span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">n</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">w</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NextWordStopped</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">w</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">THEN1__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">COMMA_WORD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> -1) </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">TreatNounAsPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</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">WorkMarkedAsUntruncatedPlural</span><span class="plain-syntax">(</span><span class="identifier-syntax">w</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">parser_action</span><span class="plain-syntax"> = ##</span><span class="identifier-syntax">PluralFound</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">outcome</span><span class="plain-syntax"> = </span><span class="reserved-syntax">true</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
@ -4241,7 +4227,7 @@ is defined in the Standard Rules, not here.
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">wn</span><span class="plain-syntax"> &lt;= </span><span class="identifier-syntax">num_words</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">l</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NextWordStopped</span><span class="plain-syntax">(); </span><span class="identifier-syntax">wn</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">l</span><span class="plain-syntax"> == </span><span class="identifier-syntax">THEN1__WD</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">l</span><span class="plain-syntax"> ~= -1 </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_PREP</span><span class="plain-syntax">) { </span><span class="identifier-syntax">wn</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</span><span class="plain-syntax">; } </span><span class="comment-syntax">if preposition</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">l</span><span class="plain-syntax"> ~= -1 </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">l</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_PREP</span><span class="plain-syntax">) { </span><span class="identifier-syntax">wn</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</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">l</span><span class="plain-syntax"> == </span><span class="identifier-syntax">ALL1__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">ALL2__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">ALL3__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">ALL4__WD</span><span class="plain-syntax"> </span><span class="reserved-syntax">or</span><span class="plain-syntax"> </span><span class="identifier-syntax">ALL5__WD</span><span class="plain-syntax">) { </span><span class="identifier-syntax">wn</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</span><span class="plain-syntax">; }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SafeSkipDescriptors</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="comment-syntax">save the current match state</span>

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

@ -372,17 +372,16 @@ out the I6 command verb grammar for the supplied command.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax">[ </span><span class="identifier-syntax">ShowVerbSub</span><span class="plain-syntax"> </span><span class="identifier-syntax">address</span><span class="plain-syntax"> </span><span class="identifier-syntax">lines</span><span class="plain-syntax"> </span><span class="identifier-syntax">meta</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">x</span><span class="plain-syntax">;</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">ShowVerbSub</span><span class="plain-syntax"> </span><span class="identifier-syntax">address</span><span class="plain-syntax"> </span><span class="identifier-syntax">lines</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> </span><span class="identifier-syntax">x</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">2</span><span class="plain-syntax">; </span><span class="identifier-syntax">x</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NextWordStopped</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">x</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax"> || ((</span><span class="identifier-syntax">x</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_VERB</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">WordMarkedAsVerb</span><span class="plain-syntax">(</span><span class="identifier-syntax">x</span><span class="plain-syntax">) == </span><span class="reserved-syntax">false</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="string-syntax">"Try typing ~showverb~ and then the name of a verb."</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">meta</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">x</span><span class="plain-syntax">-&gt;#</span><span class="identifier-syntax">dict_par1</span><span class="plain-syntax">) &amp; </span><span class="identifier-syntax">DICTPAR1_META</span><span class="plain-syntax">)/2;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DictionaryWordToVerbNum</span><span class="plain-syntax">(</span><span class="identifier-syntax">x</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">address</span><span class="plain-syntax"> = </span><span class="identifier-syntax">VM_CommandTableAddress</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">lines</span><span class="plain-syntax"> = </span><span class="identifier-syntax">address</span><span class="plain-syntax">-&gt;0;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">address</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">"Verb "</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">meta</span><span class="plain-syntax">) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"meta "</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">WordMarkedAsMeta</span><span class="plain-syntax">(</span><span class="identifier-syntax">x</span><span class="plain-syntax">)) </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"meta "</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_PrintCommandWords</span><span class="plain-syntax">(</span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">new_line</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">lines</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">"has no grammar lines.^"</span><span class="plain-syntax">;</span>

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

@ -1,10 +1,10 @@
Total memory consumption was 139616K = 136 MB
Total memory consumption was 139622K = 136 MB
---- was used for 2128651 objects, in 374885 frames in 0 x 800K = 0K = 0 MB:
---- was used for 2128663 objects, in 374897 frames in 0 x 800K = 0K = 0 MB:
30.2% inter_tree_node_array 60 x 8192 = 491520 objects, 43255680 bytes
19.4% text_stream_array 4928 x 100 = 492800 objects, 27754496 bytes
17.7% linked_list 45410 objects, 25429600 bytes
17.7% linked_list 45412 objects, 25430720 bytes
10.0% inter_symbol_array 135 x 1024 = 138240 objects, 14381280 bytes
9.7% inter_error_stash_array 106 x 1024 = 108544 objects, 13897024 bytes
7.4% parse_node 133803 objects, 10704240 bytes
@ -19,10 +19,10 @@ Total memory consumption was 139616K = 136 MB
1.3% package_request 21353 objects, 1879064 bytes
1.2% vocabulary_entry_array 164 x 100 = 16400 objects, 1842048 bytes
1.1% dict_entry_array 501 x 100 = 50100 objects, 1619232 bytes
1.0% inter_symbols_table 26897 objects, 1506232 bytes
1.0% inter_symbols_table 26901 objects, 1506456 bytes
1.0% match_trie_array 11 x 1000 = 11000 objects, 1496352 bytes
1.0% i6_schema_array 24 x 100 = 2400 objects, 1440768 bytes
0.9% inter_package 26897 objects, 1291056 bytes
0.9% inter_package 26901 objects, 1291248 bytes
0.7% map_data 677 objects, 1137360 bytes
0.7% id_body 980 objects, 1121120 bytes
0.7% adjective_meaning 208 objects, 1030016 bytes
@ -42,7 +42,7 @@ Total memory consumption was 139616K = 136 MB
0.1% compilation_subtask 3388 objects, 271040 bytes
0.1% inference_subject 672 objects, 263424 bytes
0.1% inter_annotation_array 2 x 8192 = 16384 objects, 262208 bytes
0.1% vanilla_function 3824 objects, 244736 bytes
0.1% vanilla_function 3826 objects, 244864 bytes
0.1% binary_predicate 330 objects, 174240 bytes
0.1% hierarchy_location 1191 objects, 171504 bytes
0.1% linguistic_stock_item 3338 objects, 160224 bytes
@ -264,7 +264,7 @@ Total memory consumption was 139616K = 136 MB
100.0% was used for memory not allocated for objects:
62.4% text stream storage 89216108 bytes in 512895 claims
62.4% text stream storage 89222204 bytes in 512916 claims
3.8% dictionary storage 5498432 bytes in 7768 claims
---- sorting 2624 bytes in 531 claims
5.0% source text 7200000 bytes in 3 claims
@ -272,7 +272,7 @@ Total memory consumption was 139616K = 136 MB
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.1% inter symbols storage 4573696 bytes in 28271 claims
3.1% inter symbols storage 4574208 bytes in 28275 claims
11.7% inter bytecode storage 16757556 bytes in 15 claims
4.3% inter links storage 6222976 bytes in 11 claims
0.1% inter tree location list storage 191232 bytes in 32 claims
@ -282,5 +282,5 @@ Total memory consumption was 139616K = 136 MB
---- code generation workspace for objects 3528 bytes in 19 claims
0.1% emitter array storage 281184 bytes in 2006 claims
-136.-6% was overhead - -195402248 bytes = -190822K = -186 MB
-136.-6% was overhead - -195403912 bytes = -190824K = -186 MB

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

@ -7,15 +7,15 @@
1.5% in //RTKindConstructors::compile//
1.5% in //RTPhrasebook::compile_entries//
1.1% in //Sequence::lint_inter//
0.7% in //ImperativeDefinitions::compile_first_block//
0.3% in //CompletionModule::compile//
0.3% in //ImperativeDefinitions::compile_first_block//
0.3% in //MajorNodes::pass_2//
0.3% in //Sequence::undertake_queued_tasks//
0.3% in //Sequence::undertake_queued_tasks//
0.3% in //World::stage_V//
5.5% not specifically accounted for
5.1% not specifically accounted for
27.6% in running Inter pipeline
8.9% in step 14/15: generate inform6 -> auto.inf
9.3% in step 14/15: generate inform6 -> auto.inf
7.0% in step 5/15: load-binary-kits
5.8% in step 6/15: make-synoptic-module
1.9% in step 9/15: make-identifiers-unique
@ -23,6 +23,6 @@
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
2.4% not specifically accounted for
2.0% not specifically accounted for
3.8% in supervisor
0.8% not specifically accounted for

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

@ -28,6 +28,15 @@ only if scripting is on.
];
@h Dictionary Parameters.
Each word in the dictionary data structure has two metadata fields, known
for traditional Inform 6 reasons as "dictionary parameters 1 and 2". Number 1
is a bitmap: some of the higher bits are written by the I6 compiler only when
certain compile options are set, but they will be for the code which I7
generates. Bit 6 is currently never written by I6; bit 5, marking singular
nouns, is never used by this parser.
(For speed reasons, reading of |DICTPAR1_NOUN| and |DICTPAR1_PREP| is done
directly by |ParserKit| rather than by calling functions here.)
=
Constant #dict_par1 = 6;
@ -42,6 +51,38 @@ Constant DICTPAR1_BIT6 = 32;
Constant DICTPAR1_TRUNC = 64;
Constant DICTPAR1_NOUN = 128;
[ WordMarkedAsVerb w;
if ((w) && ((w->#dict_par1) & DICTPAR1_VERB)) rtrue;
rfalse;
];
[ WordMarkedAsMeta w;
if ((w) && ((w->#dict_par1) & DICTPAR1_META)) rtrue;
rfalse;
];
[ WorkMarkedAsUntruncatedPlural w b;
if (w) {
b = w->#dict_par1;
if (b & DICTPAR1_TRUNC) rfalse;
if (b & DICTPAR1_PLURAL) rtrue;
}
rfalse;
];
@h Extracting Verb Numbers.
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 tools for dumping dictionaries from Infocom
story files; by using the Infocom format for dictionary tables, Inform's life
was easier.
=
[ DictionaryWordToVerbNum w;
return $ff-(w->#dict_par2);
];
@h Variables and Arrays.
=
@ -203,26 +244,6 @@ recognised by the parser.
print "'", (address) VM_NumberToDictionaryAddress(j), "' ";
];
@h Extracting Verb Numbers.
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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
=
[ DictionaryWordToVerbNum dword;
return $ff-(dword->#dict_par2);
];
@h Action functions.
This looks up the address of a function like |TakeSub| from the table of
"action subroutines".

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

@ -62,6 +62,15 @@ Global gg_scriptstr = 0;
];
@h Dictionary Parameters.
Each word in the dictionary data structure has two metadata fields, known
for traditional Inform 6 reasons as "dictionary parameters 1 and 2". Number 1
is a bitmap: some of the higher bits are written by the I6 compiler only when
certain compile options are set, but they will be for the code which I7
generates. Bit 6 is currently never written by I6; bit 5, marking singular
nouns, is never used by this parser.
(For speed reasons, reading of |DICTPAR1_NOUN| and |DICTPAR1_PREP| is done
directly by |ParserKit| rather than by calling functions here.)
=
Constant DICT_ENTRY_BYTES = 12+DICT_WORD_SIZE*WORDSIZE;
@ -77,6 +86,48 @@ Constant DICTPAR1_BIT6 = 32;
Constant DICTPAR1_TRUNC = 64;
Constant DICTPAR1_NOUN = 128;
[ WordMarkedAsVerb w;
if ((w) && ((w->#dict_par1) & DICTPAR1_VERB)) rtrue;
rfalse;
];
[ WordMarkedAsMeta w;
if ((w) && ((w->#dict_par1) & DICTPAR1_META)) rtrue;
rfalse;
];
[ WorkMarkedAsUntruncatedPlural w b;
if (w) {
b = w->#dict_par1;
if (b & DICTPAR1_TRUNC) rfalse;
if (b & DICTPAR1_PLURAL) rtrue;
}
rfalse;
];
@h Extracting Verb Numbers.
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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
=
[ DictionaryWordToVerbNum w verbnum;
w = w + #dict_par2 - 1;
@aloads w 0 verbnum;
verbnum = $ffff-verbnum;
return verbnum;
];
@h Variables and Arrays.
=
@ -463,29 +514,6 @@ recognised by the parser.
}
];
@h Extracting Verb Numbers.
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
tools for dumping dictionaries from Infocom story files; by using the Infocom
format for dictionary tables, Inform's life was easier.
But there was an implicit restriction there of 255 distinct verbs (not 256
since not all words were verbs). When Glulx raised almost all of the Z-machine
limits, it made space for 65535 verbs instead of 255, but it appears that
nobody remembered to implement this in I6-for-Glulx and the Glulx form of
the I6 library. This was only put right in March 2009, and the following
routine was added to concentrate lookups of this field in one place.
=
[ DictionaryWordToVerbNum dword verbnum;
dword = dword + #dict_par2 - 1;
@aloads dword 0 verbnum;
verbnum = $ffff-verbnum;
return verbnum;
];
@h Action functions.
This looks up the address of a function like |TakeSub| from the table of
"action subroutines".

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

@ -853,7 +853,7 @@ Is the command a direction name, and so an implicit GO? If so, go to (K).
! If the first word is not listed as a verb, it must be a direction
! or the name of someone to talk to
if (verb_word == 0 || ((verb_word->#dict_par1) & DICTPAR1_VERB) == 0) {
if (WordMarkedAsVerb(verb_word) == false) {
! So is the first word an object contained in the special object "compass"
! (i.e., a direction)? This needs use of NounDomain, a routine which
! does the object matching, returning the object number, or 0 if none found,
@ -912,7 +912,7 @@ Is anyone being addressed?
scope_reason = PARSING_REASON;
if (l == REPARSE_CODE) jump ReParse;
if (l == 0) {
if (verb_word && ((verb_word->#dict_par1) & DICTPAR1_VERB)) jump NotConversation;
if (WordMarkedAsVerb(verb_word)) jump NotConversation;
best_etype = MISSINGPERSON_PE; jump GiveError;
}
@ -930,7 +930,7 @@ Is anyone being addressed?
! name and the comma (eg, throw out "dwarf sdfgsdgs, go north").
if (wn ~= j) {
if (verb_word && ((verb_word->#dict_par1) & DICTPAR1_VERB)) jump NotConversation;
if (WordMarkedAsVerb(verb_word)) jump NotConversation;
best_etype = TOTALK_PE; jump GiveError;
}
@ -966,7 +966,7 @@ Get the verb: try all the syntax lines for that verb.
=
.NotConversation;
if (verb_word == 0 || ((verb_word->#dict_par1) & DICTPAR1_VERB) == 0) {
if (WordMarkedAsVerb(verb_word) == false) {
verb_word = UnknownVerb(verb_word);
if (verb_word ~= 0) jump VerbAccepted;
best_etype = VERB_PE;
@ -977,7 +977,7 @@ Get the verb: try all the syntax lines for that verb.
! We now definitely have a verb, not a direction, whether we got here by the
! "take ..." or "person, take ..." method. Get the meta flag for this verb:
meta = ((verb_word->#dict_par1) & DICTPAR1_META)/2;
meta = WordMarkedAsMeta(verb_word);
! You can't order other people to "full score" for you, and so on...
@ -2466,11 +2466,9 @@ because we want to allow duplicates).
if (first_word == 0) {
j = wn; first_word = LanguageIsVerb(buffer2, parse2, 1); wn = j;
}
if (first_word ~= 0) {
if (((first_word->#dict_par1) & DICTPAR1_VERB) && ~~LanguageVerbMayBeName(first_word)) {
VM_CopyBuffer(buffer, buffer2);
jump RECONSTRUCT_INPUT;
}
if ((WordMarkedAsVerb(first_word)) && ~~LanguageVerbMayBeName(first_word)) {
VM_CopyBuffer(buffer, buffer2);
jump RECONSTRUCT_INPUT;
}
! Now we insert the answer into the original typed command, as
@ -2550,11 +2548,9 @@ because we want to allow duplicates).
! Once again, if the reply looks like a command, give it to the
! parser to get on with and forget about the question...
if (first_word ~= 0) {
if (((first_word->#dict_par1) & DICTPAR1_VERB) && ~~LanguageVerbMayBeName(first_word)) {
VM_CopyBuffer(buffer, buffer2);
jump RECONSTRUCT_INPUT;
}
if ((WordMarkedAsVerb(first_word)) && ~~LanguageVerbMayBeName(first_word)) {
VM_CopyBuffer(buffer, buffer2);
jump RECONSTRUCT_INPUT;
}
! ...but if we have a genuine answer, then:
@ -3764,12 +3760,12 @@ if it was a match because of inadequate input).
}
threshold = 1;
current_noun_is_plural = TreatNounAsPlural(w);
current_noun_is_plural = WorkMarkedAsUntruncatedPlural(w);
w = NextWord();
while (Refers(obj, wn-1)) {
threshold++;
if (w)
current_noun_is_plural = current_noun_is_plural | (TreatNounAsPlural(w));
current_noun_is_plural = current_noun_is_plural | (WorkMarkedAsUntruncatedPlural(w));
w = NextWord();
}
@ -3777,16 +3773,6 @@ if it was a match because of inadequate input).
jump MMbyPN;
];
[ TreatNounAsPlural w b;
if (w) {
b = w->#dict_par1;
! if (b & DICTPAR1_SING) rfalse;
if (b & DICTPAR1_TRUNC) rfalse;
if (b & DICTPAR1_PLURAL) rtrue;
}
rfalse;
];
@h Refers.
|Refers| works out whether the word at number wnum can refer to the object
|obj|, returning true or false. The standard method is to see if the word
@ -3938,7 +3924,7 @@ Manual}, 4th edition.
for (i=0:i<n:i++) {
w = NextWordStopped();
if (w == 0 or THEN1__WD or COMMA_WORD or -1) break;
if (TreatNounAsPlural(w)) {
if (WorkMarkedAsUntruncatedPlural(w)) {
parser_action = ##PluralFound;
outcome = true;
}
@ -4128,7 +4114,7 @@ Array alt_match_list --> (MATCH_LIST_WORDS+1);
while (wn <= num_words) {
l = NextWordStopped(); wn--;
if (l == THEN1__WD) break;
if ((l ~= -1 or 0) && (l->#dict_par1) & DICTPAR1_PREP) { wn++; continue; } ! if preposition
if ((l ~= -1 or 0) && (l->#dict_par1) & DICTPAR1_PREP) { wn++; continue; }
if (l == ALL1__WD or ALL2__WD or ALL3__WD or ALL4__WD or ALL5__WD) { wn++; continue; }
SafeSkipDescriptors();
! save the current match state

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

@ -321,17 +321,16 @@ SHOWVERB is a holdover from old I6 days, but still quite useful. It writes
out the I6 command verb grammar for the supplied command.
=
[ ShowVerbSub address lines meta i x;
[ ShowVerbSub address lines i x;
wn = 2; x = NextWordStopped();
if (x == 0 || ((x->#dict_par1) & DICTPAR1_VERB) == 0)
if (WordMarkedAsVerb(x) == false)
"Try typing ~showverb~ and then the name of a verb.";
meta = ((x->#dict_par1) & DICTPAR1_META)/2;
i = DictionaryWordToVerbNum(x);
address = VM_CommandTableAddress(i);
lines = address->0;
address++;
print "Verb ";
if (meta) print "meta ";
if (WordMarkedAsMeta(x)) print "meta ";
VM_PrintCommandWords(i);
new_line;
if (lines == 0) print "has no grammar lines.^";