ifhub/inform7
1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-07-02 23:14:57 +03:00
Code Issues Projects Releases Wiki Activity

New AP parser finally passes test suite

Browse source
This commit is contained in:
Graham Nelson 2021-03-12 10:55:57 +00:00
parent df10fd520e
commit d95addef94
23 changed files with 554 additions and 455 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

72
docs/if-module/4-anl.html
View file

@ -100,7 +100,7 @@ list of <a href="4-anl.html#SP4" class="internal">anl_entry</a> objects.
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">test_this_in_ap_match</span><span class="plain-syntax">;</span>
<span class="plain-syntax">} </span><span class="reserved-syntax">action_name_list</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">action_name_list</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::new_list</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::new_list</span></span>:<br/><a href="4-anl.html#SP24">&#167;24</a>, <a href="4-anl.html#SP24_1">&#167;24.1</a>, <a href="4-anl.html#SP24_2">&#167;24.2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">first</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">action_name_list</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::new_list</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::new_list</span></span>:<br/><a href="4-anl.html#SP24">&#167;24</a>, <a href="4-anl.html#SP24_1">&#167;24.1</a>, <a href="4-anl.html#SP24_2">&#167;24.2</a>, <a href="4-anl.html#SP24_3">&#167;24.3</a>, <a href="4-anl.html#SP24_4">&#167;24.4</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">first</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">state</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">action_name_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">list</span><span class="plain-syntax"> = </span><span class="identifier-syntax">CREATE</span><span class="plain-syntax">(</span><span class="reserved-syntax">action_name_list</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">list</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">entries</span><span class="plain-syntax"> = </span><span class="identifier-syntax">first</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">list</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">negation_state</span><span class="plain-syntax"> = </span><span class="identifier-syntax">state</span><span class="plain-syntax">;</span>
@ -165,7 +165,7 @@ action list.
<span class="plain-syntax"> </span><span class="reserved-syntax">struct</span><span class="plain-syntax"> </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">next_entry</span><span class="plain-syntax">; </span><span class="comment-syntax"> next in this ANL list</span>
<span class="plain-syntax">} </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::new_entry_at</span><button class="popup" onclick="togglePopup('usagePopup6')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup6">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::new_entry_at</span></span>:<br/><a href="4-anl.html#SP24_1">&#167;24.1</a>, <a href="4-anl.html#SP26">&#167;26</a>, <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP28_2">&#167;28.2</a>, <a href="4-anl.html#SP29_1">&#167;29.1</a>, <a href="4-anl.html#SP29_1_3_1">&#167;29.1.3.1</a>, <a href="4-anl.html#SP34">&#167;34</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::new_entry_at</span><button class="popup" onclick="togglePopup('usagePopup6')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup6">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::new_entry_at</span></span>:<br/><a href="4-anl.html#SP24_2">&#167;24.2</a>, <a href="4-anl.html#SP24_3">&#167;24.3</a>, <a href="4-anl.html#SP26">&#167;26</a>, <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP28_2">&#167;28.2</a>, <a href="4-anl.html#SP29_1">&#167;29.1</a>, <a href="4-anl.html#SP29_1_3_1">&#167;29.1.3.1</a>, <a href="4-anl.html#SP34">&#167;34</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">wording</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">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax"> = </span><span class="identifier-syntax">CREATE</span><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">item</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP11" class="function-link"><span class="function-syntax">ActionNameLists::new_item</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">at</span><span class="plain-syntax"> = -1;</span>
@ -463,13 +463,13 @@ the text leading to a list:
<span class="plain-syntax"> </span><span class="reserved-syntax">return</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">wording</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::get_clause_wording</span><button class="popup" onclick="togglePopup('usagePopup28')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup28">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::get_clause_wording</span></span>:<br/><a href="4-anl.html#SP17">&#167;17</a>, <a href="4-anl.html#SP28_1_1">&#167;28.1.1</a>, <a href="4-anl.html#SP30">&#167;30</a>, <a href="4-anl.html#SP32">&#167;32</a><br/>Parse Clauses - <a href="4-pc.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">C</span><span class="plain-syntax">) {</span>
<span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::get_clause_wording</span><button class="popup" onclick="togglePopup('usagePopup28')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup28">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::get_clause_wording</span></span>:<br/><a href="4-anl.html#SP17">&#167;17</a>, <a href="4-anl.html#SP24_1_1">&#167;24.1.1</a>, <a href="4-anl.html#SP30">&#167;30</a>, <a href="4-anl.html#SP32">&#167;32</a><br/>Parse Clauses - <a href="4-pc.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">C</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">anl_clause_text</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">entry</span><span class="plain-syntax">)?(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parsing_data</span><span class="plain-syntax">.</span><span class="element-syntax">anl_clauses</span><span class="plain-syntax">):</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">c</span><span class="plain-syntax">; </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</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">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_ID</span><span class="plain-syntax"> == </span><span class="identifier-syntax">C</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_text</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">EMPTY_WORDING</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::set_clause_wording</span><button class="popup" onclick="togglePopup('usagePopup29')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup29">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::set_clause_wording</span></span>:<br/><a href="4-anl.html#SP17">&#167;17</a>, <a href="4-anl.html#SP26">&#167;26</a>, <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP29_1_3">&#167;29.1.3</a>, <a href="4-anl.html#SP32">&#167;32</a><br/>Parse Clauses - <a href="4-pc.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">C</span><span class="plain-syntax">, </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::set_clause_wording</span><button class="popup" onclick="togglePopup('usagePopup29')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup29">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::set_clause_wording</span></span>:<br/><a href="4-anl.html#SP17">&#167;17</a>, <a href="4-anl.html#SP24_3">&#167;24.3</a>, <a href="4-anl.html#SP26">&#167;26</a>, <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP29_1_3">&#167;29.1.3</a>, <a href="4-anl.html#SP32">&#167;32</a><br/>Parse Clauses - <a href="4-pc.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">C</span><span class="plain-syntax">, </span><span class="identifier-syntax">wording</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">entry</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"no entry"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">anl_clause_text</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prev</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">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">anl_clause_text</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">entry</span><span class="plain-syntax">)?(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parsing_data</span><span class="plain-syntax">.</span><span class="element-syntax">anl_clauses</span><span class="plain-syntax">):</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">; </span><span class="identifier-syntax">c</span><span class="plain-syntax">; </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</span><span class="plain-syntax">) {</span>
@ -560,7 +560,7 @@ the text leading to a list:
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::get_clause_wording</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">IN_AP_CLAUSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::add_parameter</span><button class="popup" onclick="togglePopup('usagePopup34')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup34">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_parameter</span></span>:<br/><a href="4-anl.html#SP24_2">&#167;24.2</a>, <a href="4-anl.html#SP29_1_2">&#167;29.1.2</a>, <a href="4-anl.html#SP34">&#167;34</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::add_parameter</span><button class="popup" onclick="togglePopup('usagePopup34')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup34">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_parameter</span></span>:<br/><a href="4-anl.html#SP24_4">&#167;24.4</a>, <a href="4-anl.html#SP29_1_2">&#167;29.1.2</a>, <a href="4-anl.html#SP34">&#167;34</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">wording</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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::parc</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">: </span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::set_clause_wording</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">NOUN_AP_CLAUSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
@ -747,6 +747,7 @@ something other than something &mdash; or <span class="extract"><span class="ext
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">anl_parsing_tense</span><span class="plain-syntax"> = </span><span class="identifier-syntax">IS_TENSE</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">action_name_list</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::parse</span><button class="popup" onclick="togglePopup('usagePopup45')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup45">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::parse</span></span>:<br/>Parse Action Patterns - <a href="4-pap.html#SP17">&#167;17</a><br/>Parse Clauses - <a href="4-pc.html#SP1_3">&#167;1.3</a>, <a href="4-pc.html#SP1_4">&#167;1.4</a>, <a href="4-pc.html#SP4">&#167;4</a>, <a href="4-pc.html#SP5">&#167;5</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tense</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sense</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::mismatched_brackets</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">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax"> = </span><span class="identifier-syntax">anl_parsing_tense</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">anl_parsing_tense</span><span class="plain-syntax"> = </span><span class="identifier-syntax">tense</span><span class="plain-syntax">;</span>
@ -766,13 +767,13 @@ something other than something &mdash; or <span class="extract"><span class="ext
<span class="Preform-function-syntax">&lt;action-list&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">other</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">than</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;excluded-list&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { FALSE, RP[1] }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">except</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;excluded-list&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { FALSE, RP[1] }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to/with</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl-to-tail&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { TRUE, ActionNameLists::new_list(RP[1], ANL_POSITIVE) }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1" class="named-paragraph-link"><span class="named-paragraph">Construct ANL for anything</span><span class="named-paragraph-number">24.1</span></a></span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { fail }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to/with</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl-to-tail&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1" class="named-paragraph-link"><span class="named-paragraph">Construct ANL for anything to</span><span class="named-paragraph-number">24.1</span></a></span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_2" class="named-paragraph-link"><span class="named-paragraph">Construct ANL for anything</span><span class="named-paragraph-number">24.2</span></a></span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">doing</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">something/anything</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{...}</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { -, - }; wording TW = WR[1]; </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_3" class="named-paragraph-link"><span class="named-paragraph">Construct ANL for doing something with a tail</span><span class="named-paragraph-number">24.3</span></a></span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { TRUE, ActionNameLists::new_list(RP[1], ANL_POSITIVE) }</span>
<span class="Preform-function-syntax">&lt;excluded-list&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to/with</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{&lt;minimal-common-to-text&gt;}</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_2" class="named-paragraph-link"><span class="named-paragraph">Add to-clause to excluded ANL</span><span class="named-paragraph-number">24.2</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to/with</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{&lt;minimal-common-to-text&gt;}</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_4" class="named-paragraph-link"><span class="named-paragraph">Add to-clause to excluded ANL</span><span class="named-paragraph-number">24.4</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;anl&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { TRUE, ActionNameLists::new_list(RP[1], ANL_NEGATED_LISTWISE) }</span>
<span class="Preform-function-syntax">&lt;minimal-common-to-text&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
@ -781,7 +782,16 @@ something other than something &mdash; or <span class="extract"><span class="ext
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">...</span>
</pre>
<ul class="endnotetexts"><li>This is <a href="../words-module/4-ap.html" class="internal">Preform grammar</a>, not regular C code.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_1" class="paragraph-anchor"></a><b>&#167;24.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Construct ANL for anything</span><span class="named-paragraph-number">24.1</span></span><span class="Preform-comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP24_1" class="paragraph-anchor"></a><b>&#167;24.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Construct ANL for anything to</span><span class="named-paragraph-number">24.1</span></span><span class="Preform-comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">results</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1];</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP1" class="function-link"><span class="function-syntax">ActionNameLists::new_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">results</span><span class="plain-syntax">, </span><span class="constant-syntax">ANL_POSITIVE</span><span class="plain-syntax">) }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_2" class="paragraph-anchor"></a><b>&#167;24.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Construct ANL for anything</span><span class="named-paragraph-number">24.2</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -789,7 +799,17 @@ something other than something &mdash; or <span class="extract"><span class="ext
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP1" class="function-link"><span class="function-syntax">ActionNameLists::new_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">ANL_POSITIVE</span><span class="plain-syntax">) };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_2" class="paragraph-anchor"></a><b>&#167;24.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Add to-clause to excluded ANL</span><span class="named-paragraph-number">24.2</span></span><span class="comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP24_3" class="paragraph-anchor"></a><b>&#167;24.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Construct ANL for doing something with a tail</span><span class="named-paragraph-number">24.3</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">results</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP4" class="function-link"><span class="function-syntax">ActionNameLists::new_entry_at</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::set_clause_wording</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">results</span><span class="plain-syntax">, </span><span class="constant-syntax">TAIL_AP_CLAUSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">TW</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP1" class="function-link"><span class="function-syntax">ActionNameLists::new_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">results</span><span class="plain-syntax">, </span><span class="constant-syntax">ANL_POSITIVE</span><span class="plain-syntax">) };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24_4" class="paragraph-anchor"></a><b>&#167;24.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Add to-clause to excluded ANL</span><span class="named-paragraph-number">24.4</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -799,7 +819,9 @@ something other than something &mdash; or <span class="extract"><span class="ext
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">fail</span><span class="plain-syntax"> </span><span class="identifier-syntax">production</span><span class="plain-syntax"> };</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><a href="4-anl.html#SP17" class="function-link"><span class="function-syntax">ActionNameLists::add_parameter</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;excluded-list&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP1" class="function-link"><span class="function-syntax">ActionNameLists::new_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">ANL_NEGATED_ITEMWISE</span><span class="plain-syntax">) };</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">results</span><span class="plain-syntax"> = </span><span class="identifier-syntax">entry</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> ==&gt; { </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP1" class="function-link"><span class="function-syntax">ActionNameLists::new_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">results</span><span class="plain-syntax">, </span><span class="constant-syntax">ANL_NEGATED_ITEMWISE</span><span class="plain-syntax">) };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP24">&#167;24</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25. </b>The trickiest form is:
@ -922,7 +944,7 @@ for instance, we don't want to count the "in" from "fixed in place".
<span class="plain-syntax"> </span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::set_clause_wording</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">TAIL_AP_CLAUSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">TW</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">results</span><span class="plain-syntax"> = </span><span class="identifier-syntax">entry</span><span class="plain-syntax">;</span>
<span class="identifier-syntax">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">ACTION_PATTERN_PARSING</span><span class="plain-syntax">, </span><span class="string-syntax">"Saw tail %W\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">TW</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP28_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">28.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></a></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">results</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
@ -956,7 +978,7 @@ end, but it's syntactically valid.)
<span class="Preform-function-syntax">&lt;anl-entry-with-action&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">internal</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">anl_entry</span><span class="Preform-plain-syntax"> *</span><span class="Preform-identifier-syntax">results</span><span class="Preform-plain-syntax"> = </span><span class="Preform-identifier-syntax">NULL</span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1" class="named-paragraph-link"><span class="named-paragraph">Parse the wording into a list of results</span><span class="named-paragraph-number">29.1</span></a></span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">if</span><span class="Preform-plain-syntax"> (</span><span class="Preform-identifier-syntax">experimental_anl_system</span><span class="Preform-plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP28_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">28.1.1</span></a></span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">if</span><span class="Preform-plain-syntax"> (</span><span class="Preform-identifier-syntax">experimental_anl_system</span><span class="Preform-plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP24_1_1" class="named-paragraph-link"><span class="named-paragraph">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></a></span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">if</span><span class="Preform-plain-syntax"> (</span><span class="Preform-identifier-syntax">results</span><span class="Preform-plain-syntax">) {</span>
<span class="Preform-plain-syntax"> ==&gt; { -, </span><span class="Preform-identifier-syntax">results</span><span class="Preform-plain-syntax"> }; </span><span class="Preform-reserved-syntax">return</span><span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">TRUE</span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> }</span>
@ -975,6 +997,7 @@ end, but it's syntactically valid.)
<span class="plain-syntax"> </span><span class="identifier-syntax">LOOP_OVER</span><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">, </span><span class="reserved-syntax">action_name</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_1" class="named-paragraph-link"><span class="named-paragraph">Ready the trial entry for another test</span><span class="named-paragraph-number">29.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">RW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">EMPTY_WORDING</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">abbreviated_to_tail</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_2" class="named-paragraph-link"><span class="named-paragraph">Make the trial entry fit this action, if possible, leaving remaining text in RW</span><span class="named-paragraph-number">29.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_3" class="named-paragraph-link"><span class="named-paragraph">Consider the trial entry for inclusion in the results list</span><span class="named-paragraph-number">29.1.3</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">NoMatch:</span><span class="plain-syntax"> ;</span>
@ -1005,9 +1028,15 @@ inelegant, but there's no elegant way to break out of nested loops in C.
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">it_optional</span><span class="plain-syntax"> = </span><a href="4-ann.html#SP8" class="function-link"><span class="function-syntax">ActionNameNames::it_optional</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">abbreviable</span><span class="plain-syntax"> = </span><a href="4-ann.html#SP8" class="function-link"><span class="function-syntax">ActionNameNames::abbreviable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">XW</span><span class="plain-syntax"> = </span><a href="4-ann.html#SP5" class="function-link"><span class="function-syntax">ActionNameNames::tensed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">, </span><span class="identifier-syntax">anl_parsing_tense</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">w_m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">), </span><span class="identifier-syntax">x_m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">XW</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">w_m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">), </span><span class="identifier-syntax">x_m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">XW</span><span class="plain-syntax">), </span><span class="identifier-syntax">n</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">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">w_m</span><span class="plain-syntax"> &lt;= </span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">x_m</span><span class="plain-syntax"> &lt;= </span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">XW</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">Lexer::word</span><span class="plain-syntax">(</span><span class="identifier-syntax">x_m</span><span class="plain-syntax">++) != </span><span class="identifier-syntax">Lexer::word</span><span class="plain-syntax">(</span><span class="identifier-syntax">w_m</span><span class="plain-syntax">++)) </span><span class="reserved-syntax">goto</span><span class="plain-syntax"> </span><span class="identifier-syntax">NoMatch</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">Lexer::word</span><span class="plain-syntax">(</span><span class="identifier-syntax">x_m</span><span class="plain-syntax">++) != </span><span class="identifier-syntax">Lexer::word</span><span class="plain-syntax">(</span><span class="identifier-syntax">w_m</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">abbreviable</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">it_optional</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">n</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">1</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">x_ended</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="identifier-syntax">abbreviated_to_tail</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="identifier-syntax">x_m</span><span class="plain-syntax">--; </span><span class="identifier-syntax">w_m</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">goto</span><span class="plain-syntax"> </span><span class="identifier-syntax">NoMatch</span><span class="plain-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="plain-syntax"> </span><span class="identifier-syntax">n</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_m</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">XW</span><span class="plain-syntax">)) { </span><span class="identifier-syntax">x_ended</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</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="function-syntax">&lt;object-pronoun&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::one_word</span><span class="plain-syntax">(</span><span class="identifier-syntax">x_m</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_m</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)) </span><span class="identifier-syntax">x_ended</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
@ -1042,9 +1071,10 @@ inelegant, but there's no elegant way to break out of nested loops in C.
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_3_1" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">29.1.3.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-as.html#SP5" class="function-link"><span class="function-syntax">ActionSemantics::can_have_noun</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-anl.html#SP34" class="function-link"><span class="function-syntax">ActionNameLists::parse_to_tail</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">RW</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="4-as.html#SP5" class="function-link"><span class="function-syntax">ActionSemantics::can_have_noun</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">an</span><span class="plain-syntax">)) &amp;&amp; (</span><span class="identifier-syntax">abbreviated_to_tail</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-anl.html#SP34" class="function-link"><span class="function-syntax">ActionNameLists::parse_to_tail</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">RW</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_3_1" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">29.1.3.1</span></a></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><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::set_clause_wording</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="constant-syntax">TAIL_AP_CLAUSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">RW</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP29_1_3_1" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">29.1.3.1</span></a></span><span class="plain-syntax">;</span>
@ -1086,7 +1116,7 @@ the trial entry for future trials.
<span class="plain-syntax"> </span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP4" class="function-link"><span class="function-syntax">ActionNameLists::new_entry_at</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">EMPTY_WORDING</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP29_1_3">&#167;29.1.3</a> (five times).</li></ul>
<p class="commentary firstcommentary"><a id="SP28_1_1" class="paragraph-anchor"></a><b>&#167;28.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Extend the list to provide for clauses</span><span class="named-paragraph-number">28.1.1</span></span><span class="comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP24_1_1" class="paragraph-anchor"></a><b>&#167;24.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Extend the list to provide for clauses</span><span class="named-paragraph-number">24.1.1</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -1103,11 +1133,11 @@ the trial entry for future trials.
<span class="plain-syntax"> </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">entry</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP29">&#167;29</a>.</li></ul>
<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP24_1">&#167;24.1</a>, <a href="4-anl.html#SP24_3">&#167;24.3</a>, <a href="4-anl.html#SP24_4">&#167;24.4</a>, <a href="4-anl.html#SP28_1">&#167;28.1</a>, <a href="4-anl.html#SP29">&#167;29</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP30" class="paragraph-anchor"></a><b>&#167;30. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::explode</span><button class="popup" onclick="togglePopup('usagePopup49')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup49">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::explode</span></span>:<br/><a href="4-anl.html#SP28_1_1">&#167;28.1.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::explode</span><button class="popup" onclick="togglePopup('usagePopup49')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup49">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::explode</span></span>:<br/><a href="4-anl.html#SP24_1_1">&#167;24.1.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">entry</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tc</span><span class="plain-syntax"> = -1;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::has_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">TAIL_AP_CLAUSE</span><span class="plain-syntax">)) </span><span class="identifier-syntax">tc</span><span class="plain-syntax"> = </span><span class="constant-syntax">TAIL_AP_CLAUSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="4-anl.html#SP14" class="function-link"><span class="function-syntax">ActionNameLists::has_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="constant-syntax">SECOND_AP_CLAUSE</span><span class="plain-syntax">)) </span><span class="identifier-syntax">tc</span><span class="plain-syntax"> = </span><span class="constant-syntax">SECOND_AP_CLAUSE</span><span class="plain-syntax">;</span>

2
docs/if-module/4-as.html
View file

@ -185,7 +185,7 @@ preferred way to do that is to use activities for selecting missing parameters.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">ActionSemantics::can_have_noun</span><button class="popup" onclick="togglePopup('usagePopup7')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup7">Usage of <span class="code-font"><span class="function-syntax">ActionSemantics::can_have_noun</span></span>:<br/><a href="4-as.html#SP7">&#167;7</a><br/>Action Name Names - <a href="4-ann.html#SP13">&#167;13</a><br/>Action Name Lists - <a href="4-anl.html#SP24_2">&#167;24.2</a>, <a href="4-anl.html#SP29_1_3">&#167;29.1.3</a><br/>Parse Clauses - <a href="4-pc.html#SP1_5_6">&#167;1.5.6</a>, <a href="4-pc.html#SP1_6">&#167;1.6</a>, <a href="4-pc.html#SP5">&#167;5</a><br/>Explicit Actions - <a href="4-ea.html#SP3">&#167;3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">action_name</span><span class="plain-syntax"> *</span><span class="identifier-syntax">an</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">ActionSemantics::can_have_noun</span><button class="popup" onclick="togglePopup('usagePopup7')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup7">Usage of <span class="code-font"><span class="function-syntax">ActionSemantics::can_have_noun</span></span>:<br/><a href="4-as.html#SP7">&#167;7</a><br/>Action Name Names - <a href="4-ann.html#SP13">&#167;13</a><br/>Action Name Lists - <a href="4-anl.html#SP24_4">&#167;24.4</a>, <a href="4-anl.html#SP29_1_3">&#167;29.1.3</a><br/>Parse Clauses - <a href="4-pc.html#SP1_5_6">&#167;1.5.6</a>, <a href="4-pc.html#SP1_6">&#167;1.6</a>, <a href="4-pc.html#SP5">&#167;5</a><br/>Explicit Actions - <a href="4-ea.html#SP3">&#167;3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">action_name</span><span class="plain-syntax"> *</span><span class="identifier-syntax">an</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">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">semantics</span><span class="plain-syntax">.</span><span class="identifier-syntax">max_parameters</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">1</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

8
docs/if-module/4-pap.html
View file

@ -566,7 +566,7 @@ to enable Inform to set up a stack frame if there isn't one already, and so on.
</p>
<pre class="Preform-displayed-code all-displayed-code code-font">
<span class="Preform-function-syntax">&lt;ap-six&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
<span class="Preform-function-syntax">&lt;ap-sixxxxx&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;ap-seven&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">in</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">the</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">presence</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">of</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;s-ap-parameter&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { 0, RP[1] }; APClauses::set_spec(RP[1], IN_THE_PRESENCE_OF_AP_CLAUSE, RP[2]);</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;ap-seven&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { 0, RP[1] };</span>
</pre>
@ -576,7 +576,7 @@ so what's left can't very efficiently be written in Preform.
</p>
<pre class="Preform-displayed-code all-displayed-code code-font">
<span class="Preform-function-syntax">&lt;ap-seven&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">internal</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{</span>
<span class="Preform-function-syntax">&lt;ap-six&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">internal</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">{</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">if</span><span class="Preform-plain-syntax"> (</span><span class="Preform-identifier-syntax">Wordings::mismatched_brackets</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">)) { ==&gt; { </span><span class="Preform-identifier-syntax">fail</span><span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">nonterminal</span><span class="Preform-plain-syntax"> }; }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">if</span><span class="Preform-plain-syntax"> (</span><span class="Preform-identifier-syntax">parse_action_pattern_mode</span><span class="Preform-plain-syntax"> &amp; </span><span class="Preform-constant-syntax">SCANNING_ANL_ONLY</span><span class="Preform-plain-syntax">) {</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">action_name_list</span><span class="Preform-plain-syntax"> *</span><span class="Preform-identifier-syntax">list</span><span class="Preform-plain-syntax"> = </span><a href="4-anl.html#SP23" class="function-link"><span class="Preform-function-syntax">ActionNameLists::parse</span></a><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">prevailing_ap_tense</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">NULL</span><span class="Preform-plain-syntax">);</span>
@ -588,8 +588,8 @@ so what's left can't very efficiently be written in Preform.
<span class="Preform-plain-syntax"> } </span><span class="Preform-reserved-syntax">else</span><span class="Preform-plain-syntax"> {</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">LOGIF</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">ACTION_PATTERN_PARSING</span><span class="Preform-plain-syntax">, </span><span class="Preform-string-syntax">"Parsing action pattern: %W\n"</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">);</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">LOG_INDENT</span><span class="Preform-plain-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">action_pattern</span><span class="Preform-plain-syntax"> *</span><span class="Preform-identifier-syntax">ap1</span><span class="Preform-plain-syntax"> = </span><a href="4-pc.html#SP1" class="function-link"><span class="Preform-function-syntax">ParseClauses::parse</span></a><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">);</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">LOGIF</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">ACTION_PATTERN_PARSING</span><span class="Preform-plain-syntax">, </span><span class="Preform-string-syntax">"Method 1 on %W gives $A\n"</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">ap1</span><span class="Preform-plain-syntax">);</span>
<span class="Preform-comment-syntax"> action_pattern *ap1 = ParseClauses::parse(W);</span>
<span class="Preform-comment-syntax"> LOGIF(ACTION_PATTERN_PARSING, "Method 1 on %W gives $A\n", W, ap1);</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">action_pattern</span><span class="Preform-plain-syntax"> *</span><span class="Preform-identifier-syntax">ap2</span><span class="Preform-plain-syntax"> = </span><a href="4-pc.html#SP5" class="function-link"><span class="Preform-function-syntax">ParseClauses::experiment</span></a><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">);</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">LOGIF</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">ACTION_PATTERN_PARSING</span><span class="Preform-plain-syntax">, </span><span class="Preform-string-syntax">"Method 2 on %W gives $A\n"</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">ap2</span><span class="Preform-plain-syntax">);</span>
<span class="Preform-comment-syntax"> if ((ap1) &amp;&amp; (ap2 == NULL)) {</span>

2
docs/if-module/4-pc.html
View file

@ -752,7 +752,7 @@ We treat words like "something" specially to avoid them being read as
<span class="plain-syntax"> </span><span class="identifier-syntax">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">ACTION_PATTERN_PARSING</span><span class="plain-syntax">, </span><span class="string-syntax">"Writing clause %d '%W'\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_ID</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_text</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">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">stv_to_match</span><span class="plain-syntax">) </span><a href="4-apc.html#SP13" class="function-link"><span class="function-syntax">APClauses::set_action_variable_spec</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ap</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">stv_to_match</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">evaluation</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><a href="4-apc.html#SP6" class="function-link"><span class="function-syntax">APClauses::set_spec</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ap</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_ID</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">evaluation</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="4-gng.html#SP6" class="function-link"><span class="function-syntax">Going::new_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ap</span><span class="plain-syntax">, </span><a href="4-apc.html#SP5" class="function-link"><span class="function-syntax">APClauses::clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ap</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_ID</span><span class="plain-syntax">));</span>
<span class="comment-syntax"> Going::new_clause(ap, APClauses::clause(ap, c-&gt;clause_ID));</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">ap</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

2
docs/if-module/5-tfg.html
View file

@ -824,7 +824,7 @@ problem message for this case is now commented out.
<span class="plain-syntax"> </span><span class="string-syntax">"text"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"such as \"eternity\" or \"peruvian skies\"."</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">TEST_COMPILATION_MODE</span><span class="plain-syntax">(</span><span class="identifier-syntax">SPECIFICATIONS_CMODE</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_NontextualUnderstandInAP</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">BelievedImpossible</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the topic here should be in the form of a textual description"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"as in 'asking about \"[something]\"'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>

628
inform7/Downloads/preform-diagnostics.txt
View file

File diff suppressed because it is too large Load diff

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

@ -1,17 +1,17 @@
Total memory consumption was 260175K = 254 MB
Total memory consumption was 259375K = 253 MB
62.7% was used for 1348015 objects, in 279852 frames in 204 x 800K = 163200K = 159 MB:
62.6% was used for 1340427 objects, in 278953 frames in 203 x 800K = 162400K = 158 MB:
9.7% inter_tree_node_array 36 x 8192 = 294912 objects, 25953408 bytes
5.4% text_stream_array 2595 x 100 = 259500 objects, 14615040 bytes
3.9% parse_node 131134 objects, 10490720 bytes
5.5% text_stream_array 2595 x 100 = 259500 objects, 14615040 bytes
3.9% parse_node 130245 objects, 10419600 bytes
2.7% verb_conjugation 160 objects, 7425280 bytes
2.6% parse_node_annotation_array 434 x 500 = 217000 objects, 6957888 bytes
2.6% parse_node_annotation_array 432 x 500 = 216000 objects, 6925824 bytes
2.4% linked_list 11782 objects, 6597920 bytes
2.3% inter_symbol_array 70 x 1024 = 71680 objects, 6310080 bytes
1.2% pcalc_prop_array 25 x 1000 = 25000 objects, 3400800 bytes
1.2% pcalc_prop_array 24 x 1000 = 24000 objects, 3264768 bytes
1.1% map_data 670 objects, 3178480 bytes
0.9% kind_array 66 x 1000 = 66000 objects, 2642112 bytes
0.9% kind_array 65 x 1000 = 65000 objects, 2602080 bytes
0.7% inter_schema_token 13492 objects, 1942848 bytes
0.6% vocabulary_entry_array 161 x 100 = 16100 objects, 1808352 bytes
0.5% match_trie_array 10 x 1000 = 10000 objects, 1360320 bytes
@ -39,14 +39,14 @@ Total memory consumption was 260175K = 254 MB
0.1% scan_directory 70 objects, 288960 bytes
0.1% noun 2379 objects, 285480 bytes
---- inference_subject 665 objects, 260680 bytes
---- anl_entry_array 4 x 1000 = 4000 objects, 224128 bytes
---- inter_annotation_array 1 x 8192 objects, 196640 bytes
---- linguistic_stock_item 3315 objects, 159120 bytes
---- binary_predicate 321 objects, 156648 bytes
---- stacked_variable_owner_list_array 38 x 100 = 3800 objects, 153216 bytes
---- index_lexicon_entry 395 objects, 142200 bytes
---- nonterminal 767 objects, 141128 bytes
---- nonterminal 768 objects, 141312 bytes
---- documentation_ref 1275 objects, 112200 bytes
---- anl_entry_array 2 x 1000 = 2000 objects, 112064 bytes
---- inference 1703 objects, 108992 bytes
---- hierarchy_location 730 objects, 105120 bytes
---- noun_usage 2401 objects, 96040 bytes
@ -55,7 +55,6 @@ Total memory consumption was 260175K = 254 MB
---- pcalc_term_array 2 x 1000 = 2000 objects, 80064 bytes
---- kind_variable_declaration 1652 objects, 79296 bytes
---- inter_tree 6 objects, 78624 bytes
---- ap_clause_array 3 x 400 = 1200 objects, 76896 bytes
---- inter_schema 1509 objects, 72432 bytes
---- rulebook 407 objects, 71632 bytes
---- spatial_data 670 objects, 64320 bytes
@ -66,22 +65,22 @@ Total memory consumption was 260175K = 254 MB
---- ph_stack_frame_box 577 objects, 55392 bytes
---- kind_constructor 77 objects, 54824 bytes
---- property_inference_data 1315 objects, 52600 bytes
---- ap_clause_array 2 x 400 = 800 objects, 51264 bytes
---- text_substitution 436 objects, 48832 bytes
---- grammar_line 230 objects, 46000 bytes
---- table 7 objects, 45528 bytes
---- inter_node_list 750 objects, 42000 bytes
---- action_pattern_array 10 x 100 = 1000 objects, 40320 bytes
---- anl_clause_text_array 1 x 1000 objects, 40032 bytes
---- activity_list_array 1 x 1000 objects, 40032 bytes
---- anl_clause_text_array 1 x 1000 objects, 40032 bytes
---- response_message 407 objects, 35816 bytes
---- production_list 623 objects, 34888 bytes
---- regions_data 670 objects, 32160 bytes
---- action_name_list_array 2 x 1000 = 2000 objects, 32064 bytes
---- HTML_tag_array 1 x 1000 objects, 32032 bytes
---- property_permission 96 objects, 30720 bytes
---- verb_sense 403 objects, 29016 bytes
---- stacked_variable_owner_array 6 x 100 = 600 objects, 28992 bytes
---- heading 198 objects, 28512 bytes
---- action_pattern_array 7 x 100 = 700 objects, 28224 bytes
---- counting_data 670 objects, 26800 bytes
---- parsing_data 670 objects, 21440 bytes
---- bp_runtime_implementation 321 objects, 20544 bytes
@ -92,6 +91,7 @@ Total memory consumption was 260175K = 254 MB
---- action_name 90 objects, 18000 bytes
---- parse_node_tree 20 objects, 17280 bytes
---- match_avinue_array 1 x 1000 objects, 16032 bytes
---- action_name_list_array 1 x 1000 objects, 16032 bytes
---- linked_list_item_array 1 x 1000 objects, 16032 bytes
---- to_phrase_request 59 objects, 15576 bytes
---- method 323 objects, 15504 bytes
@ -124,8 +124,8 @@ Total memory consumption was 260175K = 254 MB
---- inbuild_copy 35 objects, 3640 bytes
---- command_line_switch 43 objects, 3440 bytes
---- property_setting_bp_data 84 objects, 3360 bytes
---- instance_usage_array 1 x 200 objects, 3232 bytes
---- kind_constructor_comparison_schema_array 1 x 100 objects, 3232 bytes
---- instance_usage_array 1 x 200 objects, 3232 bytes
---- method_set 100 objects, 3200 bytes
---- definition 44 objects, 3168 bytes
---- compatibility_specification 66 objects, 3168 bytes
@ -134,8 +134,8 @@ Total memory consumption was 260175K = 254 MB
---- either_or_property_data 62 objects, 2976 bytes
---- submodule_request 72 objects, 2880 bytes
---- inter_construct 32 objects, 2560 bytes
---- parentage_inference_data 79 objects, 2528 bytes
---- part_of_inference_data 79 objects, 2528 bytes
---- parentage_inference_data 79 objects, 2528 bytes
---- kind_constructor_casting_rule_array 1 x 100 objects, 2432 bytes
---- kind_constructor_instance_array 1 x 100 objects, 2432 bytes
---- equation_symbol 30 objects, 2400 bytes
@ -229,9 +229,9 @@ Total memory consumption was 260175K = 254 MB
---- loop_over_scope 1 object, 40 bytes
---- parse_name_notice 1 object, 40 bytes
37.2% was used for memory not allocated for objects:
37.3% was used for memory not allocated for objects:
15.8% text stream storage 42247328 bytes in 265813 claims
15.9% text stream storage 42247328 bytes in 265813 claims
3.4% dictionary storage 9278976 bytes in 16372 claims
---- sorting 1056 bytes in 3 claims
2.7% source text 7200000 bytes in 3 claims
@ -247,5 +247,5 @@ Total memory consumption was 260175K = 254 MB
---- emitter array storage 12320 bytes in 8 claims
---- code generation workspace for objects 9200 bytes in 9 claims
20.3% was overhead - 54243912 bytes = 52972K = 51 MB
20.2% was overhead - 53869600 bytes = 52607K = 51 MB

18
inform7/Figures/preform-summary.txt
View file

@ -1,25 +1,25 @@
<s-literal> hits 2097/23958 nti 12 constraint (none) extremes [1, infinity)
<s-literal> hits 2097/23850 nti 12 constraint (none) extremes [1, infinity)
English:
(@1)<cardinal-number>=1
(hits 171/171) (matched: '100') constraint CS = {r0} extremes [1, 1]
(@1)minus (@2)<cardinal-number>=1
(hits 0/1887) constraint DS = {12} extremes [2, 2]
(hits 0/1866) constraint DS = {12} extremes [2, 2]
(@1)<quoted-text>=1 (@2)( (@3)<response-letter>=2 (@4))
(hits 273/855) (matched: '"[current item from the multiple object list]: [run paragraph on]" ( a )') constraint DS = {12} extremes [4, 4]
(hits 273/844) (matched: '"[current item from the multiple object list]: [run paragraph on]" ( a )') constraint DS = {12} extremes [4, 4]
(@1)<quoted-text>=1
(hits 1564/5566) (matched: 'Represents geographical locations, both indoor
(hits 1564/5549) (matched: 'Represents geographical locations, both indoor
and outdoor, which are not necessarily areas in a building. A player in one
room is mostly unable to sense, or interact with, anything in a different room.
Rooms are arranged in a map.') constraint (none) extremes [1, 1]
<s-literal-real-number>=1
(hits 11/9971) (matched: 'plus infinity') constraint (none) extremes [1, infinity)
(hits 11/9917) (matched: 'plus infinity') constraint (none) extremes [1, infinity)
(@1)<s-literal-truth-state>=1
(hits 78/273) (matched: 'false') constraint CS = {6} extremes [1, 1]
<s-literal-list>=1
(hits 0/3176) constraint DS = {8} extremes [2, infinity)
(hits 0/3142) constraint DS = {8} extremes [2, infinity)
(@1)unicode <s-unicode-character>=1
(hits 0/4303) constraint DS = {12} extremes [2, infinity)
(hits 0/4226) constraint DS = {12} extremes [2, infinity)
<s-literal-time>=1
(hits 0/2184) constraint DW = {9, 10, 11} extremes [2, 5]
(hits 0/2160) constraint DW = {9, 10, 11} extremes [2, 5]
<s-literal-unit-notation>=1
(hits 0/9882) constraint (none) extremes [1, infinity)
(hits 0/9828) constraint (none) extremes [1, infinity)

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

@ -1,29 +1,29 @@
100.0% in inform7 run
67.3% in compilation to Inter
26.3% in //Phrases::Manager::compile_first_block//
67.0% in compilation to Inter
25.7% in //Phrases::Manager::compile_first_block//
8.4% in //Phrases::Manager::compile_as_needed//
7.0% in //Strings::compile_responses//
6.1% in //InferenceSubjects::emit_all//
6.9% in //Strings::compile_responses//
6.2% in //InferenceSubjects::emit_all//
4.2% in //MajorNodes::pre_pass//
3.3% in //MajorNodes::pass_1//
1.9% in //Phrases::Manager::RulePrintingRule_routine//
1.9% in //Phrases::Manager::rulebooks_array//
1.0% in //RTVerbs::ConjugateVerb//
0.8% in //Phrases::Manager::traverse//
0.7% in //Phrases::Manager::parse_rule_parameters//
0.5% in //Phrases::Manager::compile_rulebooks//
0.5% in //World::stage_V//
0.3% in //MajorNodes::pass_2//
0.3% in //Phrases::Manager::compile_rulebooks//
0.3% in //Phrases::Manager::parse_rule_parameters//
0.3% in //RTRelations::compile_defined_relations//
0.1% in //PL::Parsing::Verbs::compile_all//
0.1% in //RTKinds::compile_data_type_support_routines//
0.1% in //Task::make_built_in_kind_constructors//
0.1% in //World::stages_II_and_III//
2.9% not specifically accounted for
30.3% in running Inter pipeline
9.8% in inter step 2/12: link
9.5% in step preparation
7.2% in inter step 12/12: generate inform6 -> auto.inf
3.2% not specifically accounted for
30.5% in running Inter pipeline
9.8% in step preparation
9.6% in inter step 2/12: link
7.1% in inter step 12/12: generate inform6 -> auto.inf
0.3% in inter step 9/12: make-identifiers-unique
0.1% in inter step 10/12: reconcile-verbs
0.1% in inter step 11/12: eliminate-redundant-labels
@ -31,6 +31,6 @@
0.1% in inter step 6/12: assimilate
0.1% in inter step 7/12: resolve-external-symbols
0.1% in inter step 8/12: inspect-plugs
2.3% not specifically accounted for
2.5% not specifically accounted for
1.9% in supervisor
0.4% not specifically accounted for

19
inform7/Tests/Groups/actions.testgroup
View file

@ -1,22 +1,23 @@
ActionPatternParsing
NPCAsking
APRegionAdaptation
Locks
TinyForest
C12RuleSorting1
C12RuleSorting2
C12RuleSorting3
C12RuleSorting4
C12RuleSorting5
StoredActionsWithValues
RelDynamicPointer
ConstantStoredActionsWithTopics
InheritedStoredActions
TableDefinedSAs
ForLengthsOfTime
C9ScenesPastTenseActions
CHS
ConstantStoredActionsWithTopics
DoingSomethingIn
ForLengthsOfTime
InheritedStoredActions
Locks
NPCAsking
RegionBoundary
RelDynamicPointer
StoredActionsWithValues
TableDefinedSAs
TinyForest
PM_ActionBothValues
PM_ActionVarAnd
PM_ActionVarOverspecific

2
inform7/Tests/Test Cases/ActionPatternParsing.txt
View file

@ -50,6 +50,8 @@ Test pattern (internal) with list looking or taking inventory in the Laboratory
Test pattern (internal) with list looking or taking inventory in the presence of Hans in the Laboratory.
Test pattern (internal) with list looking in in in in in in in in in in in in in in in in in in in in.
Test pattern (internal) with list going from the Laboratory to the Castle.
Test pattern (internal) with list listening.
Test pattern (internal) with list listening in the presence of Hans.
Test pattern (internal) with list gluttony.
Test pattern (internal) with list gluttony in the Laboratory.

16
inform7/Tests/Test Cases/DoingSomethingIn.txt Normal file
View file

@ -0,0 +1,16 @@
Place is a room.
The radio is here. The radio is a device.
Hans is a man in the Place.
Instead of listening in the presence of the radio: say "Ugh."
Before doing something in the Place:
say "Sure...";
continue the action.
Before asking someone to try doing something in the presence of a person:
say "Nope."
Test me with "listen / hans, take radio".

23
inform7/Tests/Test Cases/_Results_Ideal/ActionPatternParsing.txt
View file

@ -139,26 +139,37 @@
(4). +0 : going [noun: from the laboratory to the castle]
33. list gluttony
33. list listening
Action name list for: listening
(1). +0 : listening to
34. list listening in the presence of Hans
Action name list for: listening in the presence of hans
(1). +0 : listening to [in: the presence of hans] [in-presence: hans]
(2). +0 : listening to [in-presence: hans]
35. list gluttony
Action name list for: gluttony
(1). +0 : gluttony
34. list gluttony in the Laboratory
36. list gluttony in the Laboratory
Action name list for: gluttony in the laboratory
(1). +0 : gluttony [in: the laboratory]
35. experimental looking
37. experimental looking
experimental looking: <action-based: looking>
36. experimental taking inventory
38. experimental taking inventory
experimental taking inventory: <action-based: taking inventory>
37. experimental looking in the Laboratory
39. experimental looking in the Laboratory
experimental looking in the laboratory: <action-based: looking * in: 'radiation laboratory'>
38. experimental gluttony in the Laboratory
40. experimental gluttony in the Laboratory
experimental gluttony in the laboratory: <action-based: gluttony * in: 'radiation laboratory'>
> > Radiation Laboratory

24
inform7/Tests/Test Cases/_Results_Ideal/DoingSomethingIn.txt Normal file
View file

@ -0,0 +1,24 @@
Place
Welcome
An Interactive Fiction
Release 1 / Serial number 160428 / Inform 7 build 9Z99 (I6/v6.34) SD
Sure...
Place
You can see a radio and Hans here.
> > Place
(Testing.)
>[1] listen
Sure...
Ugh.
>[2] hans, take radio
Nope.
Hans has better things to do.
> >

8
inform7/Tests/Test Problems/PM_NontextualUnderstandInAP.txt
View file

@ -1,8 +0,0 @@
Place is a room.
Bob is a man in Place.
The player carries a ball.
Instead of asking Bob about the "ball" (this is the Bob recognizes rule):
say "'Looks like a basketball.'"

47
inform7/Tests/Test Problems/_Results_Ideal/PM_APWithImmiscible.txt
View file

@ -1,27 +1,30 @@
Inform 7 build 6L28 has started.
Inform 7 v10.1.0 has started.
I've now read your source text, which is 179 words long.
I've also read Standard Rules by Graham Nelson, which is 42597 words long.
I've also read English Language by Graham Nelson, which is 2288 words long.
Problem__ PM_APWithImmiscible
I've also read Basic Inform by Graham Nelson, which is 7687 words long.
I've also read English Language by Graham Nelson, which is 2328 words long.
I've also read Standard Rules by Graham Nelson, which is 32067 words long.
Problem__ PM_APWithDisjunction
>--> You wrote 'Instead of dropping the CD or inserting the CD into the jewel
box' (source text, line 5), which seems to introduce a rule taking effect
only 'dropping the CD or inserting the CD into the jewel box'. But this is
a combination of actions which cannot be mixed. The only alternatives where
'or' is allowed are cases where a choice of actions is given but applying
to the same objects in each case. (So 'taking or dropping the CD' is
allowed, but 'dropping the CD or inserting the CD into the jewel box' is
not, because the alternatives there would make different use of objects
from each other.)
Problem__ PM_APWithImmiscible
box' (source text, line 5), which seems to introduce a rule, but the
circumstances ('dropping the CD or inserting the CD into the jewel box')
seem to be too general for me to understand in a single rule. I can
understand a choice of of actions, in a list such as 'taking or dropping
the ball', but there can only be one set of noun(s) supplied. So 'taking
the ball or taking the bat' is disallowed. You can get around this by using
named actions ('Taking the ball is being mischievous. Taking the bat is
being mischievous. Instead of being mischievous...'), or it may be less
bother just to write more than one rule.
Problem__ PM_APWithDisjunction
>--> You wrote 'Instead of inserting the CD into the jewel box or dropping
the CD' (source text, line 8), which seems to introduce a rule taking
effect only 'inserting the CD into the jewel box or dropping the CD'. But
this is a combination of actions which cannot be mixed. The only
alternatives where 'or' is allowed are cases where a choice of actions is
given but applying to the same objects in each case. (So 'taking or
dropping the CD' is allowed, but 'dropping the CD or inserting the CD into
the jewel box' is not, because the alternatives there would make different
use of objects from each other.)
the CD' (source text, line 8), which seems to introduce a rule, but the
circumstances ('inserting the CD into the jewel box or dropping the CD')
seem to be too general for me to understand in a single rule. I can
understand a choice of of actions, in a list such as 'taking or dropping
the ball', but there can only be one set of noun(s) supplied. So 'taking
the ball or taking the bat' is disallowed. You can get around this by using
named actions ('Taking the ball is being mischievous. Taking the bat is
being mischievous. Instead of being mischievous...'), or it may be less
bother just to write more than one rule.
Problem__ PM_APWithImmiscible
>--> You wrote 'Instead of inserting the CD into the jewel box or looking' (source
text, line 11), which seems to introduce a rule taking effect only
@ -79,4 +82,4 @@ Problem__ PM_APWithImmiscible
dropping the CD' is allowed, but 'dropping the CD or inserting the CD into
the jewel box' is not, because the alternatives there would make different
use of objects from each other.)
Inform 7 has finished: 22 centiseconds used.
Inform 7 has finished.

5
inform7/Tests/Test Problems/_Results_Ideal/PM_GoingWithoutObject.txt
View file

@ -7,4 +7,9 @@ Problem__ PM_GoingWithoutObject
>--> In the sentence 'Before going to 10' (source text, line 3), '10' seems
to be intended as something the player might be going to, but it doesn't
make sense in that context.
Problem__ PM_APUnknown
>--> You wrote 'Before going to 10' (source text, line 3), which seems to
introduce a rule taking effect only if the action is 'going to 10'. But
that did not make sense as a description of an action. I am unable to place
this rule into any rulebook.
Inform 7 has finished.

9
inform7/Tests/Test Problems/_Results_Ideal/PM_NontextualUnderstandInAP.txt
View file

@ -1,9 +0,0 @@
Inform 7 build 6M38 has started.
I've now read your source text, which is 33 words long.
I've also read Standard Rules by Graham Nelson, which is 42506 words long.
I've also read English Language by Graham Nelson, which is 2288 words long.
Problem__ PM_NontextualUnderstandInAP
>--> You wrote 'Instead of asking Bob about the "ball" (this is the Bob
recognizes rule)' (source text, line 7): but the topic here should be in
the form of a textual description, as in 'asking about "[something]"'.
Inform 7 has finished: 72 centiseconds used.

36
inform7/if-module/Chapter 4/Action Name Lists.w
View file

@ -622,6 +622,7 @@ The test group |:anl| is helpful in catching errors here.
int anl_parsing_tense = IS_TENSE;
int experimental_anl_system = FALSE;
action_name_list *ActionNameLists::parse(wording W, int tense, int *sense) {
experimental_anl_system = TRUE;
if (Wordings::mismatched_brackets(W)) return NULL;
int t = anl_parsing_tense;
anl_parsing_tense = tense;
@ -640,9 +641,9 @@ action_name_list *ActionNameLists::parse(wording W, int tense, int *sense) {
<action-list> ::=
doing something/anything other than <excluded-list> | ==> { FALSE, RP[1] }
doing something/anything except <excluded-list> | ==> { FALSE, RP[1] }
doing something/anything to/with <anl-to-tail> | ==> { TRUE, ActionNameLists::new_list(RP[1], ANL_POSITIVE) }
doing something/anything to/with <anl-to-tail> | ==> @<Construct ANL for anything to@>
doing something/anything | ==> @<Construct ANL for anything@>
doing something/anything ... | ==> { fail }
doing something/anything {...} | ==> { -, - }; wording TW = WR[1]; @<Construct ANL for doing something with a tail@>
<anl> ==> { TRUE, ActionNameLists::new_list(RP[1], ANL_POSITIVE) }
<excluded-list> ::=
@ -654,10 +655,21 @@ action_name_list *ActionNameLists::parse(wording W, int tense, int *sense) {
... to/with ... | ==> { fail }
...
@<Construct ANL for anything to@> =
anl_entry *results = RP[1];
@<Extend the list to provide for clauses@>;
==> { TRUE, ActionNameLists::new_list(results, ANL_POSITIVE) }
@<Construct ANL for anything@> =
anl_entry *entry = ActionNameLists::new_entry_at(W);
==> { TRUE, ActionNameLists::new_list(entry, ANL_POSITIVE) };
@<Construct ANL for doing something with a tail@> =
anl_entry *results = ActionNameLists::new_entry_at(W);
ActionNameLists::set_clause_wording(results, TAIL_AP_CLAUSE, TW);
@<Extend the list to provide for clauses@>;
==> { TRUE, ActionNameLists::new_list(results, ANL_POSITIVE) };
@<Add to-clause to excluded ANL@> =
anl_entry *entry = RP[1];
if ((entry == NULL) ||
@ -665,7 +677,9 @@ action_name_list *ActionNameLists::parse(wording W, int tense, int *sense) {
==> { fail production };
}
ActionNameLists::add_parameter(entry, GET_RW(<excluded-list>, 1));
==> { FALSE, ActionNameLists::new_list(entry, ANL_NEGATED_ITEMWISE) };
anl_entry *results = entry;
@<Extend the list to provide for clauses@>;
==> { FALSE, ActionNameLists::new_list(results, ANL_NEGATED_ITEMWISE) };
@ The trickiest form is:
@ -814,6 +828,7 @@ end, but it's syntactically valid.)
LOOP_OVER(an, action_name) {
@<Ready the trial entry for another test@>;
wording RW = EMPTY_WORDING;
int abbreviated_to_tail = FALSE;
@<Make the trial entry fit this action, if possible, leaving remaining text in RW@>;
@<Consider the trial entry for inclusion in the results list@>;
NoMatch: ;
@ -835,9 +850,15 @@ inelegant, but there's no elegant way to break out of nested loops in C.
int it_optional = ActionNameNames::it_optional(an);
int abbreviable = ActionNameNames::abbreviable(an);
wording XW = ActionNameNames::tensed(an, anl_parsing_tense);
int w_m = Wordings::first_wn(W), x_m = Wordings::first_wn(XW);
int w_m = Wordings::first_wn(W), x_m = Wordings::first_wn(XW), n = 0;
while ((w_m <= Wordings::last_wn(W)) && (x_m <= Wordings::last_wn(XW))) {
if (Lexer::word(x_m++) != Lexer::word(w_m++)) goto NoMatch;
if (Lexer::word(x_m++) != Lexer::word(w_m++)) {
if ((abbreviable) && (it_optional) && (n >= 1)) {
x_ended = TRUE; abbreviated_to_tail = TRUE; x_m--; w_m--;
} else goto NoMatch;
break;
}
n++;
if (x_m > Wordings::last_wn(XW)) { x_ended = TRUE; break; }
if (<object-pronoun>(Wordings::one_word(x_m))) {
if (w_m > Wordings::last_wn(W)) x_ended = TRUE; else {
@ -868,9 +889,10 @@ inelegant, but there's no elegant way to break out of nested loops in C.
@<Include the trial entry@>;
} else {
if (experimental_anl_system) {
if (ActionSemantics::can_have_noun(an)) {
if (ActionNameLists::parse_to_tail(trial_entry, RW))
if ((ActionSemantics::can_have_noun(an)) && (abbreviated_to_tail == FALSE)) {
if (ActionNameLists::parse_to_tail(trial_entry, RW)) {
@<Include the trial entry@>;
}
} else {
ActionNameLists::set_clause_wording(trial_entry, TAIL_AP_CLAUSE, RW);
@<Include the trial entry@>;

8
inform7/if-module/Chapter 4/Parse Action Patterns.w
View file

@ -444,7 +444,7 @@ to enable Inform to set up a stack frame if there isn't one already, and so on.
A quick one: the optional "in the presence of".
=
<ap-six> ::=
<ap-sixxxxx> ::=
<ap-seven> in the presence of <s-ap-parameter> | ==> { 0, RP[1] }; APClauses::set_spec(RP[1], IN_THE_PRESENCE_OF_AP_CLAUSE, RP[2]);
<ap-seven> ==> { 0, RP[1] };
@ -453,7 +453,7 @@ Much of the complexity is gone now, but much potential ambiguity remains, and
so what's left can't very efficiently be written in Preform.
=
<ap-seven> internal {
<ap-six> internal {
if (Wordings::mismatched_brackets(W)) { ==> { fail nonterminal }; }
if (parse_action_pattern_mode & SCANNING_ANL_ONLY) {
action_name_list *list = ActionNameLists::parse(W, prevailing_ap_tense, NULL);
@ -465,8 +465,8 @@ so what's left can't very efficiently be written in Preform.
} else {
LOGIF(ACTION_PATTERN_PARSING, "Parsing action pattern: %W\n", W);
LOG_INDENT;
action_pattern *ap1 = ParseClauses::parse(W);
LOGIF(ACTION_PATTERN_PARSING, "Method 1 on %W gives $A\n", W, ap1);
// action_pattern *ap1 = ParseClauses::parse(W);
// LOGIF(ACTION_PATTERN_PARSING, "Method 1 on %W gives $A\n", W, ap1);
action_pattern *ap2 = ParseClauses::experiment(W);
LOGIF(ACTION_PATTERN_PARSING, "Method 2 on %W gives $A\n", W, ap2);
/* if ((ap1) && (ap2 == NULL)) {

2
inform7/if-module/Chapter 4/Parse Clauses.w
View file

@ -615,7 +615,7 @@ action_pattern *ParseClauses::experiment(wording W) {
LOGIF(ACTION_PATTERN_PARSING, "Writing clause %d '%W'\n", c->clause_ID, c->clause_text);
if (c->stv_to_match) APClauses::set_action_variable_spec(ap, c->stv_to_match, c->evaluation);
else APClauses::set_spec(ap, c->clause_ID, c->evaluation);
Going::new_clause(ap, APClauses::clause(ap, c->clause_ID));
// Going::new_clause(ap, APClauses::clause(ap, c->clause_ID));
}
return ap;
}

2
inform7/if-module/Chapter 5/Traverse for Grammar.w
View file

@ -613,7 +613,7 @@ void PL::Parsing::understand_block(wording W, understanding_reference *ur, wordi
"text",
"such as \"eternity\" or \"peruvian skies\".");
else if (TEST_COMPILATION_MODE(SPECIFICATIONS_CMODE))
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_NontextualUnderstandInAP),
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible),
"the topic here should be in the form of a textual description",
"as in 'asking about \"[something]\"'.");
else

16
services/lexicon-module/Figures/excerpts-diagnostics.txt
View file

@ -1,15 +1,15 @@
Size of lexicon: 3098 excerpt meanings
Stored among 840 words out of total vocabulary of 10569
Stored among 840 words out of total vocabulary of 10570
710 words have a start list: longest belongs to report (with 293 meanings)
15 words have an end list: longest belongs to case (with 6 meanings)
29 words have a middle list: longest belongs to to (with 4 meanings)
108 words have a subset list: longest belongs to street (with 4 meanings)
Number of attempts to retrieve: 107235
of which unsuccessful: 89577
of which successful: 17658
Number of attempts to retrieve: 106268
of which unsuccessful: 88665
of which successful: 17603
Total attempts to match against excerpt meanings: 253759
of which, total with incorrect hash codes: 231602
of which, total with correct hash codes: 22157
of which, total which matched: 19424
Total attempts to match against excerpt meanings: 253387
of which, total with incorrect hash codes: 231381
of which, total with correct hash codes: 22006
of which, total which matched: 19273