Tentative experiments

docs/if-module/4-anl.html

@@ -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#SP22_1">&#167;22.1</a>, <a href="4-anl.html#SP25_1">&#167;25.1</a>, <a href="4-anl.html#SP25_2">&#167;25.2</a>, <a href="4-anl.html#SP26_1">&#167;26.1</a>, <a href="4-anl.html#SP26_1_3_1">&#167;26.1.3.1</a>, <a href="4-anl.html#SP26_1_3_2">&#167;26.1.3.2</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#SP22_1">&#167;22.1</a>, <a href="4-anl.html#SP24">&#167;24</a>, <a href="4-anl.html#SP26_1">&#167;26.1</a>, <a href="4-anl.html#SP26_2">&#167;26.2</a>, <a href="4-anl.html#SP27_1">&#167;27.1</a>, <a href="4-anl.html#SP27_1_3_1">&#167;27.1.3.1</a>, <a href="4-anl.html#SP27_1_3_2">&#167;27.1.3.2</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>
@@ -217,7 +217,7 @@ entries which fail to change the word position.
 </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::join_to</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::join_to</span></span>:<br/><a href="4-anl.html#SP8">&#167;8</a>, <a href="4-anl.html#SP26_1_3_2">&#167;26.1.3.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">earlier</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">later</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::join_to</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::join_to</span></span>:<br/><a href="4-anl.html#SP8">&#167;8</a>, <a href="4-anl.html#SP27_1_3_2">&#167;27.1.3.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">earlier</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">later</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#SP8" class="function-link"><span class="function-syntax">ActionNameLists::precedes</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">later</span><span class="plain-syntax">, </span><span class="identifier-syntax">earlier</span><span class="plain-syntax">)) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"misordering"</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">earlier</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_entry</span><span class="plain-syntax"> = </span><span class="identifier-syntax">later</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
@@ -246,7 +246,7 @@ are in the list.
 </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">ActionNameLists::precedes</span><button class="popup" onclick="togglePopup('usagePopup11')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup11">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::precedes</span></span>:<br/><a href="4-anl.html#SP7">&#167;7</a>, <a href="4-anl.html#SP26_1_3_2">&#167;26.1.3.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">e1</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">e2</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::precedes</span><button class="popup" onclick="togglePopup('usagePopup11')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup11">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::precedes</span></span>:<br/><a href="4-anl.html#SP7">&#167;7</a>, <a href="4-anl.html#SP27_1_3_2">&#167;27.1.3.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">e1</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">e2</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">e1</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">e2</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
 
@@ -269,7 +269,7 @@ are in the list.
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::join_entry</span><button class="popup" onclick="togglePopup('usagePopup12')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup12">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::join_entry</span></span>:<br/><a href="4-anl.html#SP24">&#167;24</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">further</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">tail</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::join_entry</span><button class="popup" onclick="togglePopup('usagePopup12')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup12">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::join_entry</span></span>:<br/><a href="4-anl.html#SP25">&#167;25</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">further</span><span class="plain-syntax">, </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">tail</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">further</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">tail</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">tail</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">further</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">tail</span><span class="plain-syntax">;</span>
@@ -333,7 +333,7 @@ anything" &mdash; a completely unrestricted action.
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">item</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::clear_item_data</span><button class="popup" onclick="togglePopup('usagePopup17')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup17">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::clear_item_data</span></span>:<br/><a href="4-anl.html#SP26_1_1">&#167;26.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">action_name</span><span class="plain-syntax"> *</span><span class="identifier-syntax">an</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::clear_item_data</span><button class="popup" onclick="togglePopup('usagePopup17')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup17">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::clear_item_data</span></span>:<br/><a href="4-anl.html#SP27_1_1">&#167;27.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">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="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">item</span><span class="plain-syntax">.</span><span class="element-syntax">action_listed</span><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">entry</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">item</span><span class="plain-syntax">.</span><span class="element-syntax">nap_listed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
@@ -430,7 +430,7 @@ the text leading to a list:
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="reserved-syntax">parsing_data</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::clear_parsing_data</span><button class="popup" onclick="togglePopup('usagePopup24')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup24">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::clear_parsing_data</span></span>:<br/><a href="4-anl.html#SP26_1_1">&#167;26.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="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax">) {</span>
+<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::clear_parsing_data</span><button class="popup" onclick="togglePopup('usagePopup24')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup24">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::clear_parsing_data</span></span>:<br/><a href="4-anl.html#SP27_1_1">&#167;27.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="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="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="reserved-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="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>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::nonempty</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)) </span><span class="identifier-syntax">at</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>
@@ -452,12 +452,12 @@ 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">EMPTY_WORDING</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::set_clause_wording</span><button class="popup" onclick="togglePopup('usagePopup27')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup27">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::set_clause_wording</span></span>:<br/><a href="4-anl.html#SP15">&#167;15</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('usagePopup27')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup27">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::set_clause_wording</span></span>:<br/><a href="4-anl.html#SP15">&#167;15</a>, <a href="4-anl.html#SP24">&#167;24</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>
 <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="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="identifier-syntax">W</span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</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="identifier-syntax">W</span><span class="plain-syntax">; </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">entry</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">c</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_ID</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">C</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">Insert clause here</span><span class="named-paragraph-number">14.1</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">prev</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">;</span>
@@ -475,6 +475,7 @@ the text leading to a list:
 <span class="plain-syntax">    </span><span class="identifier-syntax">nc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">clause_text</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">prev</span><span class="plain-syntax">) { </span><span class="identifier-syntax">nc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</span><span class="plain-syntax">; </span><span class="identifier-syntax">prev</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</span><span class="plain-syntax"> = </span><span class="identifier-syntax">nc</span><span class="plain-syntax">; }</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">else</span><span class="plain-syntax"> { </span><span class="identifier-syntax">nc</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_clause</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</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">nc</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">entry</span><span class="plain-syntax">;</span>
 </pre>
 <ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP14">&#167;14</a> (twice).</li></ul>
 <p class="commentary firstcommentary"><a id="SP15" class="paragraph-anchor"></a><b>&#167;15.  </b></p>
@@ -490,7 +491,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('usagePopup30')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup30">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_parameter</span></span>:<br/><a href="4-anl.html#SP22_2">&#167;22.2</a>, <a href="4-anl.html#SP26_1_2">&#167;26.1.2</a>, <a href="4-anl.html#SP26_1_3_1">&#167;26.1.3.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="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('usagePopup30')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup30">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_parameter</span></span>:<br/><a href="4-anl.html#SP22_2">&#167;22.2</a>, <a href="4-anl.html#SP27_1_2">&#167;27.1.2</a>, <a href="4-anl.html#SP27_1_3_1">&#167;27.1.3.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="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>
@@ -500,7 +501,7 @@ 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">entry</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_in_clause</span><button class="popup" onclick="togglePopup('usagePopup31')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup31">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_in_clause</span></span>:<br/><a href="4-anl.html#SP23_1">&#167;23.1</a>, <a href="4-anl.html#SP25_2">&#167;25.2</a>, <a href="4-anl.html#SP26_1_3">&#167;26.1.3</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_in_clause</span><button class="popup" onclick="togglePopup('usagePopup31')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup31">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::add_in_clause</span></span>:<br/><a href="4-anl.html#SP23_1">&#167;23.1</a>, <a href="4-anl.html#SP26_2">&#167;26.2</a>, <a href="4-anl.html#SP27_1_3">&#167;27.1.3</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><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">IN_AP_CLAUSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">entry</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
@@ -625,7 +626,7 @@ is no best action. (For example, in "throwing or removing something".)
 <span class="plain-syntax">    }</span>
 <span class="plain-syntax">}</span>
 
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::log_entry</span><button class="popup" onclick="togglePopup('usagePopup40')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup40">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::log_entry</span></span>:<br/>IF Module - <a href="1-im.html#SP2">&#167;2</a>, <a href="1-im.html#SP2_3">&#167;2.3</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::log_entry</span><button class="popup" onclick="togglePopup('usagePopup40')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup40">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::log_entry</span></span>:<br/><a href="4-anl.html#SP24">&#167;24</a><br/>IF Module - <a href="1-im.html#SP2">&#167;2</a>, <a href="1-im.html#SP2_3">&#167;2.3</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">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="plain-syntax">        </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"&lt;null-entry&gt;"</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
@@ -673,7 +674,7 @@ something other than something &mdash; or <span class="extract"><span class="ext
 
 <pre class="displayed-code all-displayed-code code-font">
 <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">disable_anl_in</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</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('usagePopup41')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup41">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></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="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>
@@ -754,14 +755,28 @@ for instance, we don't want to count the "in" from "fixed in place".
 <span class="Preform-function-syntax">&lt;anl-operand&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">...</span><span class="Preform-plain-syntax">                                  </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { TRUE, ActionNameLists::entry_for_to_tail(W) };</span>
 
-<span class="Preform-function-syntax">&lt;text-of-in-clause&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
+<span class="Preform-function-syntax">&lt;text-of-in-clause&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">experimental_anl_system</span><span class="Preform-plain-syntax"> == </span><span class="Preform-identifier-syntax">FALSE</span><span class="Preform-plain-syntax">) {</span>
+<span class="Preform-plain-syntax">        </span><span class="Preform-reserved-syntax">int</span><span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> = </span><span class="Preform-function-syntax">&lt;text-of-in-clause-old&gt;</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">        ==&gt; { </span><span class="Preform-function-syntax">&lt;&lt;r&gt;&gt;</span><span class="Preform-plain-syntax">, </span><span class="Preform-function-syntax">&lt;&lt;rp&gt;&gt;</span><span class="Preform-plain-syntax"> };</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">rv</span><span class="Preform-plain-syntax">;</span>
+<span class="Preform-plain-syntax">    }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-reserved-syntax">int</span><span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> = </span><span class="Preform-function-syntax">&lt;text-of-clause&gt;</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">    ==&gt; { </span><span class="Preform-function-syntax">&lt;&lt;r&gt;&gt;</span><span class="Preform-plain-syntax">, </span><span class="Preform-function-syntax">&lt;&lt;rp&gt;&gt;</span><span class="Preform-plain-syntax"> };</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">rv</span><span class="Preform-plain-syntax">;</span>
+<span class="Preform-plain-syntax">}</span>
+
+<span class="Preform-function-syntax">&lt;text-of-clause&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">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-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"> { IN_THE_PRESENCE_OF_AP_CLAUSE, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">in</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"> { IN_AP_CLAUSE, - }</span>
+
+<span class="Preform-function-syntax">&lt;text-of-in-clause-old&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">fixed</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">place</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"> { advance Wordings::delta(WR[1], W) }</span>
 <span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">is/are/was/were/been/listed</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">***</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"> { advance Wordings::delta(WR[1], W) }</span>
-<span class="Preform-plain-syntax">    </span><span class="Preform-function-syntax">&lt;if-gen-permitted&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-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"> { TRUE, - }</span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">in</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, - }</span>
-<span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">in</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, - }</span>
 
 <span class="Preform-function-syntax">&lt;if-gen-permitted&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">0</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">disable_anl_in</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><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="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">    ==&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>
 </pre>
@@ -770,10 +785,38 @@ for instance, we don't want to count the "in" from "fixed in place".
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
-<span class="plain-syntax">    ==&gt; { </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><a href="4-anl.html#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1], </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-in-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">)) }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</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#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1], </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-in-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">)) }</span>
+<span class="plain-syntax">    } </span><span class="reserved-syntax">else</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#SP24" class="function-link"><span class="function-syntax">ActionNameLists::options</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1], </span><span class="identifier-syntax">R</span><span class="plain-syntax">[2], </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">), </span><span class="identifier-syntax">FALSE</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#SP23">&#167;23</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24.  </b>This matches a comma/or-separated list of items:
+<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24.  </b></p>
+
+<pre class="displayed-code all-displayed-code code-font">
+<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::options</span><button class="popup" onclick="togglePopup('usagePopup42')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup42">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::options</span></span>:<br/><a href="4-anl.html#SP23_1">&#167;23.1</a>, <a href="4-anl.html#SP26_2">&#167;26.2</a>, <a href="4-anl.html#SP27_1_3_2">&#167;27.1.3.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">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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">compulsory</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">original</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">compulsory</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
+<span class="plain-syntax">        </span><a href="4-anl.html#SP24" class="function-link"><span class="function-syntax">ActionNameLists::dup</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="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">next_entry</span><span class="plain-syntax">;</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">entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">C</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"So:  "</span><span class="plain-syntax">); </span><a href="4-anl.html#SP19" class="function-link"><span class="function-syntax">ActionNameLists::log_entry</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">original</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-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">original</span><span class="plain-syntax"> != </span><span class="identifier-syntax">entry</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"And: "</span><span class="plain-syntax">); </span><a href="4-anl.html#SP19" class="function-link"><span class="function-syntax">ActionNameLists::log_entry</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">); </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</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">original</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">}</span>
+
+<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::dup</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="plain-syntax">    </span><span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><span class="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_entry</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">new_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>
+<span class="plain-syntax">    </span><span class="identifier-syntax">new_entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parsing_data</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="plain-syntax">    </span><span class="identifier-syntax">new_entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">item</span><span class="plain-syntax"> = </span><span class="identifier-syntax">entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">item</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">next_entry</span><span class="plain-syntax"> = </span><span class="identifier-syntax">new_entry</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">new_entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next_entry</span><span class="plain-syntax"> = </span><span class="identifier-syntax">saved</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">}</span>
+</pre>
+<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25.  </b>This matches a comma/or-separated list of items:
 </p>
 
 <pre class="Preform-displayed-code all-displayed-code code-font">
@@ -786,17 +829,17 @@ for instance, we don't want to count the "in" from "fixed in place".
 <span class="Preform-plain-syntax">    </span><span class="Preform-constant-syntax">_,/or</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"> { pass 1 }</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="SP25" class="paragraph-anchor"></a><b>&#167;25.  </b>Items can be named action patterns, so let's get those out of the way first:
+<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26.  </b>Items can be named action patterns, so let's get those out of the way first:
 </p>
 
 <pre class="Preform-displayed-code all-displayed-code code-font">
 <span class="Preform-function-syntax">&lt;anl-entry&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;named-action-pattern&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#SP25_1" class="named-paragraph-link"><span class="named-paragraph">Make a NAP entry</span><span class="named-paragraph-number">25.1</span></a></span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-function-syntax">&lt;named-action-pattern&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#SP26_1" class="named-paragraph-link"><span class="named-paragraph">Make a NAP entry</span><span class="named-paragraph-number">26.1</span></a></span>
-<span class="Preform-plain-syntax">    </span><span class="Preform-function-syntax">&lt;named-action-pattern&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;text-of-in-clause&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#SP25_2" class="named-paragraph-link"><span class="named-paragraph">Make a NAP entry with an in clause</span><span class="named-paragraph-number">25.2</span></a></span>
+<span class="Preform-plain-syntax">    </span><span class="Preform-function-syntax">&lt;named-action-pattern&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;text-of-in-clause&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#SP26_2" class="named-paragraph-link"><span class="named-paragraph">Make a NAP entry with an in clause</span><span class="named-paragraph-number">26.2</span></a></span>
 <span class="Preform-plain-syntax">    </span><span class="Preform-function-syntax">&lt;anl-entry-with-action&gt;</span><span class="Preform-plain-syntax">                      </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { pass 1 }</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="SP25_1" class="paragraph-anchor"></a><b>&#167;25.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make a NAP entry</span><span class="named-paragraph-number">25.1</span></span><span class="Preform-comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP26_1" class="paragraph-anchor"></a><b>&#167;26.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make a NAP entry</span><span class="named-paragraph-number">26.1</span></span><span class="Preform-comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -804,18 +847,21 @@ for instance, we don't want to count the "in" from "fixed in place".
 <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><span class="element-syntax">nap_listed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1];</span>
 <span class="plain-syntax">    ==&gt; { </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">entry</span><span class="plain-syntax"> };</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP25">&#167;25</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP26">&#167;26</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP25_2" class="paragraph-anchor"></a><b>&#167;25.2.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make a NAP entry with an in clause</span><span class="named-paragraph-number">25.2</span></span><span class="comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP26_2" class="paragraph-anchor"></a><b>&#167;26.2.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make a NAP entry with an in clause</span><span class="named-paragraph-number">26.2</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">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">W</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><span class="element-syntax">nap_listed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1];</span>
-<span class="plain-syntax">    </span><a href="4-anl.html#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</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;text-of-in-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax">)</span>
+<span class="plain-syntax">        </span><a href="4-anl.html#SP24" class="function-link"><span class="function-syntax">ActionNameLists::options</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">R</span><span class="plain-syntax">[2], </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">), </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">else</span>
+<span class="plain-syntax">        </span><a href="4-anl.html#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</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;text-of-in-clause&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="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">entry</span><span class="plain-syntax"> };</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP25">&#167;25</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP26">&#167;26</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26.  </b>Which reduces us to an internal nonterminal for an entry in this list.
+<p class="commentary firstcommentary"><a id="SP27" class="paragraph-anchor"></a><b>&#167;27.  </b>Which reduces us to an internal nonterminal for an entry in this list.
 It actually produces multiple matches: for example,
 </p>
 
@@ -832,7 +878,7 @@ end, but it's syntactically valid.)
 <pre class="Preform-displayed-code all-displayed-code code-font">
 <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#SP26_1" class="named-paragraph-link"><span class="named-paragraph">Parse the wording into a list of results</span><span class="named-paragraph-number">26.1</span></a></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#SP27_1" class="named-paragraph-link"><span class="named-paragraph">Parse the wording into a list of results</span><span class="named-paragraph-number">27.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>
@@ -840,7 +886,7 @@ end, but it's syntactically valid.)
 <span class="Preform-plain-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="SP26_1" class="paragraph-anchor"></a><b>&#167;26.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Parse the wording into a list of results</span><span class="named-paragraph-number">26.1</span></span><span class="Preform-comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP27_1" class="paragraph-anchor"></a><b>&#167;27.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Parse the wording into a list of results</span><span class="named-paragraph-number">27.1</span></span><span class="Preform-comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -849,16 +895,16 @@ end, but it's syntactically valid.)
 
 <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="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#SP26_1_1" class="named-paragraph-link"><span class="named-paragraph">Ready the trial entry for another test</span><span class="named-paragraph-number">26.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#SP27_1_1" class="named-paragraph-link"><span class="named-paragraph">Ready the trial entry for another test</span><span class="named-paragraph-number">27.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="named-paragraph-container code-font"><a href="4-anl.html#SP26_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">26.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#SP27_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">27.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#SP26_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">26.1.3</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#SP27_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">27.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>
 <span class="plain-syntax">    }</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">"Parsing ANL from %W resulted in:\n$8\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="identifier-syntax">results</span><span class="plain-syntax">);</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP26">&#167;26</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP27">&#167;27</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP26_1_1" class="paragraph-anchor"></a><b>&#167;26.1.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Ready the trial entry for another test</span><span class="named-paragraph-number">26.1.1</span></span><span class="comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP27_1_1" class="paragraph-anchor"></a><b>&#167;27.1.1.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Ready the trial entry for another test</span><span class="named-paragraph-number">27.1.1</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -866,14 +912,14 @@ end, but it's syntactically valid.)
 <span class="plain-syntax">    </span><a href="4-anl.html#SP11" class="function-link"><span class="function-syntax">ActionNameLists::clear_item_data</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">an</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::clear_parsing_data</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP26_1">&#167;26.1</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP27_1">&#167;27.1</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP26_1_2" class="paragraph-anchor"></a><b>&#167;26.1.2.  </b>Here <span class="extract"><span class="extract-syntax">XW</span></span> will be the wording of the action name, say "removing it from";
+<p class="commentary firstcommentary"><a id="SP27_1_2" class="paragraph-anchor"></a><b>&#167;27.1.2.  </b>Here <span class="extract"><span class="extract-syntax">XW</span></span> will be the wording of the action name, say "removing it from";
 we try to fit <span class="extract"><span class="extract-syntax">W</span></span> to this, say "removing a heavy thing from something in the
 Dining Room"; and if we cannot, we run away to the label <span class="extract"><span class="extract-syntax">NoMatch</span></span>, which is
 inelegant, but there's no elegant way to break out of nested loops in C.
 </p>
 
-<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the trial entry fit this action, if possible, leaving remaining text in RW</span><span class="named-paragraph-number">26.1.2</span></span><span class="comment-syntax"> =</span>
+<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make the trial entry fit this action, if possible, leaving remaining text in RW</span><span class="named-paragraph-number">27.1.2</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -907,30 +953,34 @@ inelegant, but there's no elegant way to break out of nested loops in C.
 <span class="plain-syntax">        </span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">parsing_data</span><span class="plain-syntax">.</span><span class="element-syntax">abbreviation_level</span><span class="plain-syntax"> = </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_m</span><span class="plain-syntax">+1;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">RW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::from</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="identifier-syntax">w_m</span><span class="plain-syntax">);</span>
 </pre>
-<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP26_1">&#167;26.1</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP27_1">&#167;27.1</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP26_1_3" class="paragraph-anchor"></a><b>&#167;26.1.3.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Consider the trial entry for inclusion in the results list</span><span class="named-paragraph-number">26.1.3</span></span><span class="comment-syntax"> =</span>
+<p class="commentary firstcommentary"><a id="SP27_1_3" class="paragraph-anchor"></a><b>&#167;27.1.3.  </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Consider the trial entry for inclusion in the results list</span><span class="named-paragraph-number">27.1.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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">C</span><span class="plain-syntax"> = -1; </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">CW</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::empty</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#SP26_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">26.1.3.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#SP27_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">27.1.3.2</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;text-of-in-clause&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">RW</span><span class="plain-syntax">)) {</span>
-<span class="plain-syntax">        </span><a href="4-anl.html#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-in-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
+<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">experimental_anl_system</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP26_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">26.1.3.2</span></a></span><span class="plain-syntax">;</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">C</span><span class="plain-syntax"> = </span><span class="function-syntax">&lt;&lt;r&gt;&gt;</span><span class="plain-syntax">; </span><span class="identifier-syntax">CW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">);</span>
+<span class="plain-syntax">        } </span><span class="reserved-syntax">else</span>
+<span class="plain-syntax">            </span><a href="4-anl.html#SP15" class="function-link"><span class="function-syntax">ActionNameLists::add_in_clause</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax">&lt;text-of-in-clause&gt;</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
+<span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="4-anl.html#SP27_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">27.1.3.2</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><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="plain-syntax">        (</span><a href="4-anl.html#SP26_1_3_1" 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><a href="4-anl.html#SP27_1_3_1" 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#SP26_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">26.1.3.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#SP27_1_3_2" class="named-paragraph-link"><span class="named-paragraph">Include the trial entry</span><span class="named-paragraph-number">27.1.3.2</span></a></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#SP26_1">&#167;26.1</a>.</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP27_1">&#167;27.1</a>.</li></ul>
-<p class="commentary firstcommentary"><a id="SP26_1_3_1" class="paragraph-anchor"></a><b>&#167;26.1.3.1.  </b>As an aside, the following code runs a specially adapted form of &lt;anl-to-tail&gt;:
+<p class="commentary firstcommentary"><a id="SP27_1_3_1" class="paragraph-anchor"></a><b>&#167;27.1.3.1.  </b>As an aside, the following code runs a specially adapted form of &lt;anl-to-tail&gt;:
 not one which parses any differently, just one which uses the trial entry and not
 newly-created ones (which would be expensive on memory).
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="identifier-syntax">to_tail_entry_being_parsed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
-<span class="reserved-syntax">anl_entry</span><span class="plain-syntax"> *</span><span class="function-syntax">ActionNameLists::entry_for_to_tail</span><button class="popup" onclick="togglePopup('usagePopup42')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup42">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::entry_for_to_tail</span></span>:<br/><a href="4-anl.html#SP23">&#167;23</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::entry_for_to_tail</span><button class="popup" onclick="togglePopup('usagePopup43')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup43">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::entry_for_to_tail</span></span>:<br/><a href="4-anl.html#SP23">&#167;23</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="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((!</span><span class="identifier-syntax">preform_lookahead_mode</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">to_tail_entry_being_parsed</span><span class="plain-syntax">))</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">entry</span><span class="plain-syntax"> = </span><span class="identifier-syntax">to_tail_entry_being_parsed</span><span class="plain-syntax">;</span>
@@ -939,7 +989,7 @@ newly-created ones (which would be expensive on memory).
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</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="function-syntax">ActionNameLists::parse_to_tail</span><button class="popup" onclick="togglePopup('usagePopup43')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup43">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::parse_to_tail</span></span>:<br/><a href="4-anl.html#SP26_1_3">&#167;26.1.3</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">int</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameLists::parse_to_tail</span><button class="popup" onclick="togglePopup('usagePopup44')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup44">Usage of <span class="code-font"><span class="function-syntax">ActionNameLists::parse_to_tail</span></span>:<br/><a href="4-anl.html#SP27_1_3">&#167;27.1.3</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">result</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">to_tail_entry_being_parsed</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">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;anl-to-tail&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">)) </span><span class="identifier-syntax">result</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
@@ -947,12 +997,12 @@ newly-created ones (which would be expensive on memory).
 <span class="plain-syntax">    </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">result</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 </pre>
-<p class="commentary firstcommentary"><a id="SP26_1_3_2" class="paragraph-anchor"></a><b>&#167;26.1.3.2.  </b>So this is the happy ending. We don't copy the trial entry; we insertion-sort
+<p class="commentary firstcommentary"><a id="SP27_1_3_2" class="paragraph-anchor"></a><b>&#167;27.1.3.2.  </b>So this is the happy ending. We don't copy the trial entry; we insertion-sort
 the structure itself into the results list, and make a fresh structure to be
 the trial entry for future trials.
 </p>
 
-<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Include the trial entry</span><span class="named-paragraph-number">26.1.3.2</span></span><span class="comment-syntax"> =</span>
+<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Include the trial entry</span><span class="named-paragraph-number">27.1.3.2</span></span><span class="comment-syntax"> =</span>
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -965,9 +1015,11 @@ the trial entry for future trials.
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prev</span><span class="plain-syntax">) </span><a href="4-anl.html#SP7" class="function-link"><span class="function-syntax">ActionNameLists::join_to</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prev</span><span class="plain-syntax">, </span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">); </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">results</span><span class="plain-syntax"> = </span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><a href="4-anl.html#SP7" class="function-link"><span class="function-syntax">ActionNameLists::join_to</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">pos</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    }</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">C</span><span class="plain-syntax"> != -1)</span>
+<span class="plain-syntax">        </span><a href="4-anl.html#SP24" class="function-link"><span class="function-syntax">ActionNameLists::options</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">trial_entry</span><span class="plain-syntax">, </span><span class="identifier-syntax">C</span><span class="plain-syntax">, </span><span class="identifier-syntax">CW</span><span class="plain-syntax">, </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">);</span>
 <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#SP26_1_3">&#167;26.1.3</a> (three times).</li></ul>
+<ul class="endnotetexts"><li>This code is used in <a href="4-anl.html#SP27_1_3">&#167;27.1.3</a> (three times).</li></ul>
 <nav role="progress"><div class="progresscontainer">
     <ul class="progressbar"><li class="progressprev"><a href="4-ap2.html">&#10094;</a></li><li class="progresschapter"><a href="P-wtmd.html">P</a></li><li class="progresschapter"><a href="1-im.html">1</a></li><li class="progresschapter"><a href="2-bd.html">2</a></li><li class="progresschapter"><a href="3-sm.html">3</a></li><li class="progresscurrentchapter">4</li><li class="progresssection"><a href="4-ap.html">ap</a></li><li class="progresssection"><a href="4-anaa.html">anaa</a></li><li class="progresssection"><a href="4-ak.html">ak</a></li><li class="progresssection"><a href="4-ac.html">ac</a></li><li class="progresssection"><a href="4-act.html">act</a></li><li class="progresssection"><a href="4-as.html">as</a></li><li class="progresssection"><a href="4-av.html">av</a></li><li class="progresssection"><a href="4-ann.html">ann</a></li><li class="progresssection"><a href="4-ap2.html">ap2</a></li><li class="progresscurrent">anl</li><li class="progresssection"><a href="4-apc.html">apc</a></li><li class="progresssection"><a href="4-gng.html">gng</a></li><li class="progresssection"><a href="4-pap.html">pap</a></li><li class="progresssection"><a href="4-pc.html">pc</a></li><li class="progresssection"><a href="4-ea.html">ea</a></li><li class="progresssection"><a href="4-nap.html">nap</a></li><li class="progresschapter"><a href="5-pp.html">5</a></li><li class="progressnext"><a href="4-apc.html">&#10095;</a></li></ul></div>
 </nav><!--End of weave-->

docs/if-module/4-ann.html

@@ -148,7 +148,7 @@ enough that this is almost never used.
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
-<span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameNames::tensed</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">ActionNameNames::tensed</span></span>:<br/><a href="4-ann.html#SP10">&#167;10</a>, <a href="4-ann.html#SP11">&#167;11</a>, <a href="4-ann.html#SP13">&#167;13</a><br/>Actions Plugin - <a href="4-ap.html#SP4">&#167;4</a><br/>Actions-Only Nodes and Annotations - <a href="4-anaa.html#SP3">&#167;3</a><br/>Actions - <a href="4-act.html#SP3">&#167;3</a><br/>Action Semantics - <a href="4-as.html#SP6_1">&#167;6.1</a><br/>Action Name Lists - <a href="4-anl.html#SP19">&#167;19</a>, <a href="4-anl.html#SP26_1_2">&#167;26.1.2</a><br/>Going - <a href="4-gng.html#SP2">&#167;2</a><br/>Grammar Lines - <a href="5-gl.html#SP21">&#167;21</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="identifier-syntax">tense</span><span class="plain-syntax">) {</span>
+<span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameNames::tensed</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">ActionNameNames::tensed</span></span>:<br/><a href="4-ann.html#SP10">&#167;10</a>, <a href="4-ann.html#SP11">&#167;11</a>, <a href="4-ann.html#SP13">&#167;13</a><br/>Actions Plugin - <a href="4-ap.html#SP4">&#167;4</a><br/>Actions-Only Nodes and Annotations - <a href="4-anaa.html#SP3">&#167;3</a><br/>Actions - <a href="4-act.html#SP3">&#167;3</a><br/>Action Semantics - <a href="4-as.html#SP6_1">&#167;6.1</a><br/>Action Name Lists - <a href="4-anl.html#SP19">&#167;19</a>, <a href="4-anl.html#SP27_1_2">&#167;27.1.2</a><br/>Going - <a href="4-gng.html#SP2">&#167;2</a><br/>Grammar Lines - <a href="5-gl.html#SP21">&#167;21</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="identifier-syntax">tense</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">tense</span><span class="plain-syntax"> == </span><span class="identifier-syntax">IS_TENSE</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">naming_data</span><span class="plain-syntax">.</span><span class="element-syntax">present_name</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">tense</span><span class="plain-syntax"> == </span><span class="identifier-syntax">HASBEEN_TENSE</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">naming_data</span><span class="plain-syntax">.</span><span class="element-syntax">past_name</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"action tense unsupported"</span><span class="plain-syntax">);</span>
@@ -211,7 +211,7 @@ preposition can be abbreviated is under the author's control:
 </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">ActionNameNames::it_optional</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">ActionNameNames::it_optional</span></span>:<br/>Action Name Lists - <a href="4-anl.html#SP26_1_2">&#167;26.1.2</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">ActionNameNames::it_optional</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">ActionNameNames::it_optional</span></span>:<br/>Action Name Lists - <a href="4-anl.html#SP27_1_2">&#167;27.1.2</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">naming_data</span><span class="plain-syntax">.</span><span class="element-syntax">it_optional</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 
@@ -219,7 +219,7 @@ preposition can be abbreviated is under the author's control:
 <span class="plain-syntax">    </span><span class="identifier-syntax">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">naming_data</span><span class="plain-syntax">.</span><span class="element-syntax">abbreviable</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">int</span><span class="plain-syntax"> </span><span class="function-syntax">ActionNameNames::abbreviable</span><button class="popup" onclick="togglePopup('usagePopup9')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup9">Usage of <span class="code-font"><span class="function-syntax">ActionNameNames::abbreviable</span></span>:<br/>Action Name Lists - <a href="4-anl.html#SP26_1_2">&#167;26.1.2</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">ActionNameNames::abbreviable</span><button class="popup" onclick="togglePopup('usagePopup9')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup9">Usage of <span class="code-font"><span class="function-syntax">ActionNameNames::abbreviable</span></span>:<br/>Action Name Lists - <a href="4-anl.html#SP27_1_2">&#167;27.1.2</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">an</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">naming_data</span><span class="plain-syntax">.</span><span class="element-syntax">abbreviable</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 </pre>

docs/if-module/4-as.html

@@ -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#SP22_2">&#167;22.2</a>, <a href="4-anl.html#SP26_1_3">&#167;26.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><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#SP22_2">&#167;22.2</a>, <a href="4-anl.html#SP27_1_3">&#167;27.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><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>

docs/if-module/4-pc.html

@@ -546,9 +546,9 @@ We treat words like "something" specially to avoid them being read as
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">action_pattern</span><span class="plain-syntax"> *</span><span class="function-syntax">ParseClauses::experiment</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="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Experiment on: %W\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
-<span class="plain-syntax">    </span><span class="identifier-syntax">disable_anl_in</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</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">action_name_list</span><span class="plain-syntax"> *</span><span class="identifier-syntax">anl</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP21" class="function-link"><span class="function-syntax">ActionNameLists::parse</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="identifier-syntax">IS_TENSE</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">disable_anl_in</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</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">FALSE</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"$L\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">anl</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">action_name</span><span class="plain-syntax"> *</span><span class="identifier-syntax">chief_an</span><span class="plain-syntax"> = </span><a href="4-anl.html#SP18" class="function-link"><span class="function-syntax">ActionNameLists::get_best_action</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">anl</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">chief_an</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">chief_an</span><span class="plain-syntax"> = </span><a href="4-ann.html#SP13" class="function-link"><span class="function-syntax">ActionNameNames::longest_nounless</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="identifier-syntax">IS_TENSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>

inform7/Figures/memory-diagnostics.txt

@@ -1,10 +1,10 @@
-Total memory consumption was 258575K = 253 MB
+Total memory consumption was 257772K = 252 MB
 
-62.4% was used for 1342387 objects, in 279016 frames in 202 x 800K = 161600K = 157 MB:
+62.3% was used for 1342267 objects, in 278995 frames in 201 x 800K = 160800K = 157 MB:
 
      9.8%  inter_tree_node_array                    36 x 8192 = 294912 objects, 25953408 bytes
-     5.5%  text_stream_array                        2595 x 100 = 259500 objects, 14615040 bytes
+     5.5%  text_stream_array                        2594 x 100 = 259400 objects, 14609408 bytes
-     3.9%  parse_node                               130338 objects, 10427040 bytes
+     3.9%  parse_node                               130322 objects, 10425760 bytes
      2.8%  verb_conjugation                         160 objects, 7425280 bytes
      2.6%  parse_node_annotation_array              433 x 500 = 216500 objects, 6941856 bytes
      2.4%  linked_list                              11782 objects, 6597920 bytes
@@ -12,7 +12,7 @@ Total memory consumption was 258575K = 253 MB
      1.2%  pcalc_prop_array                         24 x 1000 = 24000 objects, 3264768 bytes
      1.2%  map_data                                 670 objects, 3178480 bytes
      0.9%  kind_array                               65 x 1000 = 65000 objects, 2602080 bytes
-     0.7%  inter_schema_token                       13492 objects, 1942848 bytes
+     0.7%  inter_schema_token                       13487 objects, 1942128 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
      0.3%  phrase                                   940 objects, 1015200 bytes
@@ -20,12 +20,12 @@ Total memory consumption was 258575K = 253 MB
      0.3%  adjective_meaning                        202 objects, 1000304 bytes
      0.3%  excerpt_meaning                          3098 objects, 966576 bytes
      0.3%  inter_package                            13227 objects, 952344 bytes
-     0.3%  production                               3891 objects, 902712 bytes
+     0.3%  production                               3892 objects, 902944 bytes
-     0.3%  ptoken                                   8408 objects, 874432 bytes
+     0.3%  ptoken                                   8409 objects, 874536 bytes
      0.3%  grammatical_usage                        3610 objects, 866400 bytes
      0.3%  individual_form                          2560 objects, 860160 bytes
      0.3%  inter_symbols_table                      13227 objects, 846528 bytes
-     0.3%  inter_schema_node                        8692 objects, 834432 bytes
+     0.3%  inter_schema_node                        8689 objects, 834144 bytes
      0.2%  dictionary                               16372 objects, 785856 bytes
      0.2%  dict_entry_array                         232 x 100 = 23200 objects, 749824 bytes
      0.2%  package_request                          7954 objects, 699952 bytes
@@ -45,7 +45,7 @@ Total memory consumption was 258575K = 253 MB
      ----  stacked_variable_owner_list_array        38 x 100 = 3800 objects, 153216 bytes
      ----  anl_entry_array                          3 x 1000 = 3000 objects, 144096 bytes
      ----  index_lexicon_entry                      395 objects, 142200 bytes
-     ----  nonterminal                              761 objects, 140024 bytes
+     ----  nonterminal                              763 objects, 140392 bytes
      ----  documentation_ref                        1275 objects, 112200 bytes
      ----  inference                                1703 objects, 108992 bytes
      ----  hierarchy_location                       730 objects, 105120 bytes
@@ -56,7 +56,7 @@ Total memory consumption was 258575K = 253 MB
      ----  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
+     ----  inter_schema                             1508 objects, 72384 bytes
      ----  rulebook                                 407 objects, 71632 bytes
      ----  spatial_data                             670 objects, 64320 bytes
      ----  kind_macro_definition                    9 objects, 62280 bytes
@@ -72,7 +72,7 @@ Total memory consumption was 258575K = 253 MB
      ----  inter_node_list                          750 objects, 42000 bytes
      ----  activity_list_array                      1 x 1000 objects, 40032 bytes
      ----  response_message                         407 objects, 35816 bytes
-     ----  production_list                          620 objects, 34720 bytes
+     ----  production_list                          621 objects, 34776 bytes
      ----  regions_data                             670 objects, 32160 bytes
      ----  HTML_tag_array                           1 x 1000 objects, 32032 bytes
      ----  property_permission                      96 objects, 30720 bytes
@@ -229,16 +229,16 @@ Total memory consumption was 258575K = 253 MB
      ----  loop_over_scope                          1 object, 40 bytes
      ----  parse_name_notice                        1 object, 40 bytes
 
-37.5% was used for memory not allocated for objects:
+37.6% was used for memory not allocated for objects:
 
-    15.9%  text stream storage                      42247328 bytes in 265813 claims
+    16.0%  text stream storage                      42246324 bytes in 265801 claims
      3.5%  dictionary storage                       9278976 bytes in 16372 claims
      ----  sorting                                  1056 bytes in 3 claims
      2.7%  source text                              7200000 bytes in 3 claims
      4.0%  source text details                      10800000 bytes in 2 claims
      ----  linguistic stock array                   81920 bytes in 2 claims
      ----  small word set array                     105600 bytes in 22 claims
-     0.8%  inter symbols storage                    2280320 bytes in 13937 claims
+     0.8%  inter symbols storage                    2278336 bytes in 13936 claims
      6.3%  inter bytecode storage                   16802820 bytes in 14 claims
      3.3%  inter links storage                      8750208 bytes in 246 claims
      0.6%  instance-of-kind counting                1695204 bytes in 1 claim
@@ -247,5 +247,5 @@ Total memory consumption was 258575K = 253 MB
      ----  emitter array storage                    12320 bytes in 8 claims
      ----  code generation workspace for objects    9200 bytes in 9 claims
 
-20.0% was overhead - 52990136 bytes = 51748K = 50 MB
+19.7% was overhead - 52178144 bytes = 50955K = 49 MB
 

inform7/Figures/preform-summary.txt

@@ -1,25 +1,25 @@
-<s-literal> hits 2097/23958 nti 12 constraint (none) extremes [1, infinity)
+<s-literal> hits 2097/23954 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/1890) constraint DS = {12} extremes [2, 2]
+          (hits 0/1893) constraint DS = {12} extremes [2, 2]
         (@1)<quoted-text>=1 (@2)( (@3)<response-letter>=2 (@4)) 
-          (hits 273/840) (matched: '"[current item from the multiple object list]: [run paragraph on]" ( a )') constraint DS = {12} extremes [4, 4]
+          (hits 273/842) (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
         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/9969) (matched: 'plus infinity') constraint (none) extremes [1, infinity)
         (@1)<s-literal-truth-state>=1 
-          (hits 78/264) (matched: 'false') constraint CS = {6} extremes [1, 1]
+          (hits 78/273) (matched: 'false') constraint CS = {6} extremes [1, 1]
         <s-literal-list>=1 
           (hits 0/1484) constraint DS = {8} extremes [2, infinity)
         (@1)unicode <s-unicode-character>=1 
-          (hits 0/4269) constraint DS = {12} extremes [2, infinity)
+          (hits 0/4296) constraint DS = {12} extremes [2, infinity)
         <s-literal-time>=1 
-          (hits 0/3529) constraint DW = {9, 10, 11} extremes [2, 5]
+          (hits 0/3504) constraint DW = {9, 10, 11} extremes [2, 5]
         <s-literal-unit-notation>=1 
-          (hits 0/9882) constraint (none) extremes [1, infinity)
+          (hits 0/9880) constraint (none) extremes [1, infinity)

inform7/Figures/timings-diagnostics.txt

@@ -1,14 +1,14 @@
 100.0% in inform7 run
-     67.1% in compilation to Inter
+     66.7% in compilation to Inter
-         25.7% in //Phrases::Manager::compile_first_block//
+         25.6% in //Phrases::Manager::compile_first_block//
           8.5% in //Phrases::Manager::compile_as_needed//
-          7.2% in //Strings::compile_responses//
+          7.0% in //Strings::compile_responses//
-          5.9% in //InferenceSubjects::emit_all//
+          6.0% in //InferenceSubjects::emit_all//
-          4.1% in //MajorNodes::pre_pass//
+          4.2% in //MajorNodes::pre_pass//
-          3.4% in //MajorNodes::pass_1//
+          3.3% in //MajorNodes::pass_1//
-          1.9% in //Phrases::Manager::RulePrintingRule_routine//
+          2.0% in //Phrases::Manager::RulePrintingRule_routine//
-          1.9% in //Phrases::Manager::rulebooks_array//
+          1.8% in //Phrases::Manager::rulebooks_array//
-          1.0% in //RTVerbs::ConjugateVerb//
+          1.1% in //RTVerbs::ConjugateVerb//
           0.7% in //Phrases::Manager::traverse//
           0.5% in //Phrases::Manager::parse_rule_parameters//
           0.5% in //World::stage_V//
@@ -19,19 +19,18 @@
           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//
-          3.3% not specifically accounted for
+          3.2% not specifically accounted for
-     30.4% in running Inter pipeline
+     30.6% in running Inter pipeline
-          9.8% in inter step 2/12: link
+          9.9% in inter step 2/12: link
-          9.8% in step preparation
+          9.9% in step preparation
-          7.0% in inter step 12/12: generate inform6 -> auto.inf
+          7.2% 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
-          0.1% in inter step 4/12: parse-linked-matter
           0.1% in inter step 5/12: resolve-conditional-compilation
           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.1% not specifically accounted for
+          2.0% not specifically accounted for
-      1.9% in supervisor
+      2.0% in supervisor
-      0.4% not specifically accounted for
+      0.6% not specifically accounted for

inform7/Tests/Test Cases/_Results_Ideal/ActionPatternParsing.txt

@@ -85,16 +85,16 @@
   (3). +0 ANL entry : looking
   
   Chief action: looking
-  experimental looking or taking inventory in the laboratory in the presence of hans: <null-ap>
+  experimental looking or taking inventory in the laboratory in the presence of hans: <action-based: taking inventory / looking>
   
   26. experimental looking or taking inventory in the presence of Hans in the Laboratory
   Experiment on: looking or taking inventory in the presence of hans in the laboratory
-  (1). +2 ANL entry : taking [noun: inventory] [in: hans in the laboratory]
+  (1). +2 ANL entry : taking [noun: inventory] [in-presence: hans in the laboratory]
-  (2). +2 ANL entry : taking inventory [in: hans in the laboratory]
+  (2). +2 ANL entry : taking inventory [in-presence: hans in the laboratory]
   (3). +0 ANL entry : looking
   
   Chief action: looking
-  experimental looking or taking inventory in the presence of hans in the laboratory: <null-ap>
+  experimental looking or taking inventory in the presence of hans in the laboratory: <action-based: taking inventory / looking>
   
 > >   Radiation Laboratory
 > Are you sure you want to quit? 

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

@@ -349,12 +349,12 @@ wording ActionNameLists::get_clause_wording(anl_entry *entry, int C) {
 	return EMPTY_WORDING;
 }
 
-void ActionNameLists::set_clause_wording(anl_entry *entry, int C, wording W) {
+anl_entry *ActionNameLists::set_clause_wording(anl_entry *entry, int C, wording W) {
 	if (entry == NULL) internal_error("no entry");
 	anl_clause_text *prev = NULL;
 	for (anl_clause_text *c = (entry)?(entry->parsing_data.anl_clauses):NULL; c; c = c->next_clause) {
 		if (c->clause_ID == C) {
-			c->clause_text = W; return;
+			c->clause_text = W; return entry;
 		}
 		if (c->clause_ID > C) @<Insert clause here@>;
 		prev = c;
@@ -368,6 +368,7 @@ void ActionNameLists::set_clause_wording(anl_entry *entry, int C, wording W) {
 	nc->clause_text = W;
 	if (prev) { nc->next_clause = prev->next_clause; prev->next_clause = nc; }
 	else { nc->next_clause = NULL; entry->parsing_data.anl_clauses = nc; }
+	return entry;
 
 @ =
 wording ActionNameLists::par(anl_entry *entry, int i) {
@@ -556,7 +557,7 @@ The test group |:anl| is helpful in catching errors here.
 
 @ =
 int anl_parsing_tense = IS_TENSE;
-int disable_anl_in = FALSE;
+int experimental_anl_system = FALSE;
 action_name_list *ActionNameLists::parse(wording W, int tense, int *sense) {
 	if (Wordings::mismatched_brackets(W)) return NULL;
 	int t = anl_parsing_tense;
@@ -622,19 +623,61 @@ for instance, we don't want to count the "in" from "fixed in place".
 <anl-operand> ::=
 	...                                  ==> { TRUE, ActionNameLists::entry_for_to_tail(W) };
 
-<text-of-in-clause> ::=
+<text-of-in-clause> internal {
+	if (experimental_anl_system == FALSE) {
+		int rv = <text-of-in-clause-old>(W);
+		==> { <<r>>, <<rp>> };
+		return rv;
+	}
+	int rv = <text-of-clause>(W);
+	==> { <<r>>, <<rp>> };
+	return rv;
+}
+
+<text-of-clause> ::=
+	in the presence of ... | ==> { IN_THE_PRESENCE_OF_AP_CLAUSE, - }
+	in ...                   ==> { IN_AP_CLAUSE, - }
+
+<text-of-in-clause-old> ::=
 	fixed in place *** |                 ==> { advance Wordings::delta(WR[1], W) }
 	is/are/was/were/been/listed in *** | ==> { advance Wordings::delta(WR[1], W) }
-	<if-gen-permitted> in the presence of ... | ==> { TRUE, - }
+	in ...                               ==> { TRUE, - }
-	in ...                             ==> { TRUE, - }
 	
 <if-gen-permitted> internal 0 {
-	if (disable_anl_in) return TRUE;
+	if (experimental_anl_system) return TRUE;
 	==> { fail nonterminal };
 }
 
 @<Augment ANL with in clause@> =
-	==> { TRUE, ActionNameLists::add_in_clause(RP[1], GET_RW(<text-of-in-clause>, 1)) }
+	if (experimental_anl_system == FALSE) {
+		==> { TRUE, ActionNameLists::add_in_clause(RP[1], GET_RW(<text-of-in-clause>, 1)) }
+	} else {
+		==> { TRUE, ActionNameLists::options(RP[1], R[2], GET_RW(<text-of-clause>, 1), FALSE) }	
+	}
+
+@
+
+=
+anl_entry *ActionNameLists::options(anl_entry *entry, int C, wording W, int compulsory) {
+	anl_entry *original = entry;
+	if (compulsory == FALSE) {
+		ActionNameLists::dup(entry);
+		entry = entry->next_entry;
+	}
+	ActionNameLists::set_clause_wording(entry, C, W);
+	LOG("So:  "); ActionNameLists::log_entry(original); LOG("\n");
+	if (original != entry) { LOG("And: "); ActionNameLists::log_entry(entry); LOG("\n"); }
+	return original;
+}
+
+void ActionNameLists::dup(anl_entry *entry) {
+	anl_entry *saved = entry->next_entry;
+	anl_entry *new_entry = ActionNameLists::new_entry_at(EMPTY_WORDING);
+	new_entry->parsing_data = entry->parsing_data;
+	new_entry->item = entry->item;
+	entry->next_entry = new_entry;
+	new_entry->next_entry = saved;
+}
 
 @ This matches a comma/or-separated list of items:
 
@@ -651,7 +694,7 @@ for instance, we don't want to count the "in" from "fixed in place".
 
 =
 <anl-entry> ::=
-	<named-action-pattern>	|                    ==> @<Make a NAP entry@>
+	<named-action-pattern> |                     ==> @<Make a NAP entry@>
 	<named-action-pattern> <text-of-in-clause> | ==> @<Make a NAP entry with an in clause@>
 	<anl-entry-with-action>					     ==> { pass 1 }
 
@@ -663,7 +706,10 @@ for instance, we don't want to count the "in" from "fixed in place".
 @<Make a NAP entry with an in clause@> =
 	anl_entry *entry = ActionNameLists::new_entry_at(W);
 	entry->item.nap_listed = RP[1];
-	ActionNameLists::add_in_clause(entry, GET_RW(<text-of-in-clause>, 1));
+	if (experimental_anl_system)
+		ActionNameLists::options(entry, R[2], GET_RW(<text-of-clause>, 1), TRUE);
+	else
+		ActionNameLists::add_in_clause(entry, GET_RW(<text-of-in-clause>, 1));
 	==> { 0, entry };
 
 @ Which reduces us to an internal nonterminal for an entry in this list.
@@ -742,10 +788,14 @@ inelegant, but there's no elegant way to break out of nested loops in C.
 	RW = Wordings::from(W, w_m);
 
 @<Consider the trial entry for inclusion in the results list@> =
+	int C = -1; wording CW = EMPTY_WORDING;
 	if (Wordings::empty(RW)) {
 		@<Include the trial entry@>;
 	} else if (<text-of-in-clause>(RW)) {
-		ActionNameLists::add_in_clause(trial_entry, GET_RW(<text-of-in-clause>, 1));
+		if (experimental_anl_system) {
+			C = <<r>>; CW = GET_RW(<text-of-clause>, 1);
+		} else
+			ActionNameLists::add_in_clause(trial_entry, GET_RW(<text-of-in-clause>, 1));
 		@<Include the trial entry@>;
 	} else if ((ActionSemantics::can_have_noun(an)) &&
 		(ActionNameLists::parse_to_tail(trial_entry, RW))) {
@@ -789,4 +839,6 @@ the trial entry for future trials.
 		if (prev) ActionNameLists::join_to(prev, trial_entry); else results = trial_entry;
 		ActionNameLists::join_to(trial_entry, pos);
 	}
+	if (C != -1)
+		ActionNameLists::options(trial_entry, C, CW, TRUE);
 	trial_entry = ActionNameLists::new_entry_at(EMPTY_WORDING);

inform7/if-module/Chapter 4/Parse Clauses.w

@@ -409,9 +409,9 @@ We treat words like "something" specially to avoid them being read as
 =
 action_pattern *ParseClauses::experiment(wording W) {
 	LOG("Experiment on: %W\n", W);
-	disable_anl_in = TRUE;
+	experimental_anl_system = TRUE;
 	action_name_list *anl = ActionNameLists::parse(W, IS_TENSE, NULL);
-	disable_anl_in = TRUE;
+	experimental_anl_system = FALSE;
 	LOG("$L\n", anl);
 	action_name *chief_an = ActionNameLists::get_best_action(anl);
 	if (chief_an == NULL) chief_an = ActionNameNames::longest_nounless(W, IS_TENSE, NULL);

services/lexicon-module/Figures/excerpts-diagnostics.txt

@@ -1,15 +1,15 @@
 Size of lexicon: 3098 excerpt meanings
-  Stored among 840 words out of total vocabulary of 10563
+  Stored among 840 words out of total vocabulary of 10565
   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: 105695
+Number of attempts to retrieve: 105687
-  of which unsuccessful: 88054
+  of which unsuccessful: 88050
-  of which successful: 17641
+  of which successful: 17637
 
-Total attempts to match against excerpt meanings: 253547
+Total attempts to match against excerpt meanings: 253531
-  of which, total with incorrect hash codes: 231407
+  of which, total with incorrect hash codes: 231395
-  of which, total with correct hash codes: 22140
+  of which, total with correct hash codes: 22136
-  of which, total which matched: 19407
+  of which, total which matched: 19403