mirror of
https://github.com/ganelson/inform.git
synced 2024-06-29 05:24:57 +03:00
Further work on calculus notation
This commit is contained in:
Graham Nelson
parent
623d5e340c
commit
8d943adfb8
|
|
@ -27,7 +27,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="index.html"><span class="selectedlink">arch-test</span></a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -35,7 +35,9 @@ function togglePopup(material_id) {
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="index.html"><span class="selectedlink">arch-test</span></a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -25,7 +25,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><span class="unlink">arch-test</span></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -93,7 +93,18 @@ which use this module:
|
|||
<span class="definition-keyword">enum</span> <span class="constant-syntax">PREDICATE_CALCULUS_WORKINGS_DA</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *, </span><a href="3-prp.html#SP8" class="function-link"><span class="function-syntax">Calculus::Propositions::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *, </span><a href="3-ap.html#SP24" class="function-link"><span class="function-syntax">Calculus::Atoms::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *, </span><a href="3-trm.html#SP10" class="function-link"><span class="function-syntax">Calculus::Terms::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *, </span><a href="2-bp.html#SP31" class="function-link"><span class="function-syntax">BinaryPredicates::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *, </span><a href="2-up.html#SP3" class="function-link"><span class="function-syntax">UnaryPredicates::log</span></a><span class="plain-syntax">)</span>
|
||||
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">CalculusModule::start</span><span class="plain-syntax">(</span><span class="reserved-syntax">void</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'D'</span><span class="plain-syntax">, </span><a href="3-prp.html#SP8" class="function-link"><span class="function-syntax">Calculus::Propositions::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'o'</span><span class="plain-syntax">, </span><a href="3-ap.html#SP24" class="function-link"><span class="function-syntax">Calculus::Atoms::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'0'</span><span class="plain-syntax">, </span><a href="3-trm.html#SP10" class="function-link"><span class="function-syntax">Calculus::Terms::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'2'</span><span class="plain-syntax">, </span><a href="2-bp.html#SP31" class="function-link"><span class="function-syntax">BinaryPredicates::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'r'</span><span class="plain-syntax">, </span><a href="2-up.html#SP3" class="function-link"><span class="function-syntax">UnaryPredicates::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">PREDICATE_CALCULUS_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"predicate calculus"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</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::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">PREDICATE_CALCULUS_WORKINGS_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"predicate calculus workings"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="2-ter.html#SP2" class="function-link"><span class="function-syntax">Calculus::Equality::start</span></a><span class="plain-syntax">();</span>
|
||||
|
|
|
|||
|
|
@ -791,7 +791,7 @@ would always be <span class="extract"><span class="extract-syntax">NULL</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">BinaryPredicates::log</span><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">BinaryPredicates::log</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">BinaryPredicates::log</span></span>:<br/>Calculus Module - <a href="1-cm.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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">i</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">bp</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"<null-BP>\n"</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">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"BP%d <%S> - %s way round - %s\n"</span><span class="plain-syntax">,</span>
|
||||
|
|
@ -825,7 +825,7 @@ so the fact that it runs relatively slowly does not matter.
|
|||
<p class="commentary firstcommentary"><a id="SP33" class="paragraph-anchor"></a><b>§33. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_log_name</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">BinaryPredicates::get_log_name</span></span>:<br/>Atomic Propositions - <a href="3-ap.html#SP24_2">§24.2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax">) {</span>
|
||||
<span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_log_name</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">BinaryPredicates::get_log_name</span></span>:<br/>Atomic Propositions - <a href="3-ap.html#SP24_2">§24.2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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">bp</span><span class="plain-syntax">-></span><span class="element-syntax">debugging_log_name</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
|
|
@ -841,7 +841,7 @@ so the fact that it runs relatively slowly does not matter.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bp</span><span class="plain-syntax">-></span><span class="element-syntax">form_of_relation</span><span class="plain-syntax"> == </span><span class="constant-syntax">Relation_ByRoutine</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">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">char</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::form_to_text</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">BinaryPredicates::form_to_text</span></span>:<br/><a href="2-bp.html#SP31">§31</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">char</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::form_to_text</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">BinaryPredicates::form_to_text</span></span>:<br/><a href="2-bp.html#SP31">§31</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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">bp</span><span class="plain-syntax">-></span><span class="element-syntax">form_of_relation</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">Relation_Implicit:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"Relation_Implicit"</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">Relation_OtoO:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"Relation_OtoO"</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -864,11 +864,11 @@ so the fact that it runs relatively slowly does not matter.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::term_kind</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">BinaryPredicates::term_kind</span></span>:<br/>Binary Predicate Families - <a href="2-bpf.html#SP6">§6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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">kind</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::term_kind</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">BinaryPredicates::term_kind</span></span>:<br/>Binary Predicate Families - <a href="2-bpf.html#SP6">§6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bp</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">"tried to find kind of null relation"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="2-bp.html#SP21" class="function-link"><span class="function-syntax">BinaryPredicates::kind_of_term</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">bp</span><span class="plain-syntax">-></span><span class="element-syntax">term_details</span><span class="plain-syntax">[</span><span class="identifier-syntax">t</span><span class="plain-syntax">]));</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
<span class="reserved-syntax">i6_schema</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_term_as_function_of_other</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">BinaryPredicates::get_term_as_function_of_other</span></span>:<br/>Terms - <a href="3-trm.html#SP9">§9</a>, <a href="3-trm.html#SP10">§10</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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="reserved-syntax">i6_schema</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_term_as_function_of_other</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">BinaryPredicates::get_term_as_function_of_other</span></span>:<br/>Terms - <a href="3-trm.html#SP9">§9</a>, <a href="3-trm.html#SP10">§10</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">bp</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">"tried to find function of null relation"</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">bp</span><span class="plain-syntax">-></span><span class="element-syntax">term_details</span><span class="plain-syntax">[</span><span class="identifier-syntax">t</span><span class="plain-syntax">].</span><span class="element-syntax">function_of_other</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
@ -877,7 +877,7 @@ so the fact that it runs relatively slowly does not matter.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_reversal</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">BinaryPredicates::get_reversal</span></span>:<br/><a href="2-bp.html#SP15">§15</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">BinaryPredicates::get_reversal</span><button class="popup" onclick="togglePopup('usagePopup14')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup14">Usage of <span class="code-font"><span class="function-syntax">BinaryPredicates::get_reversal</span></span>:<br/><a href="2-bp.html#SP15">§15</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</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">bp</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">"tried to find reversal of null relation"</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">bp</span><span class="plain-syntax">-></span><span class="element-syntax">reversal</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ also records its sense, i.e., positive or negative:
|
|||
</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">UnaryPredicates::log</span><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">UnaryPredicates::log</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">UnaryPredicates::log</span></span>:<br/>Calculus Module - <a href="1-cm.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="identifier-syntax">aph</span><span class="plain-syntax"> = </span><a href="2-up.html#SP4" class="function-link"><span class="function-syntax">UnaryPredicates::get_adj</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">au</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">Lcon::get_sense</span><span class="plain-syntax">(</span><span class="identifier-syntax">au</span><span class="plain-syntax">-></span><span class="element-syntax">lcon</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NEGATIVE_SENSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"~"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">W</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Adjectives::get_nominative_singular</span><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -109,12 +109,12 @@ also records its sense, i.e., positive or negative:
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="function-syntax">UnaryPredicates::get_adj</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">UnaryPredicates::get_adj</span></span>:<br/><a href="2-up.html#SP3">§3</a><br/>Terms - <a href="3-trm.html#SP7">§7</a><br/>Atomic Propositions - <a href="3-ap.html#SP24_1">§24.1</a><br/>Binding and Substitution - <a href="3-bas.html#SP17">§17</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</span><span class="plain-syntax">) {</span>
|
||||
<span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="function-syntax">UnaryPredicates::get_adj</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">UnaryPredicates::get_adj</span></span>:<br/><a href="2-up.html#SP3">§3</a><br/>Terms - <a href="3-trm.html#SP7">§7</a><br/>Atomic Propositions - <a href="3-ap.html#SP24_1">§24.1</a><br/>Binding and Substitution - <a href="3-bas.html#SP17">§17</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</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">au</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">NULL</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">Adjectives::from_lcon</span><span class="plain-syntax">(</span><span class="identifier-syntax">au</span><span class="plain-syntax">-></span><span class="element-syntax">lcon</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">UnaryPredicates::get_parity</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">UnaryPredicates::get_parity</span></span>:<br/>Atomic Propositions - <a href="3-ap.html#SP24_1">§24.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">UnaryPredicates::get_parity</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">UnaryPredicates::get_parity</span></span>:<br/>Atomic Propositions - <a href="3-ap.html#SP24_1">§24.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">au</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">au</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">"null adjective tested for positivity"</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">Lcon::get_sense</span><span class="plain-syntax">(</span><span class="identifier-syntax">au</span><span class="plain-syntax">-></span><span class="element-syntax">lcon</span><span class="plain-syntax">) == </span><span class="identifier-syntax">NEGATIVE_SENSE</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
|
|
|
|||
|
|
@ -131,8 +131,8 @@ following is our Periodic Table of all possible elements:
|
|||
<span class="definition-keyword">define</span> <span class="constant-syntax">CALLED_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">18</span><span class="plain-syntax"> </span><span class="comment-syntax"> to keep track of "(called the intruder)"-style names</span>
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">20</span><span class="plain-syntax"> </span><span class="comment-syntax"> logical negation </span>\(\lnot\)<span class="comment-syntax"> applied to contents of group</span>
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">NEGATION_CLOSE_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">30</span><span class="plain-syntax"> </span><span class="comment-syntax"> end of logical negation </span>\(\lnot\)
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">21</span><span class="plain-syntax"> </span><span class="comment-syntax"> logical negation </span>\(\lnot\)<span class="comment-syntax"> applied to contents of group</span>
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">DOMAIN_CLOSE_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">31</span><span class="plain-syntax"> </span><span class="comment-syntax"> end of logical negation </span>\(\lnot\)
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">21</span><span class="plain-syntax"> </span><span class="comment-syntax"> this holds the domain of a quantifier</span>
|
||||
<span class="definition-keyword">define</span> <span class="constant-syntax">DOMAIN_CLOSE_ATOM</span><span class="plain-syntax"> </span><span class="constant-syntax">31</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b>And as with columns in the Periodic Table, these elements come in what are
|
||||
called "groups", because it often happens that atoms of different elements
|
||||
|
|
@ -148,7 +148,7 @@ behave similarly when the elements have something in common.
|
|||
</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">Calculus::Atoms::element_get_group</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::element_get_group</span></span>:<br/><a href="3-ap.html#SP23">§23</a><br/>Propositions - <a href="3-prp.html#SP6">§6</a>, <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP28">§28</a><br/>Binding and Substitution - <a href="3-bas.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::element_get_group</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::element_get_group</span></span>:<br/><a href="3-ap.html#SP23">§23</a><br/>Propositions - <a href="3-prp.html#SP6">§6</a>, <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP30">§30</a><br/>Binding and Substitution - <a href="3-bas.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</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">element</span><span class="plain-syntax"> <= </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">element</span><span class="plain-syntax"> < </span><span class="constant-syntax">STRUCTURAL_GROUP</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">STRUCTURAL_GROUP</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">element</span><span class="plain-syntax"> < </span><span class="constant-syntax">PREDICATES_GROUP</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">PREDICATES_GROUP</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -163,7 +163,7 @@ like this, or else returns the opposite number to any element code which does.
|
|||
</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">Calculus::Atoms::element_get_match</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::element_get_match</span></span>:<br/>Propositions - <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP28">§28</a>, <a href="3-prp.html#SP31">§31</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::element_get_match</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::element_get_match</span></span>:<br/>Propositions - <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP30">§30</a>, <a href="3-prp.html#SP33">§33</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</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">element</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_OPEN_ATOM:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">NEGATION_CLOSE_ATOM</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_CLOSE_ATOM:</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -177,7 +177,7 @@ like this, or else returns the opposite number to any element code which does.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::new</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">Calculus::Atoms::new</span></span>:<br/><a href="3-ap.html#SP7">§7</a>, <a href="3-ap.html#SP10">§10</a>, <a href="3-ap.html#SP11">§11</a>, <a href="3-ap.html#SP12">§12</a>, <a href="3-ap.html#SP13">§13</a>, <a href="3-ap.html#SP14">§14</a>, <a href="3-ap.html#SP15">§15</a>, <a href="3-ap.html#SP16">§16</a>, <a href="3-ap.html#SP17">§17</a>, <a href="3-ap.html#SP19">§19</a>, <a href="3-ap.html#SP20">§20</a><br/>Propositions - <a href="3-prp.html#SP13">§13</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::new</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">Calculus::Atoms::new</span></span>:<br/><a href="3-ap.html#SP7">§7</a>, <a href="3-ap.html#SP10">§10</a>, <a href="3-ap.html#SP11">§11</a>, <a href="3-ap.html#SP12">§12</a>, <a href="3-ap.html#SP13">§13</a>, <a href="3-ap.html#SP14">§14</a>, <a href="3-ap.html#SP15">§15</a>, <a href="3-ap.html#SP16">§16</a>, <a href="3-ap.html#SP17">§17</a>, <a href="3-ap.html#SP19">§19</a>, <a href="3-ap.html#SP20">§20</a><br/>Propositions - <a href="3-prp.html#SP13">§13</a>, <a href="3-prp.html#SP16">§16</a>, <a href="3-prp.html#SP17">§17</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">CREATE</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="identifier-syntax">next</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">prop</span><span class="plain-syntax">-></span><span class="identifier-syntax">element</span><span class="plain-syntax"> = </span><span class="identifier-syntax">element</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -211,7 +211,7 @@ rather than \(\forall 1. P\).
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span></span>:<br/>Binding and Substitution - <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">quantifier</span><span class="plain-syntax"> *</span><span class="identifier-syntax">quant</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parameter</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span></span>:<br/>Propositions - <a href="3-prp.html#SP17">§17</a><br/>Binding and Substitution - <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">quantifier</span><span class="plain-syntax"> *</span><span class="identifier-syntax">quant</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parameter</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP6" class="function-link"><span class="function-syntax">Calculus::Atoms::new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="identifier-syntax">arity</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="identifier-syntax">terms</span><span class="plain-syntax">[0] = </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_variable</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">v</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -240,7 +240,7 @@ rather than \(\forall 1. P\).
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::is_existence_quantifier</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">Calculus::Atoms::is_existence_quantifier</span></span>:<br/>Propositions - <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP26">§26</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::is_existence_quantifier</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">Calculus::Atoms::is_existence_quantifier</span></span>:<br/>Propositions - <a href="3-prp.html#SP11">§11</a>, <a href="3-prp.html#SP28">§28</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">prop</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">) &&</span>
|
||||
<span class="plain-syntax"> (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">quant</span><span class="plain-syntax"> == </span><span class="identifier-syntax">exists_quantifier</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -268,7 +268,7 @@ rather than \(\forall 1. P\).
|
|||
<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">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::is_for_all_x</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">Calculus::Atoms::is_for_all_x</span></span>:<br/>Propositions - <a href="3-prp.html#SP32">§32</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::is_for_all_x</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">Calculus::Atoms::is_for_all_x</span></span>:<br/>Propositions - <a href="3-prp.html#SP34">§34</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_forall_quantifier</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">)) && (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0].</span><span class="element-syntax">variable</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</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>
|
||||
|
|
@ -472,11 +472,11 @@ need \(t=x\), that is, variable 0.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</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">Calculus::Atoms::unary_PREDICATE_from_aph</span></span>:<br/>Propositions - <a href="3-prp.html#SP34_1">§34.1</a>, <a href="3-prp.html#SP34_2">§34.2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">negated</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</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">Calculus::Atoms::unary_PREDICATE_from_aph</span></span>:<br/>Propositions - <a href="3-prp.html#SP36_1">§36.1</a>, <a href="3-prp.html#SP36_2">§36.2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">negated</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-ap.html#SP19" class="function-link"><span class="function-syntax">Calculus::Atoms::unary_PREDICATE_from_aph_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="identifier-syntax">negated</span><span class="plain-syntax">, </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_variable</span></a><span class="plain-syntax">(0));</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::au_from_unary_PREDICATE</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">Calculus::Atoms::au_from_unary_PREDICATE</span></span>:<br/>Propositions - <a href="3-prp.html#SP27">§27</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::au_from_unary_PREDICATE</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">Calculus::Atoms::au_from_unary_PREDICATE</span></span>:<br/>Propositions - <a href="3-prp.html#SP29">§29</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">RETRIEVE_POINTER_unary_predicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">predicate</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
|
|
@ -500,7 +500,7 @@ need \(t=x\), that is, variable 0.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">RETRIEVE_POINTER_binary_predicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">predicate</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">Calculus::Atoms::is_equality_predicate</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">Calculus::Atoms::is_equality_predicate</span></span>:<br/><a href="3-ap.html#SP22">§22</a><br/>Propositions - <a href="3-prp.html#SP12">§12</a>, <a href="3-prp.html#SP23">§23</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::is_equality_predicate</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">Calculus::Atoms::is_equality_predicate</span></span>:<br/><a href="3-ap.html#SP22">§22</a><br/>Propositions - <a href="3-prp.html#SP12">§12</a>, <a href="3-prp.html#SP25">§25</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">binary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bp</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP20" class="function-link"><span class="function-syntax">Calculus::Atoms::is_binary_predicate</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">bp</span><span class="plain-syntax"> == </span><span class="identifier-syntax">R_equality</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>
|
||||
|
|
@ -510,7 +510,7 @@ need \(t=x\), that is, variable 0.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::prop_x_is_constant</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::prop_x_is_constant</span></span>:<br/>Propositions - <a href="3-prp.html#SP34_3">§34.3</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">spec</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Atoms::prop_x_is_constant</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::prop_x_is_constant</span></span>:<br/>Propositions - <a href="3-prp.html#SP36_3">§36.3</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">spec</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-ap.html#SP20" class="function-link"><span class="function-syntax">Calculus::Atoms::binary_PREDICATE_new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">R_equality</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_variable</span></a><span class="plain-syntax">(0), </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
@ -553,10 +553,10 @@ need \(t=x\), that is, variable 0.
|
|||
</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">Calculus::Atoms::log</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::log</span><button class="popup" onclick="togglePopup('usagePopup15')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup15">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::log</span></span>:<br/>Calculus Module - <a href="1-cm.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP24" class="function-link"><span class="function-syntax">Calculus::Atoms::write</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DL</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</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">Calculus::Atoms::write</span><button class="popup" onclick="togglePopup('usagePopup15')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup15">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::write</span></span>:<br/>Propositions - <a href="3-prp.html#SP8">§8</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Atoms::write</span><button class="popup" onclick="togglePopup('usagePopup16')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup16">Usage of <span class="code-font"><span class="function-syntax">Calculus::Atoms::write</span></span>:<br/>Propositions - <a href="3-prp.html#SP8">§8</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">prop</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"<null-atom>"</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax">; }</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">arity</span><span class="plain-syntax"> == </span><span class="constant-syntax">2</span><span class="plain-syntax">) &&</span>
|
||||
<span class="plain-syntax"> (</span><span class="identifier-syntax">RETRIEVE_POINTER_binary_predicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">predicate</span><span class="plain-syntax">) == </span><span class="identifier-syntax">R_equality</span><span class="plain-syntax">)) {</span>
|
||||
|
|
@ -603,10 +603,10 @@ need \(t=x\), that is, variable 0.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">EVERYWHERE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"everywhere"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NOWHERE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"nowhere"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">HERE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"here"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_OPEN_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"NOT["</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_CLOSE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"NOT]"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DOMAIN_OPEN_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"IN["</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DOMAIN_CLOSE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"IN]"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_OPEN_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"NOT<"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">NEGATION_CLOSE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"NOT>"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DOMAIN_OPEN_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"IN<"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">DOMAIN_CLOSE_ATOM:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"IN>"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">default:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"?bad-atom?"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">arity</span><span class="plain-syntax"> > </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
|
||||
|
|
|
|||
|
|
@ -151,11 +151,10 @@ the quantifier has finished. We set the <span class="extract"><span class="extra
|
|||
<span class="definition-keyword">define</span> <span class="constant-syntax">BOUND_VST</span><span class="plain-syntax"> </span><span class="constant-syntax">3</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Variables::determine_status</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Variables::determine_status</span></span>:<br/><a href="3-bas.html#SP4">§4</a>, <a href="3-bas.html#SP5">§5</a>, <a href="3-bas.html#SP6">§6</a>, <a href="3-bas.html#SP7">§7</a>, <a href="3-bas.html#SP10">§10</a>, <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> *</span><span class="identifier-syntax">var_states</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> *</span><span class="identifier-syntax">valid</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Variables::determine_status</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Variables::determine_status</span></span>:<br/><a href="3-bas.html#SP4">§4</a>, <a href="3-bas.html#SP5">§5</a>, <a href="3-bas.html#SP6">§6</a>, <a href="3-bas.html#SP7">§7</a>, <a href="3-bas.html#SP10">§10</a>, <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> *</span><span class="identifier-syntax">var_states</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">err</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">unavailable</span><span class="plain-syntax">[26], </span><span class="identifier-syntax">blevel</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">dummy</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">valid</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">valid</span><span class="plain-syntax"> = &</span><span class="identifier-syntax">dummy</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> *</span><span class="identifier-syntax">valid</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="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">unavailable</span><span class="plain-syntax">[26], </span><span class="identifier-syntax">blevel</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">valid</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">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">j</span><span class="plain-syntax"><26; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) { </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] = </span><span class="constant-syntax">UNUSED_VST</span><span class="plain-syntax">; </span><span class="identifier-syntax">unavailable</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] = </span><span class="constant-syntax">0</span><span class="plain-syntax">; }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_PROPOSITION</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-ap.html#SP4" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax">) == </span><span class="constant-syntax">OPEN_OPERATORS_GROUP</span><span class="plain-syntax">) </span><span class="identifier-syntax">blevel</span><span class="plain-syntax">++;</span>
|
||||
|
|
@ -165,16 +164,18 @@ the quantifier has finished. We set the <span class="extract"><span class="extra
|
|||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">j</span><span class="function-syntax"><p-></span><span class="element-syntax">arity</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax"> = </span><a href="3-trm.html#SP6" class="function-link"><span class="function-syntax">Calculus::Terms::variable_underlying</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">]));</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">v</span><span class="plain-syntax"> >= </span><span class="constant-syntax">26</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"corrupted variable term"</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">v</span><span class="plain-syntax"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">v</span><span class="plain-syntax"> >= </span><span class="constant-syntax">26</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"corrupted variable term"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">valid</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">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">v</span><span class="plain-syntax"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">unavailable</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">] == -1) {</span>
|
||||
<span class="plain-syntax"> *</span><span class="identifier-syntax">valid</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">"$o invalid because of %c unavailable\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">pcalc_vars</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">valid</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">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"%c unavailable"</span><span class="plain-syntax">, </span><span class="identifier-syntax">pcalc_vars</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</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">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">QUANTIFIER_ATOM</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">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">] != </span><span class="constant-syntax">UNUSED_VST</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> *</span><span class="identifier-syntax">valid</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">"$D: $o invalid because of %c Q for F\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">pcalc_vars</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">valid</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">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"%c used outside its binding"</span><span class="plain-syntax">, </span><span class="identifier-syntax">pcalc_vars</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">]);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">] = </span><span class="constant-syntax">BOUND_VST</span><span class="plain-syntax">; </span><span class="identifier-syntax">unavailable</span><span class="plain-syntax">[</span><span class="identifier-syntax">v</span><span class="plain-syntax">] = </span><span class="identifier-syntax">blevel</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
|
||||
|
|
@ -183,18 +184,17 @@ the quantifier has finished. We set the <span class="extract"><span class="extra
|
|||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</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">valid</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. </b>With just a little wrapping, this gives us the test of well-formedness.
|
||||
</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">Calculus::Variables::is_well_formed</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Variables::is_well_formed</span></span>:<br/><a href="3-bas.html#SP14">§14</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">status</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[26];</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP11" class="function-link"><span class="function-syntax">Calculus::Propositions::is_syntactically_valid</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</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><a href="3-bas.html#SP3" class="function-link"><span class="function-syntax">Calculus::Variables::determine_status</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">, &</span><span class="identifier-syntax">status</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">status</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Variable usage malformed\n"</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Variables::is_well_formed</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Variables::is_well_formed</span></span>:<br/><a href="3-bas.html#SP14">§14</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">err</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">var_states</span><span class="plain-syntax">[26];</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP11" class="function-link"><span class="function-syntax">Calculus::Propositions::is_syntactically_valid</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">err</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</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">return</span><span class="plain-syntax"> </span><a href="3-bas.html#SP3" class="function-link"><span class="function-syntax">Calculus::Variables::determine_status</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">, </span><span class="identifier-syntax">err</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>§5. </b>Occasionally we really do care only about one of the 26 variables:
|
||||
|
|
@ -371,7 +371,7 @@ order. For instance:
|
|||
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">=25; </span><span class="identifier-syntax">j</span><span class="plain-syntax">>=0; </span><span class="identifier-syntax">j</span><span class="plain-syntax">--)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="constant-syntax">FREE_VST</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP16" class="function-link"><span class="function-syntax">Calculus::Propositions::insert_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP18" class="function-link"><span class="function-syntax">Calculus::Propositions::insert_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP7" class="function-link"><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">exists_quantifier</span><span class="plain-syntax">, </span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">));</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -430,7 +430,7 @@ looks viable, and once to perform the substitution itself.
|
|||
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">verify_only</span><span class="plain-syntax">) *</span><span class="identifier-syntax">allowed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">v</span><span class="plain-syntax"><0) || (</span><span class="identifier-syntax">v</span><span class="plain-syntax">>=26)) </span><span class="identifier-syntax">DISALLOW</span><span class="plain-syntax">(</span><span class="string-syntax">"variable substitution out of range"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-bas.html#SP4" class="function-link"><span class="function-syntax">Calculus::Variables::is_well_formed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-bas.html#SP4" class="function-link"><span class="function-syntax">Calculus::Variables::is_well_formed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">DISALLOW</span><span class="plain-syntax">(</span><span class="string-syntax">"substituting into malformed prop"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-bas.html#SP14_1" class="named-paragraph-link"><span class="named-paragraph">Make sure the substitution would not fail because of a circularity</span><span class="named-paragraph-number">14.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">verify_only</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -444,7 +444,7 @@ looks viable, and once to perform the substitution itself.
|
|||
<span class="plain-syntax"> *</span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</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><a href="3-bas.html#SP4" class="function-link"><span class="function-syntax">Calculus::Variables::is_well_formed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-bas.html#SP4" class="function-link"><span class="function-syntax">Calculus::Variables::is_well_formed</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"substitution made malformed prop"</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">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ function togglePopup(material_id) {
|
|||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Services</a></li><li><a href="index.html">calculus</a></li><li><a href="index.html#3">Chapter 3: Propositions</a></li><li><b>Propositions</b></li></ul></div>
|
||||
<p class="purpose">To build and modify structures representing propositions in predicate calculus.</p>
|
||||
|
||||
<ul class="toc"><li><a href="3-prp.html#SP6">§6. Implied conjunction</a></li><li><a href="3-prp.html#SP9">§9. Validity</a></li><li><a href="3-prp.html#SP12">§12. Complexity</a></li><li><a href="3-prp.html#SP13">§13. Primitive operations on propositions</a></li><li><a href="3-prp.html#SP16">§16. Inserting and deleting atoms</a></li><li><a href="3-prp.html#SP18">§18. Inspecting contents</a></li><li><a href="3-prp.html#SP19">§19. Matching sequences of atoms</a></li><li><a href="3-prp.html#SP20">§20. Seeking atoms</a></li><li><a href="3-prp.html#SP28">§28. Bracketed groups</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="3-prp.html#SP6">§6. Implied conjunction</a></li><li><a href="3-prp.html#SP9">§9. Validity</a></li><li><a href="3-prp.html#SP12">§12. Complexity</a></li><li><a href="3-prp.html#SP13">§13. Primitive operations on propositions</a></li><li><a href="3-prp.html#SP16">§16. Negation</a></li><li><a href="3-prp.html#SP17">§17. Quantification</a></li><li><a href="3-prp.html#SP18">§18. Inserting and deleting atoms</a></li><li><a href="3-prp.html#SP20">§20. Inspecting contents</a></li><li><a href="3-prp.html#SP21">§21. Matching sequences of atoms</a></li><li><a href="3-prp.html#SP22">§22. Seeking atoms</a></li><li><a href="3-prp.html#SP30">§30. Bracketed groups</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b>We now begin on the data structures to hold propositions. Now a properly
|
||||
constructed proposition has a natural tree structure — one can regard
|
||||
|
|
@ -260,7 +260,7 @@ logged as just <span class="extract"><span class="extract-syntax"><< >&
|
|||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">log_addresses</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::log</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::log</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">Calculus::Propositions::log</span></span>:<br/>Calculus Module - <a href="1-cm.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="3-prp.html#SP8" class="function-link"><span class="function-syntax">Calculus::Propositions::write</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DL</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</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">Calculus::Propositions::write</span><span class="plain-syntax">(</span><span class="identifier-syntax">OUTPUT_STREAM</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -336,39 +336,39 @@ but we can at least test syntactic validity here.
|
|||
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">MAX_PROPOSITION_GROUP_NESTING</span><span class="plain-syntax"> </span><span class="constant-syntax">100</span><span class="plain-syntax"> </span><span class="comment-syntax"> vastly more than could realistically be used</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::is_syntactically_valid</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">Calculus::Propositions::is_syntactically_valid</span></span>:<br/>Binding and Substitution - <a href="3-bas.html#SP4">§4</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::is_syntactically_valid</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::is_syntactically_valid</span></span>:<br/>Binding and Substitution - <a href="3-bas.html#SP4">§4</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">err</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">groups_stack</span><span class="plain-syntax">[</span><span class="constant-syntax">MAX_PROPOSITION_GROUP_NESTING</span><span class="plain-syntax">], </span><span class="identifier-syntax">group_sp</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_PROPOSITION</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="comment-syntax"> (1) each individual atom has to be properly built:</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">char</span><span class="plain-syntax"> *</span><span class="identifier-syntax">err</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP23" class="function-link"><span class="function-syntax">Calculus::Atoms::validate</span></a><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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">err</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Atom error: %s: $o\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</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">char</span><span class="plain-syntax"> *</span><span class="identifier-syntax">v_err</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP23" class="function-link"><span class="function-syntax">Calculus::Atoms::validate</span></a><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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">v_err</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"atom error: %s"</span><span class="plain-syntax">, </span><span class="identifier-syntax">err</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="comment-syntax"> (2) every open bracket must be matched by a close bracket of the same kind:</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-ap.html#SP4" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax">) == </span><span class="constant-syntax">OPEN_OPERATORS_GROUP</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">group_sp</span><span class="plain-syntax"> >= </span><span class="constant-syntax">MAX_PROPOSITION_GROUP_NESTING</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">"Group nesting too deep\n"</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="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"group nesting too deep"</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">groups_stack</span><span class="plain-syntax">[</span><span class="identifier-syntax">group_sp</span><span class="plain-syntax">++] = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</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><a href="3-ap.html#SP4" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax">) == </span><span class="constant-syntax">CLOSE_OPERATORS_GROUP</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">group_sp</span><span class="plain-syntax"> <= </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Too many close groups\n"</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">group_sp</span><span class="plain-syntax"> <= </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"too many close groups"</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><a href="3-ap.html#SP5" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_match</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">groups_stack</span><span class="plain-syntax">[--</span><span class="identifier-syntax">group_sp</span><span class="plain-syntax">]) != </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</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">"Group open/close doesn't match\n"</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="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"group open/close doesn't match"</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="comment-syntax"> (3) every quantifier except "exists" must be followed by domain brackets, which occur nowhere else:</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_quantifier</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">)) && (</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_existence_quantifier</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p_prev</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">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> != </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Quant without domain\n"</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">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> != </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"quant without domain"</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">else</span><span class="plain-syntax"> {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Domain without quant\n"</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">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"domain without quant"</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) &&</span>
|
||||
<span class="plain-syntax"> (</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_quantifier</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">)) && (</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_existence_quantifier</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</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">"Ends without domain of final quantifier\n"</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="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"ends without domain of final quantifier"</span><span class="plain-syntax">); </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="comment-syntax"> (4) a proposition must end with all its brackets closed:</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">group_sp</span><span class="plain-syntax"> != </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"%d group(s) open\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">group_sp</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">group_sp</span><span class="plain-syntax"> != </span><span class="constant-syntax">0</span><span class="plain-syntax">) { </span><span class="identifier-syntax">WRITE_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">err</span><span class="plain-syntax">, </span><span class="string-syntax">"%d group(s) open"</span><span class="plain-syntax">, </span><span class="identifier-syntax">group_sp</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
|
|
@ -423,7 +423,7 @@ need to be careful in using this.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::concatenate</span><button class="popup" onclick="togglePopup('usagePopup4')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup4">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::concatenate</span></span>:<br/><a href="3-prp.html#SP15">§15</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">existing_body</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">tail</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::concatenate</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::concatenate</span></span>:<br/><a href="3-prp.html#SP15">§15</a>, <a href="3-prp.html#SP16">§16</a>, <a href="3-prp.html#SP17">§17</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">existing_body</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">end</span><span class="plain-syntax"> = </span><span class="identifier-syntax">existing_body</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">end</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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">sc</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -467,12 +467,43 @@ need to be careful in using this.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Tail: $D\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">tail</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP15">§15</a> (twice).</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP16" class="paragraph-anchor"></a><b>§16. Inserting and deleting atoms. </b>Here we insert an atom at a given position, or at the front if the position
|
||||
<p class="commentary firstcommentary"><a id="SP16" class="paragraph-anchor"></a><b>§16. Negation. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::negate</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP6" class="function-link"><span class="function-syntax">Calculus::Atoms::new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP6" class="function-link"><span class="function-syntax">Calculus::Atoms::new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">NEGATION_CLOSE_ATOM</span><span class="plain-syntax">)));</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP17" class="paragraph-anchor"></a><b>§17. Quantification. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::quantify</span><span class="plain-syntax">(</span><span class="identifier-syntax">quantifier</span><span class="plain-syntax"> *</span><span class="identifier-syntax">quant</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parameter</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">domain</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP7" class="function-link"><span class="function-syntax">Calculus::Atoms::QUANTIFIER_new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">quant</span><span class="plain-syntax">, </span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="identifier-syntax">parameter</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::quantify_using</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Q</span><span class="plain-syntax">, </span><span class="identifier-syntax">domain</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::quantify_using</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">Q</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">domain</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">domain</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Q</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Q</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP6" class="function-link"><span class="function-syntax">Calculus::Atoms::new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">DOMAIN_OPEN_ATOM</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">domain</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ap.html#SP6" class="function-link"><span class="function-syntax">Calculus::Atoms::new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">DOMAIN_CLOSE_ATOM</span><span class="plain-syntax">))));</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP14" class="function-link"><span class="function-syntax">Calculus::Propositions::concatenate</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Q</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>§18. Inserting and deleting atoms. </b>Here we insert an atom at a given position, or at the front if the position
|
||||
is <span class="extract"><span class="extract-syntax">NULL</span></span>.
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::insert_atom</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::insert_atom</span></span>:<br/>Binding and Substitution - <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</span><span class="plain-syntax">,</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::insert_atom</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">Calculus::Propositions::insert_atom</span></span>:<br/>Binding and Substitution - <a href="3-bas.html#SP11">§11</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">new_atom</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">position</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">new_atom</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -485,11 +516,11 @@ is <span class="extract"><span class="extract-syntax">NULL</span></span>.
|
|||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP17" class="paragraph-anchor"></a><b>§17. </b>And similarly, with the deleted atom the one after the position given:
|
||||
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>§19. </b>And similarly, with the deleted atom the one after the position given:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::delete_atom</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">Calculus::Propositions::delete_atom</span></span>:<br/><a href="3-prp.html#SP31">§31</a>, <a href="3-prp.html#SP32">§32</a>, <a href="3-prp.html#SP33">§33</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::delete_atom</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">Calculus::Propositions::delete_atom</span></span>:<br/><a href="3-prp.html#SP33">§33</a>, <a href="3-prp.html#SP34">§34</a>, <a href="3-prp.html#SP35">§35</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</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">position</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prop</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">"deleting atom nowhere"</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">prop</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -500,7 +531,7 @@ is <span class="extract"><span class="extract-syntax">NULL</span></span>.
|
|||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP18" class="paragraph-anchor"></a><b>§18. Inspecting contents. </b>First, we count the number of atoms in a given proposition. This is used by
|
||||
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>§20. Inspecting contents. </b>First, we count the number of atoms in a given proposition. This is used by
|
||||
other parts of Inform as a crude measure of how complicated it is; though in
|
||||
fact it is not all that crude so long as it is applied to a proposition
|
||||
which has been simplified.
|
||||
|
|
@ -514,7 +545,7 @@ which has been simplified.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP19" class="paragraph-anchor"></a><b>§19. Matching sequences of atoms. </b>The following sneakily variable-argument-length function can be used to
|
||||
<p class="commentary firstcommentary"><a id="SP21" class="paragraph-anchor"></a><b>§21. Matching sequences of atoms. </b>The following sneakily variable-argument-length function can be used to
|
||||
detect subsequences within a proposition: say, the sequence
|
||||
</p>
|
||||
|
||||
|
|
@ -539,7 +570,7 @@ four.) There are two special pseudo-element-numbers:
|
|||
<span class="definition-keyword">define</span> <span class="constant-syntax">END_PROP_HERE</span><span class="plain-syntax"> -1 </span><span class="comment-syntax"> a sentinel meaning "the proposition must end at this point"</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::match</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">Calculus::Propositions::match</span></span>:<br/><a href="3-prp.html#SP32">§32</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::match</span><button class="popup" onclick="togglePopup('usagePopup8')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup8">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::match</span></span>:<br/><a href="3-prp.html#SP34">§34</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax">, ...) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="identifier-syntax">outcome</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">va_list</span><span class="plain-syntax"> </span><span class="identifier-syntax">ap</span><span class="plain-syntax">; </span><span class="comment-syntax"> the variable argument list signified by the dots</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">va_start</span><span class="plain-syntax">(</span><span class="identifier-syntax">ap</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax">); </span><span class="comment-syntax"> macro to begin variable argument processing</span>
|
||||
|
|
@ -560,12 +591,12 @@ four.) There are two special pseudo-element-numbers:
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">outcome</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP20" class="paragraph-anchor"></a><b>§20. Seeking atoms. </b>Here we run through the proposition looking for either a given element, or
|
||||
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>§22. Seeking atoms. </b>Here we run through the proposition looking for either a given element, or
|
||||
a given arity, or both:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span><button class="popup" onclick="togglePopup('usagePopup8')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup8">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></span>:<br/><a href="3-prp.html#SP21">§21</a>, <a href="3-prp.html#SP22">§22</a>, <a href="3-prp.html#SP24">§24</a>, <a href="3-prp.html#SP27">§27</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">atom_req</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">arity_req</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::prop_seek_atom</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">Calculus::Propositions::prop_seek_atom</span></span>:<br/><a href="3-prp.html#SP23">§23</a>, <a href="3-prp.html#SP24">§24</a>, <a href="3-prp.html#SP26">§26</a>, <a href="3-prp.html#SP29">§29</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">atom_req</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">arity_req</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_PROPOSITION</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</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">atom_req</span><span class="plain-syntax"> < </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="identifier-syntax">atom_req</span><span class="plain-syntax">)) &&</span>
|
||||
|
|
@ -574,26 +605,26 @@ a given arity, or both:
|
|||
<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>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP21" class="paragraph-anchor"></a><b>§21. </b>Seeking different kinds of atom is now easy:
|
||||
<p class="commentary firstcommentary"><a id="SP23" class="paragraph-anchor"></a><b>§23. </b>Seeking different kinds of atom is now easy:
|
||||
</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">Calculus::Propositions::contains_binary_predicate</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">2</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="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><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">2</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="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">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::contains_quantifier</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, -1)) </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="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><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, -1)) </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="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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::composited_kind</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">k_atom</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">KIND_ATOM</span><span class="plain-syntax">, -1);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">k_atom</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">KIND_ATOM</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">k_atom</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">k_atom</span><span class="plain-syntax">-></span><span class="element-syntax">composited</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)) </span><span class="identifier-syntax">k_atom</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">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">k_atom</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">Calculus::Propositions::contains_nonexistence_quantifier</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">quantifier</span><span class="plain-syntax"> *</span><span class="identifier-syntax">quant</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">quant</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">quant</span><span class="plain-syntax"> != </span><span class="identifier-syntax">exists_quantifier</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="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -602,36 +633,36 @@ a given arity, or both:
|
|||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::contains_callings</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">CALLED_ATOM</span><span class="plain-syntax">, -1)) </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="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><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">CALLED_ATOM</span><span class="plain-syntax">, -1)) </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="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>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP22" class="paragraph-anchor"></a><b>§22. </b>Here we try to find out the kind of value of variable 0 without the full
|
||||
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>§24. </b>Here we try to find out the kind of value of variable 0 without the full
|
||||
expense of typechecking the proposition:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::describes_kind</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">ISAKIND_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">ISAKIND_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">)) != </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="3-trm.html#SP6" class="function-link"><span class="function-syntax">Calculus::Terms::variable_underlying</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0])) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) &&</span>
|
||||
<span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">assert_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_value</span><span class="plain-syntax">))) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">assert_kind</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">KIND_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">KIND_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">)) != </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-trm.html#SP6" class="function-link"><span class="function-syntax">Calculus::Terms::variable_underlying</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0])) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">assert_kind</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP23" class="function-link"><span class="function-syntax">Calculus::Propositions::describes_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP25" class="function-link"><span class="function-syntax">Calculus::Propositions::describes_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">val</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">VALUE_TO_KIND_FUNCTION</span><span class="plain-syntax">(</span><span class="identifier-syntax">val</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">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP23" class="paragraph-anchor"></a><b>§23. </b>And, similarly, the actual value it must have:
|
||||
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>§25. </b>And, similarly, the actual value it must have:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::describes_value</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">Calculus::Propositions::describes_value</span></span>:<br/><a href="3-prp.html#SP22">§22</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::describes_value</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">Calculus::Propositions::describes_value</span></span>:<br/><a href="3-prp.html#SP24">§24</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">; </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">bl</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">; </span><span class="identifier-syntax">p</span><span class="plain-syntax">; </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</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="element-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -653,26 +684,26 @@ expense of typechecking the proposition:
|
|||
<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>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>§24. </b>Finding an adjective is easy: it's a predicate of arity 1.
|
||||
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>§26. </b>Finding an adjective is easy: it's a predicate of arity 1.
|
||||
</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">Calculus::Propositions::contains_adjective</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </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">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </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>
|
||||
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::count_unary_predicates</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</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">ac</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">)) != </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-trm.html#SP6" class="function-link"><span class="function-syntax">Calculus::Terms::variable_underlying</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0])) == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">ac</span><span class="plain-syntax">++;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</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">ac</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>§25. </b>The following searches not for an atom, but for the lexically earliest
|
||||
<p class="commentary firstcommentary"><a id="SP27" class="paragraph-anchor"></a><b>§27. </b>The following searches not for an atom, but for the lexically earliest
|
||||
term in the proposition:
|
||||
</p>
|
||||
|
||||
|
|
@ -686,7 +717,7 @@ term in the proposition:
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_variable</span></a><span class="plain-syntax">(0); </span><span class="comment-syntax"> never executed, but needed to prevent </span><span class="extract"><span class="extract-syntax">gcc</span></span><span class="comment-syntax"> warnings</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>§26. </b>Here we attempt, if possible, to read a proposition as being either
|
||||
<p class="commentary firstcommentary"><a id="SP28" class="paragraph-anchor"></a><b>§28. </b>Here we attempt, if possible, to read a proposition as being either
|
||||
{\it adjective}(\(v\)) or \(\exists v: {\it adjective}(v)\), where the adjective
|
||||
can be also be read as a noun, and if so we return a constant term \(t\) for
|
||||
that noun; or if the proposition isn't in that form, we return \(t=x\), that
|
||||
|
|
@ -714,13 +745,13 @@ is, variable 0.
|
|||
<span class="plain-syntax">}</span>
|
||||
<span class="plain-syntax">#</span><span class="identifier-syntax">endif</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP27" class="paragraph-anchor"></a><b>§27. </b>We often form propositions which are really lists of adjectives, and the
|
||||
<p class="commentary firstcommentary"><a id="SP29" class="paragraph-anchor"></a><b>§29. </b>We often form propositions which are really lists of adjectives, and the
|
||||
following are useful for looping through them:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::first_unary_predicate</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> **</span><span class="identifier-syntax">ppp</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</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">ppp</span><span class="plain-syntax">) *</span><span class="identifier-syntax">ppp</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</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">prop</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">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-ap.html#SP19" class="function-link"><span class="function-syntax">Calculus::Atoms::au_from_unary_PREDICATE</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -728,13 +759,13 @@ following are useful for looping through them:
|
|||
|
||||
<span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::next_unary_predicate</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> **</span><span class="identifier-syntax">ppp</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">ppp</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">"bad ppp"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP20" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">((*</span><span class="identifier-syntax">ppp</span><span class="plain-syntax">)-></span><span class="element-syntax">next</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP22" class="function-link"><span class="function-syntax">Calculus::Propositions::prop_seek_atom</span></a><span class="plain-syntax">((*</span><span class="identifier-syntax">ppp</span><span class="plain-syntax">)-></span><span class="element-syntax">next</span><span class="plain-syntax">, </span><span class="constant-syntax">PREDICATE_ATOM</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> *</span><span class="identifier-syntax">ppp</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</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">prop</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">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-ap.html#SP19" class="function-link"><span class="function-syntax">Calculus::Atoms::au_from_unary_PREDICATE</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP28" class="paragraph-anchor"></a><b>§28. Bracketed groups. </b>The following routine tests whether the entire proposition is a single
|
||||
<p class="commentary firstcommentary"><a id="SP30" class="paragraph-anchor"></a><b>§30. Bracketed groups. </b>The following routine tests whether the entire proposition is a single
|
||||
bracketed group. For instance:
|
||||
</p>
|
||||
|
||||
|
|
@ -746,7 +777,7 @@ and that they may be nested.
|
|||
</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">Calculus::Propositions::is_a_group</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">Calculus::Propositions::is_a_group</span></span>:<br/><a href="3-prp.html#SP29">§29</a>, <a href="3-prp.html#SP30">§30</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">governing</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Propositions::is_a_group</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">Calculus::Propositions::is_a_group</span></span>:<br/><a href="3-prp.html#SP31">§31</a>, <a href="3-prp.html#SP32">§32</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">governing</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">match</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP5" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_match</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">governing</span><span class="plain-syntax">), </span><span class="identifier-syntax">level</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">match</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"Calculus::Propositions::is_a_group called on unmatchable"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -759,13 +790,13 @@ and that they may be nested.
|
|||
<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>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP29" class="paragraph-anchor"></a><b>§29. </b>The following removes matched parentheses, leaving just the interior:
|
||||
<p class="commentary firstcommentary"><a id="SP31" class="paragraph-anchor"></a><b>§31. </b>The following removes matched parentheses, leaving just the interior:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::remove_topmost_group</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">Calculus::Propositions::remove_topmost_group</span></span>:<br/><a href="3-prp.html#SP30">§30</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::remove_topmost_group</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">Calculus::Propositions::remove_topmost_group</span></span>:<br/><a href="3-prp.html#SP32">§32</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</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">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><a href="3-prp.html#SP28" class="function-link"><span class="function-syntax">Calculus::Propositions::is_a_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">element</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">prop</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><a href="3-prp.html#SP30" class="function-link"><span class="function-syntax">Calculus::Propositions::is_a_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">element</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">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"tried to remove topmost group which wasn't there"</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">PREDICATE_CALCULUS_WORKINGS</span><span class="plain-syntax">, </span><span class="string-syntax">"ungrouping proposition: $D\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prop</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -775,22 +806,22 @@ and that they may be nested.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP30" class="paragraph-anchor"></a><b>§30. </b>The main application of which is to remove negation:
|
||||
<p class="commentary firstcommentary"><a id="SP32" class="paragraph-anchor"></a><b>§32. </b>The main application of which is to remove negation:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::unnegate</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP28" class="function-link"><span class="function-syntax">Calculus::Propositions::is_a_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP29" class="function-link"><span class="function-syntax">Calculus::Propositions::remove_topmost_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-prp.html#SP30" class="function-link"><span class="function-syntax">Calculus::Propositions::is_a_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP31" class="function-link"><span class="function-syntax">Calculus::Propositions::remove_topmost_group</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP31" class="paragraph-anchor"></a><b>§31. </b>More ambitiously, this removes matched parentheses found at any given
|
||||
<p class="commentary firstcommentary"><a id="SP33" class="paragraph-anchor"></a><b>§33. </b>More ambitiously, this removes matched parentheses found at any given
|
||||
point in a proposition (which can continue after the close bracket).
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::ungroup_after</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">Calculus::Propositions::ungroup_after</span></span>:<br/><a href="3-prp.html#SP32">§32</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> **</span><span class="identifier-syntax">last</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::ungroup_after</span><button class="popup" onclick="togglePopup('usagePopup13')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup13">Usage of <span class="code-font"><span class="function-syntax">Calculus::Propositions::ungroup_after</span></span>:<br/><a href="3-prp.html#SP34">§34</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">position</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> **</span><span class="identifier-syntax">last</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_VARIABLE</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">from</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">opener</span><span class="plain-syntax">, </span><span class="identifier-syntax">closer</span><span class="plain-syntax">, </span><span class="identifier-syntax">level</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -800,9 +831,9 @@ point in a proposition (which can continue after the close bracket).
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">closer</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP5" class="function-link"><span class="function-syntax">Calculus::Atoms::element_get_match</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">opener</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">closer</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"tried to remove frontmost group which doesn't open"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">position</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove opening atom</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">position</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove opening atom</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">from</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="identifier-syntax">closer</span><span class="plain-syntax">) { </span><span class="comment-syntax"> the special case of an empty group</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">position</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove opening atom</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">position</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove opening atom</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">goto</span><span class="plain-syntax"> </span><span class="identifier-syntax">Ungrouped</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">level</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -811,7 +842,7 @@ point in a proposition (which can continue after the close bracket).
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="identifier-syntax">closer</span><span class="plain-syntax">) </span><span class="identifier-syntax">level</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">level</span><span class="plain-syntax"> < </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">last</span><span class="plain-syntax">) *</span><span class="identifier-syntax">last</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove closing atom</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">); </span><span class="comment-syntax"> remove closing atom</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">goto</span><span class="plain-syntax"> </span><span class="identifier-syntax">Ungrouped</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
|
|
@ -821,22 +852,22 @@ point in a proposition (which can continue after the close bracket).
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP32" class="paragraph-anchor"></a><b>§32. </b>Occasionally we want to strip away a "for all", and since that is always
|
||||
<p class="commentary firstcommentary"><a id="SP34" class="paragraph-anchor"></a><b>§34. </b>Occasionally we want to strip away a "for all", and since that is always
|
||||
followed by a domain specification, we must also ungroup this:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="function-syntax">Calculus::Propositions::trim_universal_quantifier</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><a href="3-ap.html#SP8" class="function-link"><span class="function-syntax">Calculus::Atoms::is_for_all_x</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">)) &&</span>
|
||||
<span class="plain-syntax"> (</span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::match</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</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">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP31" class="function-link"><span class="function-syntax">Calculus::Propositions::ungroup_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</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">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> (</span><a href="3-prp.html#SP21" class="function-link"><span class="function-syntax">Calculus::Propositions::match</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">, </span><span class="constant-syntax">QUANTIFIER_ATOM</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">DOMAIN_OPEN_ATOM</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">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP33" class="function-link"><span class="function-syntax">Calculus::Propositions::ungroup_after</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</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">prop</span><span class="plain-syntax"> = </span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">PREDICATE_CALCULUS_WORKINGS</span><span class="plain-syntax">, </span><span class="string-syntax">"Calculus::Propositions::trim_universal_quantifier: $D\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</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">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP33" class="paragraph-anchor"></a><b>§33. </b>Less ambitiously:
|
||||
<p class="commentary firstcommentary"><a id="SP35" class="paragraph-anchor"></a><b>§35. </b>Less ambitiously:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
|
|
@ -846,12 +877,12 @@ followed by a domain specification, we must also ungroup this:
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">TRAVERSE_PROPOSITION</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">element</span><span class="plain-syntax"> == </span><span class="constant-syntax">DOMAIN_CLOSE_ATOM</span><span class="plain-syntax">)) {</span>
|
||||
<span class="plain-syntax"> *</span><span class="identifier-syntax">move_domain</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><a href="3-prp.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-prp.html#SP19" class="function-link"><span class="function-syntax">Calculus::Propositions::delete_atom</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">p_prev</span><span class="plain-syntax">);</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">prop</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP34" class="paragraph-anchor"></a><b>§34. </b>The following routine takes a SP and returns the best proposition it can,
|
||||
<p class="commentary firstcommentary"><a id="SP36" class="paragraph-anchor"></a><b>§36. </b>The following routine takes a SP and returns the best proposition it can,
|
||||
with a single unbound variable, to represent SP.
|
||||
</p>
|
||||
|
||||
|
|
@ -866,13 +897,13 @@ with a single unbound variable, to represent SP.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</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">prop</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax">; </span><span class="comment-syntax"> a propositional form is already made</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_1" class="named-paragraph-link"><span class="named-paragraph">If this is an instance of a kind, but can be used adjectivally, convert it as such</span><span class="named-paragraph-number">34.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_2" class="named-paragraph-link"><span class="named-paragraph">If it's an either-or property name, it must be being used adjectivally</span><span class="named-paragraph-number">34.2</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_3" class="named-paragraph-link"><span class="named-paragraph">It must be an ordinary noun</span><span class="named-paragraph-number">34.3</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_1" class="named-paragraph-link"><span class="named-paragraph">If this is an instance of a kind, but can be used adjectivally, convert it as such</span><span class="named-paragraph-number">36.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_2" class="named-paragraph-link"><span class="named-paragraph">If it's an either-or property name, it must be being used adjectivally</span><span class="named-paragraph-number">36.2</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_3" class="named-paragraph-link"><span class="named-paragraph">It must be an ordinary noun</span><span class="named-paragraph-number">36.3</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
<span class="plain-syntax">#</span><span class="identifier-syntax">endif</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP34_1" class="paragraph-anchor"></a><b>§34.1. </b>For example, if we have written:
|
||||
<p class="commentary firstcommentary"><a id="SP36_1" class="paragraph-anchor"></a><b>§36.1. </b>For example, if we have written:
|
||||
</p>
|
||||
|
||||
<blockquote>
|
||||
|
|
@ -883,7 +914,7 @@ with a single unbound variable, to represent SP.
|
|||
noun, we return the proposition testing it adjectivally: {\it pink}(\(x\)).
|
||||
</p>
|
||||
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If this is an instance of a kind, but can be used adjectivally, convert it as such</span><span class="named-paragraph-number">34.1</span></span><span class="comment-syntax"> =</span>
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If this is an instance of a kind, but can be used adjectivally, convert it as such</span><span class="named-paragraph-number">36.1</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
|
|
@ -892,15 +923,15 @@ noun, we return the proposition testing it adjectivally: {\it pink}(\(x\)).
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pname</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::Conditions::get_coinciding_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">Instances::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pname</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP19" class="function-link"><span class="function-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Instances::get_adjective</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">), </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">34.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">36.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP34">§34</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP34_2" class="paragraph-anchor"></a><b>§34.2. </b>For example, if the SP is "scenery", we return the proposition {\it scenery}(\(x\)).
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP36">§36</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP36_2" class="paragraph-anchor"></a><b>§36.2. </b>For example, if the SP is "scenery", we return the proposition {\it scenery}(\(x\)).
|
||||
</p>
|
||||
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If it's an either-or property name, it must be being used adjectivally</span><span class="named-paragraph-number">34.2</span></span><span class="comment-syntax"> =</span>
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">If it's an either-or property name, it must be being used adjectivally</span><span class="named-paragraph-number">36.2</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
|
|
@ -909,35 +940,35 @@ noun, we return the proposition testing it adjectivally: {\it pink}(\(x\)).
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Properties::is_either_or</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">)) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP19" class="function-link"><span class="function-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</span></a><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Properties::EitherOr::get_aph</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">), </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">34.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">36.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP34">§34</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP34_3" class="paragraph-anchor"></a><b>§34.3. </b>For example, if the SP is the number 17, we return the proposition {\it is}(\(x\), 17).
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP36">§36</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP36_3" class="paragraph-anchor"></a><b>§36.3. </b>For example, if the SP is the number 17, we return the proposition {\it is}(\(x\), 17).
|
||||
</p>
|
||||
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">It must be an ordinary noun</span><span class="named-paragraph-number">34.3</span></span><span class="comment-syntax"> =</span>
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">It must be an ordinary noun</span><span class="named-paragraph-number">36.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="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="3-ap.html#SP21" class="function-link"><span class="function-syntax">Calculus::Atoms::prop_x_is_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Node::duplicate</span><span class="plain-syntax">(</span><span class="identifier-syntax">spec</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP34_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">34.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-prp.html#SP36_1_1" class="named-paragraph-link"><span class="named-paragraph">Typecheck the propositional form, and return</span><span class="named-paragraph-number">36.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP34">§34</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP34_1_1" class="paragraph-anchor"></a><b>§34.1.1. </b>In all cases, we finish by doing the following. In the one-atom noun cases
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP36">§36</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP36_1_1" class="paragraph-anchor"></a><b>§36.1.1. </b>In all cases, we finish by doing the following. In the one-atom noun cases
|
||||
it's a formality, but we want to enforce the rule that all propositions
|
||||
created in Inform go through type-checking, so:
|
||||
</p>
|
||||
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Typecheck the propositional form, and return</span><span class="named-paragraph-number">34.1.1</span></span><span class="comment-syntax"> =</span>
|
||||
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Typecheck the propositional form, and return</span><span class="named-paragraph-number">36.1.1</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Calculus::Propositions::Checker::type_check</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Propositions::Checker::tc_no_problem_reporting</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">prop</span><span class="plain-syntax">;</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP34_1">§34.1</a>, <a href="3-prp.html#SP34_2">§34.2</a>, <a href="3-prp.html#SP34_3">§34.3</a>.</li></ul>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-prp.html#SP36_1">§36.1</a>, <a href="3-prp.html#SP36_2">§36.2</a>, <a href="3-prp.html#SP36_3">§36.3</a>.</li></ul>
|
||||
<nav role="progress"><div class="progresscontainer">
|
||||
<ul class="progressbar"><li class="progressprev"><a href="3-ap.html">❮</a></li><li class="progresschapter"><a href="P-wtmd.html">P</a></li><li class="progresschapter"><a href="1-cm.html">1</a></li><li class="progresschapter"><a href="2-cs.html">2</a></li><li class="progresscurrentchapter">3</li><li class="progresssection"><a href="3-trm.html">trm</a></li><li class="progresssection"><a href="3-ap.html">ap</a></li><li class="progresscurrent">prp</li><li class="progresssection"><a href="3-bas.html">bas</a></li><li class="progressnext"><a href="3-bas.html">❯</a></li></ul></div>
|
||||
</nav><!--End of weave-->
|
||||
|
|
|
|||
|
|
@ -145,14 +145,14 @@ field is
|
|||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. Creating new terms. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::new_variable</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::new_variable</span></span>:<br/><a href="3-trm.html#SP7">§7</a><br/>Atomic Propositions - <a href="3-ap.html#SP7">§7</a>, <a href="3-ap.html#SP19">§19</a>, <a href="3-ap.html#SP21">§21</a><br/>Propositions - <a href="3-prp.html#SP25">§25</a>, <a href="3-prp.html#SP26">§26</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::new_variable</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::new_variable</span></span>:<br/><a href="3-trm.html#SP7">§7</a><br/>Atomic Propositions - <a href="3-ap.html#SP7">§7</a>, <a href="3-ap.html#SP19">§19</a>, <a href="3-ap.html#SP21">§21</a><br/>Propositions - <a href="3-prp.html#SP27">§27</a>, <a href="3-prp.html#SP28">§28</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">v</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">; </span><span class="named-paragraph-container code-font"><a href="3-trm.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Make new blank term structure pt</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">v</span><span class="plain-syntax"> < </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">v</span><span class="plain-syntax"> >= </span><span class="constant-syntax">26</span><span class="plain-syntax">)) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"bad variable term created"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">.</span><span class="element-syntax">variable</span><span class="plain-syntax"> = </span><span class="identifier-syntax">v</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">pt</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::new_constant</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::new_constant</span></span>:<br/><a href="3-trm.html#SP7">§7</a><br/>Compilation Schemas - <a href="2-cs.html#SP6">§6</a>, <a href="2-cs.html#SP8">§8</a><br/>Atomic Propositions - <a href="3-ap.html#SP21">§21</a><br/>Propositions - <a href="3-prp.html#SP26">§26</a><br/>Binding and Substitution - <a href="3-bas.html#SP16">§16</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::new_constant</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::new_constant</span></span>:<br/><a href="3-trm.html#SP7">§7</a><br/>Compilation Schemas - <a href="2-cs.html#SP6">§6</a>, <a href="2-cs.html#SP8">§8</a><br/>Atomic Propositions - <a href="3-ap.html#SP21">§21</a><br/>Propositions - <a href="3-prp.html#SP28">§28</a><br/>Binding and Substitution - <a href="3-bas.html#SP16">§16</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">c</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">; </span><span class="named-paragraph-container code-font"><a href="3-trm.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Make new blank term structure pt</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">.</span><span class="element-syntax">constant</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -225,7 +225,7 @@ at the bottom of which is a constant \(C\); and similarly for variables.
|
|||
<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="function-syntax">Calculus::Terms::variable_underlying</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::variable_underlying</span></span>:<br/>Propositions - <a href="3-prp.html#SP22">§22</a>, <a href="3-prp.html#SP24">§24</a><br/>Binding and Substitution - <a href="3-bas.html#SP3">§3</a>, <a href="3-bas.html#SP9">§9</a>, <a href="3-bas.html#SP14_1">§14.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::variable_underlying</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::variable_underlying</span></span>:<br/>Propositions - <a href="3-prp.html#SP24">§24</a>, <a href="3-prp.html#SP26">§26</a><br/>Binding and Substitution - <a href="3-bas.html#SP3">§3</a>, <a href="3-bas.html#SP9">§9</a>, <a href="3-bas.html#SP14_1">§14.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">t</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">t</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">"null term"</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">t</span><span class="plain-syntax">-></span><span class="identifier-syntax">variable</span><span class="plain-syntax"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax">-></span><span class="element-syntax">variable</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">t</span><span class="plain-syntax">-></span><span class="identifier-syntax">function</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-trm.html#SP6" class="function-link"><span class="function-syntax">Calculus::Terms::variable_underlying</span></a><span class="plain-syntax">(&(</span><span class="identifier-syntax">t</span><span class="plain-syntax">-></span><span class="element-syntax">function</span><span class="plain-syntax">-></span><span class="element-syntax">fn_of</span><span class="plain-syntax">));</span>
|
||||
|
|
@ -245,7 +245,7 @@ again.
|
|||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax">#</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">CORE_MODULE</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::adj_to_noun_conversion</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">Calculus::Terms::adj_to_noun_conversion</span></span>:<br/>Propositions - <a href="3-prp.html#SP26">§26</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">tr</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::adj_to_noun_conversion</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">Calculus::Terms::adj_to_noun_conversion</span></span>:<br/>Propositions - <a href="3-prp.html#SP28">§28</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">tr</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">adjective</span><span class="plain-syntax"> *</span><span class="identifier-syntax">aph</span><span class="plain-syntax"> = </span><a href="2-up.html#SP4" class="function-link"><span class="function-syntax">UnaryPredicates::get_adj</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">tr</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">I</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Adjectives::Meanings::has_ENUMERATIVE_meaning</span><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">I</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><a href="3-trm.html#SP3" class="function-link"><span class="function-syntax">Calculus::Terms::new_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">Rvalues::from_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">));</span>
|
||||
|
|
@ -338,10 +338,10 @@ concisely and without fuss.
|
|||
</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">Calculus::Terms::log</span><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pt</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::log</span><button class="popup" onclick="togglePopup('usagePopup8')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup8">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::log</span></span>:<br/>Calculus Module - <a href="1-cm.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pt</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="3-trm.html#SP10" class="function-link"><span class="function-syntax">Calculus::Terms::write</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DL</span><span class="plain-syntax">, </span><span class="identifier-syntax">pt</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">Calculus::Terms::write</span><button class="popup" onclick="togglePopup('usagePopup8')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup8">Usage of <span class="code-font"><span class="function-syntax">Calculus::Terms::write</span></span>:<br/>Compilation Schemas - <a href="2-cs.html#SP10">§10</a><br/>Atomic Propositions - <a href="3-ap.html#SP24">§24</a>, <a href="3-ap.html#SP24_3">§24.3</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pt</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Calculus::Terms::write</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">Calculus::Terms::write</span></span>:<br/>Compilation Schemas - <a href="2-cs.html#SP10">§10</a><br/>Atomic Propositions - <a href="3-ap.html#SP24">§24</a>, <a href="3-ap.html#SP24_3">§24.3</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pt</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">pt</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">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"<null-term>"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pt</span><span class="plain-syntax">-></span><span class="element-syntax">constant</span><span class="plain-syntax">) {</span>
|
||||
|
|
|
|||
|
|
@ -73,113 +73,9 @@ MathJax = {
|
|||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Services</a></li><li><a href="index.html">calculus</a></li><li><a href="index.html#P">Preliminaries</a></li><li><b>Introduction to Predicate Calculus</b></li></ul></div>
|
||||
<p class="purpose">An exposition of the form of predicate calculus used by Inform.</p>
|
||||
|
||||
<ul class="toc"><li><a href="P-itpc.html#SP2">§2. Why predicate calculus</a></li><li><a href="P-itpc.html#SP4">§4. Formal description</a></li><li><a href="P-itpc.html#SP7">§7. Free and bound variables, well-formedness</a></li><li><a href="P-itpc.html#SP8">§8. The scope of quantifiers</a></li><li><a href="P-itpc.html#SP10">§10. What is not in our calculus</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="P-itpc.html#SP3">§3. Free and bound variables, well-formedness</a></li><li><a href="P-itpc.html#SP4">§4. The scope of quantifiers</a></li><li><a href="P-itpc.html#SP6">§6. What is not in our calculus</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b>"Again and again Haddon thought he had found the key to the strange writings,
|
||||
but always he was disappointed. And then one day — he was an old man of seventy
|
||||
now — he fed a trial programme into his computer, and for the first time a
|
||||
translated sentence was delivered — his life-long task was rewarded. Yes,
|
||||
but for the fact that one man had been prepared to devote every spare hour of
|
||||
his life to solving the riddle, the amazing story of the Trigan Empire would
|
||||
never have been given to the world. WHAT FOLLOWS IS THAT STORY."
|
||||
("The Rise and Fall of the Trigan Empire", 1965)
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. Why predicate calculus. </b>Most attempts to codify the meaning of sentences in any systematic way
|
||||
involve predicate calculus, and most people generally seem to agree
|
||||
that linguistic concepts (like verbs, adjectives, and determiners)
|
||||
correspond uncannily well with logical ones (like binary predicates,
|
||||
unary predicates, and quantifiers). Since today's mathematical logic
|
||||
has its roots in work on the philosophy of language (chiefly by Frege and
|
||||
Wittgenstein), this is not altogether a coincidence. All the same, it is
|
||||
striking how good the fit is, considering that human language is so
|
||||
haphazard and logic so regular.
|
||||
</p>
|
||||
|
||||
<p class="commentary">At any rate Inform goes along with this consensus, and converts the
|
||||
difficult passages in its source text into mathematical propositions
|
||||
— lines written in logical notation. This is useful partly as a
|
||||
well-defined way to store complicated meanings inside the program, but
|
||||
also because these propositions can then be simplified by logical
|
||||
rules. We can change their form so long as we do not change their
|
||||
meaning, in the hope of finding ways to carry out the same tasks but
|
||||
more efficiently than a simple-minded reading of the text would
|
||||
suggest.
|
||||
</p>
|
||||
|
||||
<p class="commentary">There are four main tasks to perform:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>(a) Building propositions from the other Inform data structures;
|
||||
</li><li>(b) Simplifying, rearranging and type-checking propositions;
|
||||
</li><li>(c) Asserting that certain propositions are true at the start of play;
|
||||
</li><li>(d) Compiling certain propositions to I6 code which can test them, make them
|
||||
true, or make them false.
|
||||
</li></ul>
|
||||
<p class="commentary">In this chapter, we take these tasks in order. Because it contains all
|
||||
of Inform's predicate calculus lore in one place, it necessarily contains
|
||||
little pieces of algorithms from other chapters: a piece of the
|
||||
type-checker, a piece of the code for asserting the initial state of
|
||||
play, and so on. Well: but the overlap had to go somewhere.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b>A glimpse of Inform's inner workings can be made by writing a test
|
||||
instruction like so:
|
||||
</p>
|
||||
|
||||
<blockquote>
|
||||
<p>Laboratory is a room. The box is a container.</p>
|
||||
</blockquote>
|
||||
|
||||
<blockquote>
|
||||
<p>Test sentence (internal) with a man can see the box in the Laboratory.</p>
|
||||
</blockquote>
|
||||
|
||||
<p class="commentary">At the start of play, the compiled story file will print a textual form of
|
||||
the proposition in predicate calculus which that became:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> 1. a man can see the box in the Laboratory</span>
|
||||
<span class="plain-syntax"> [ Exists x : man(x) & thing('box') & is('laboratory', ContainerOf('box')) & can-see(x, 'box') ]</span>
|
||||
<span class="plain-syntax"> x - object.</span>
|
||||
</pre>
|
||||
<p class="commentary">(The <span class="extract"><span class="extract-syntax">intest</span></span> test case <span class="extract"><span class="extract-syntax">Calculus</span></span> runs about 200 sentences like this.)
|
||||
One can similarly "Test description (internal) with..." for any description,
|
||||
such as "animals which are in lighted rooms".
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. Formal description. </b>There are many flavours of predicate calculus, and though they behave in
|
||||
broadly similar ways, the details vary in practice. Inform's calculus
|
||||
is unusual in several respects, so here is its definition.
|
||||
</p>
|
||||
|
||||
<p class="commentary">The terms "constant", "variable" and "function" below are used in
|
||||
their predicate-calculus senses, not their Inform ones. In the excerpt
|
||||
</p>
|
||||
|
||||
<blockquote>
|
||||
<p>a container in the location of Nicole contains the second noun</p>
|
||||
</blockquote>
|
||||
|
||||
<p class="commentary">the text "location of Nicole" is a phrase deciding an object — a function —
|
||||
and "the second noun" is an object that varies — a variable. But if we are
|
||||
looking at the sentence only for its logical meaning, we have to forget about
|
||||
the passage of time and think about what the sentence means at any single
|
||||
moment. "Location of Nicole" and "the second noun" are both fixed, in
|
||||
this instant; the only thing which varies is the identity of the possible
|
||||
container, because we might have to look at hundreds of different containers
|
||||
to see if the sentence is true. One logical translation might be
|
||||
$$ \exists x: {\it container}(x)\land {\it in}(x, C_1) \land {\it in}(C_2, x) $$
|
||||
where \(C_1\) and \(C_2\) are constants ("location of Nicole" and "second noun"
|
||||
respectively), while the only variable is \(x\), the mysterious container.
|
||||
(The symbol \(\exists\) means "there exists".) Because objects move
|
||||
around in play, and \(C_1\) and \(C_2\) have different values at different
|
||||
moments, this sentence is sometimes true and sometimes false. But its
|
||||
meaning does not change.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>§5. </b>The propositions in our predicate calculus are those which can be made
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b>The propositions in our predicate calculus are those which can be made
|
||||
using the following ingredients and recipes.
|
||||
</p>
|
||||
|
||||
|
|
@ -316,7 +212,7 @@ proposition \(\phi\) in which \(v\) is a "free" variable (see below),
|
|||
possible values of \(v\) matching the condition \(\phi(v)\), and this specifies
|
||||
the range of the quantifier.
|
||||
</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>§6. </b>Note that there are two ways in which propositions can appear in brackets
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. </b>Note that there are two ways in which propositions can appear in brackets
|
||||
in a bigger proposition: negation (d), and specifying a quantification
|
||||
domain (g). We sometimes call the bracketed part a "subexpression" of the
|
||||
whole.
|
||||
|
|
@ -354,7 +250,7 @@ $$ \exists x: {\it number}(x)\land {\it even}(x) $$
|
|||
specifies a domain for a \(\exists\) quantifier.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>§7. Free and bound variables, well-formedness. </b>In any proposition \(\phi\), we say that a variable \(v\) is "bound" if it
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. Free and bound variables, well-formedness. </b>In any proposition \(\phi\), we say that a variable \(v\) is "bound" if it
|
||||
appears as the variable governed by a quantifier: it is "free" if it
|
||||
does appear somewhere in \(\phi\) — either directly as a term or indirectly
|
||||
through a function application — and is not bound. For instance, in
|
||||
|
|
@ -379,7 +275,7 @@ $$ \lnot ( \exists v : {\it closed}(v) ) \land {\it openable}(v) $$
|
|||
case, outside the negation brackets).
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>§8. The scope of quantifiers. </b>A quantifier introduces a variable into a proposition which would not
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. The scope of quantifiers. </b>A quantifier introduces a variable into a proposition which would not
|
||||
otherwise be there, and it exists only for a limited range. For instance, in
|
||||
the proposition
|
||||
$$ {\it open}(x)\land\lnot(\exists y: {\it in}(x, y))\land {\it container}(x) $$
|
||||
|
|
@ -391,7 +287,7 @@ which it is created. If the quantifier is outside of any brackets, then the
|
|||
variable lasts until the end of the proposition.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>§9. </b>Earlier drafts of Inform played games with moving quantifiers around, in
|
||||
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>§5. </b>Earlier drafts of Inform played games with moving quantifiers around, in
|
||||
order to try to achieve more efficiently compiled propositions. The same
|
||||
thing is now done by building propositions in a way which places quantifiers
|
||||
as far forwards as possible, so we no longer actively move them once they
|
||||
|
|
@ -416,7 +312,7 @@ only be satisfied if at least one case of \(x\) works, and here every case of
|
|||
the same evaluation in this case, too.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>§10. What is not in our calculus. </b>The significant thing missing is disjunction. In general, the
|
||||
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>§6. What is not in our calculus. </b>The significant thing missing is disjunction. In general, the
|
||||
disjunction \(\phi\lor\psi\) — "at least one of \(\phi\) and \(\psi\)
|
||||
holds" — is not a proposition.
|
||||
</p>
|
||||
|
|
|
|||
|
|
@ -12,6 +12,25 @@
|
|||
<link href="../docs-assets/Navigation.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
<link href="../docs-assets/Fonts.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
<link href="../docs-assets/Base.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
<script src="http://code.jquery.com/jquery-1.12.4.min.js"
|
||||
integrity="sha256-ZosEbRLbNQzLpnKIkEdrPv7lOy9C27hHQ+Xp8a4MxAQ=" crossorigin="anonymous"></script>
|
||||
|
||||
<script src="../docs-assets/Bigfoot.js"></script>
|
||||
<link href="../docs-assets/Bigfoot.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
<script>
|
||||
MathJax = {
|
||||
tex: {
|
||||
inlineMath: '$', '$'], ['\\(', '\\)'
|
||||
},
|
||||
svg: {
|
||||
fontCache: 'global'
|
||||
}
|
||||
};
|
||||
</script>
|
||||
<script type="text/javascript" id="MathJax-script" async
|
||||
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js">
|
||||
</script>
|
||||
|
||||
<link href="../docs-assets/Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
|
||||
</head>
|
||||
|
|
@ -59,7 +78,7 @@
|
|||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Services</a></li><li><a href="index.html">calculus</a></li><li><a href="index.html#P">Preliminaries</a></li><li><b>What This Module Does</b></li></ul></div>
|
||||
<p class="purpose">An overview of the calculus module's role and abilities.</p>
|
||||
|
||||
<ul class="toc"><li><a href="P-wtmd.html#SP1">§1. Prerequisites</a></li><li><a href="P-wtmd.html#SP2">§2. Notation</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="P-wtmd.html#SP1">§1. Prerequisites</a></li><li><a href="P-wtmd.html#SP2">§2. What predicate calculus is</a></li><li><a href="P-wtmd.html#SP3">§3. Notation</a></li><li><a href="P-wtmd.html#SP4">§4. Formal description</a></li><li><a href="P-wtmd.html#SP6">§6. Unary predicates</a></li><li><a href="P-wtmd.html#SP7">§7. Binary predicates</a></li><li><a href="P-wtmd.html#SP8">§8. Making propositions</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. Prerequisites. </b>The calculus module is a part of the Inform compiler toolset. It is
|
||||
presented as a literate program or "web". Before diving in:
|
||||
|
|
@ -75,22 +94,60 @@ and where functions have names like <span class="extract"><span class="extract-s
|
|||
uses a module of utility functions called <a href="../../../inweb/docs/foundation-module/index.html" class="internal">foundation</a>.
|
||||
For more, see <a href="../../../inweb/docs/foundation-module/P-abgtf.html" class="internal">A Brief Guide to Foundation (in foundation)</a>.
|
||||
</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. Notation. </b>This module deals with propositions in predicate calculus, that is, with
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. What predicate calculus is. </b>The word "calculus" is often used to mean differentiating and integrating
|
||||
functions, but properly speaking that is "infinitesimal calculus", and there
|
||||
are many others.<sup id="fnref:1"><a href="#fn:1" rel="footnote">1</a></sup> In logic, different sets of rules for making deductions
|
||||
tend to be given such names, and we will use (a form of) one of the most
|
||||
popular simple systems, "predicate calculus".<sup id="fnref:2"><a href="#fn:2" rel="footnote">2</a></sup>
|
||||
</p>
|
||||
|
||||
<p class="commentary">Most attempts to codify the meaning of sentences in any systematic way involve
|
||||
predicate calculus, and most people generally seem to agree that linguistic
|
||||
concepts (like verbs, adjectives, and determiners) correspond uncannily well
|
||||
with logical ones (like binary predicates, unary predicates, and quantifiers).<sup id="fnref:3"><a href="#fn:3" rel="footnote">3</a></sup>
|
||||
All the same, it is striking how good the fit is, considering that human language
|
||||
is so haphazard at first sight.
|
||||
</p>
|
||||
|
||||
<p class="commentary">At any rate Inform goes along with this consensus, and converts the difficult
|
||||
passages in its source text into logical "propositions" — lines written in
|
||||
logical notation. This is useful partly as a tidy way to store complicated
|
||||
meanings inside the program, but also because these propositions can then be
|
||||
simplified by logical rules, without changing their meaning. Without such
|
||||
simplifications, Inform would generate much less efficient code.
|
||||
</p>
|
||||
|
||||
<ul class="footnotetexts"><li class="footnote" id="fn:1"><p class="inwebfootnote"><sup id="fnref:1"><a href="#fn:1" rel="footnote">1</a></sup> At time of writing, <a href="https://en.wikipedia.org/wiki/Calculus_(disambiguation)" class="external">nearly 40 can be found here</a>,
|
||||
though admittedly that includes a genus of spider and a Tintin character.
|
||||
<a href="#fnref:1" title="return to text"> ↩</a></p></li><li class="footnote" id="fn:2"><p class="inwebfootnote"><sup id="fnref:2"><a href="#fn:2" rel="footnote">2</a></sup> Specifically, first order predicate calculus with equality, but with
|
||||
generalised quantifiers added, and disjunction removed.
|
||||
<a href="#fnref:2" title="return to text"> ↩</a></p></li><li class="footnote" id="fn:3"><p class="inwebfootnote"><sup id="fnref:3"><a href="#fn:3" rel="footnote">3</a></sup> This is not altogether a coincidence since the pioneers of mathematical
|
||||
logic, and in particular Frege and Wittgenstein, began by thinking about
|
||||
natural language.
|
||||
<a href="#fnref:3" title="return to text"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. Notation. </b>This module deals with propositions in predicate calculus, that is, with
|
||||
logical statements which are normally written in mathematical notation. To
|
||||
the end user of Inform, these are invisible: they exist only inside the
|
||||
compiler and are never typed in or printed out. But for the debugging log,
|
||||
for unit testing, and for the literate source, we need to do both of these.
|
||||
</p>
|
||||
|
||||
<p class="commentary">The following demonstrates the notation being read in, and then written back
|
||||
out, by the <a href="../calculus-test/index.html" class="internal">calculus-test</a> module. As with <a href="../kinds-test/index.html" class="internal">kinds-test</a>, this is a REPL:
|
||||
a read-evaluate-print-loop tool, which reads in calculations, performs them,
|
||||
and prints the result. Here, the "calculations" consist only of being told
|
||||
exactly what the proposition is, and then printing it back.
|
||||
<p class="commentary">A glimpse of the propositions generated by Inform can be had by running this
|
||||
test, whose output uses our notation:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">Laboratory</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">a</span><span class="plain-syntax"> </span><span class="identifier-syntax">room</span><span class="plain-syntax">. </span><span class="identifier-syntax">The</span><span class="plain-syntax"> </span><span class="identifier-syntax">box</span><span class="plain-syntax"> </span><span class="identifier-syntax">is</span><span class="plain-syntax"> </span><span class="identifier-syntax">a</span><span class="plain-syntax"> </span><span class="identifier-syntax">container</span><span class="plain-syntax">.</span>
|
||||
<span class="identifier-syntax">Test</span><span class="plain-syntax"> </span><span class="identifier-syntax">sentence</span><span class="plain-syntax"> (</span><span class="identifier-syntax">internal</span><span class="plain-syntax">) </span><span class="identifier-syntax">with</span><span class="plain-syntax"> </span><span class="identifier-syntax">a</span><span class="plain-syntax"> </span><span class="identifier-syntax">man</span><span class="plain-syntax"> </span><span class="identifier-syntax">can</span><span class="plain-syntax"> </span><span class="identifier-syntax">see</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">box</span><span class="plain-syntax"> </span><span class="identifier-syntax">in</span><span class="plain-syntax"> </span><span class="identifier-syntax">the</span><span class="plain-syntax"> </span><span class="identifier-syntax">Laboratory</span><span class="plain-syntax">.</span>
|
||||
<span class="identifier-syntax">Test</span><span class="plain-syntax"> </span><span class="identifier-syntax">description</span><span class="plain-syntax"> (</span><span class="identifier-syntax">internal</span><span class="plain-syntax">) </span><span class="identifier-syntax">with</span><span class="plain-syntax"> </span><span class="identifier-syntax">animals</span><span class="plain-syntax"> </span><span class="identifier-syntax">which</span><span class="plain-syntax"> </span><span class="identifier-syntax">are</span><span class="plain-syntax"> </span><span class="identifier-syntax">in</span><span class="plain-syntax"> </span><span class="identifier-syntax">lighted</span><span class="plain-syntax"> </span><span class="identifier-syntax">rooms</span><span class="plain-syntax">.</span>
|
||||
</pre>
|
||||
<p class="commentary">But a much easier way to test the functions in this module is to use the
|
||||
<a href="../calculus-test/index.html" class="internal">calculus-test</a> tool. As with <a href="../kinds-test/index.html" class="internal">kinds-test</a>, this is a REPL: that is,
|
||||
a read-evaluate-print-loop tool, which reads in calculations, performs them,
|
||||
and prints the result.
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">new unary blue</span><span class="plain-syntax">':</span><span class="string-syntax"> ok</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< >></span><span class="plain-syntax">':</span><span class="string-syntax"> << >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< is-a-kind (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << is-a-kind(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< is-a-var (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << is-a-var(x) >></span>
|
||||
|
|
@ -105,11 +162,190 @@ exactly what the proposition is, and then printing it back.
|
|||
<span class="plain-syntax">'</span><span class="element-syntax"><< (x == y) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << (x == y) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">new binary sees</span><span class="plain-syntax">':</span><span class="string-syntax"> ok</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< sees (x, y) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << sees(x, y) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< NOT< ^ blue (x) ^ NOT> >></span><span class="plain-syntax">':</span><span class="string-syntax"> << NOT< blue(x) NOT> >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Forall x IN< kind = number (x) IN>: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << ForAll x IN< kind=number(x) IN> : blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Exists x >></span><span class="plain-syntax">':</span><span class="string-syntax"> << Exists x >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< ForAll x >></span><span class="plain-syntax">':</span><span class="string-syntax"> << ForAll x >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< kind = number (x) ^ blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << kind=number(x) ^ blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Exists x: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << Exists x : blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< ForAll x: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << ForAll x : blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< DoesNotExist x IN< kind = number (x) IN>: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << DoesNotExist x IN< kind=number(x) IN> : blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Forall x IN< kind = number (x) IN>: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << ForAll x IN< kind=number(x) IN> : blue(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Card= 6 x IN< kind = number (x) IN>: blue (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> << Card=6 x IN< kind=number(x) IN> : blue(x) >></span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. Formal description. </b>1. A "term" is any of the following:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● A constant, corresponding to anything which can be evaluated to Inform —
|
||||
a number, a text, etc. — and which has a definite kind.
|
||||
</li><li>● One of 26 variables, which we print to the debugging log as <span class="extract"><span class="extract-syntax">x</span></span>, <span class="extract"><span class="extract-syntax">y</span></span>,
|
||||
<span class="extract"><span class="extract-syntax">z</span></span>, <span class="extract"><span class="extract-syntax">a</span></span>, <span class="extract"><span class="extract-syntax">b</span></span>, <span class="extract"><span class="extract-syntax">c</span></span>, ..., <span class="extract"><span class="extract-syntax">w</span></span>.
|
||||
</li><li>● A function \(f\) applied to another term.<sup id="fnref:4"><a href="#fn:4" rel="footnote">4</a></sup>
|
||||
</li></ul>
|
||||
<p class="commentary">Note that if we have given values to the necessary variables, then any term
|
||||
can be evaluated to a value, and its kind determined. For example, if <span class="extract"><span class="extract-syntax">x</span></span> is 7,
|
||||
then the terms <span class="extract"><span class="extract-syntax">17</span></span>, <span class="extract"><span class="extract-syntax">x</span></span> and <span class="extract"><span class="extract-syntax">f(x)</span></span> evaluate to 17, 7 and \(f(7)\) respectively.
|
||||
</p>
|
||||
|
||||
<p class="commentary">2. An "atomic proposition" is any of the following:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● A "unary predicate" \(U(t)\), where \(t\) is a term, which is either true or
|
||||
false depending on the evaluation of \(t\).
|
||||
</li><li>● A "binary predicate" \(B(t_1, t_2)\) depending on two terms.<sup id="fnref:5"><a href="#fn:5" rel="footnote">5</a></sup>
|
||||
</li><li>● A "quantifier" \(Q(v, n)\) applying to a variable \(v\), optionally with a
|
||||
parameter \(n\). See <a href="../linguistics-module/2-daq.html" class="internal">Determiners and Quantifiers (in linguistics)</a> for the range
|
||||
of quantifiers available.
|
||||
</li></ul>
|
||||
<p class="commentary">3. A "proposition" is a sequence of 0 or more of the following:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● A conjunction \(P_1\land P_2\), where \(P_1\) and \(P_2\) are propositions.
|
||||
</li><li>● A negation \(\lnot P\), where \(P\) is a proposition.
|
||||
</li><li>● A quantification \(Q v\in D: P\), where \(Q\) is a quantifier, optionally
|
||||
also with a numerical parameter, \(v\) is a variable, \(D\) is a set
|
||||
specifying the domain of \(v\), and \(P\) is a proposition.<sup id="fnref:6"><a href="#fn:6" rel="footnote">6</a></sup>
|
||||
</li><li>● An existential quantification \(\exists v: P\) without a domain.
|
||||
</li></ul>
|
||||
<ul class="footnotetexts"><li class="footnote" id="fn:4"><p class="inwebfootnote"><sup id="fnref:4"><a href="#fn:4" rel="footnote">4</a></sup> In this module we use words such as "constant", "variable" and "function" in
|
||||
their predicate-calculus senses, not their Inform ones. For example, if we are
|
||||
to decide whether it is true that "a container in the location of Nicole contains
|
||||
the prize", we have to forget about the passage of time and think only about a
|
||||
single moment. In the resultant proposition, "the location of Nicole" and
|
||||
"the prize" lead to constant terms, "a container" leads to a variable term (since
|
||||
we do not know its identity) and there are no functions.
|
||||
<a href="#fnref:4" title="return to text"> ↩</a></p></li><li class="footnote" id="fn:5"><p class="inwebfootnote"><sup id="fnref:5"><a href="#fn:5" rel="footnote">5</a></sup> We do not support higher arities of predicates as such, but they can be
|
||||
simulated. The universal relation in Inform is in effect a ternary predicate,
|
||||
but is achieved by combining two of its terms into an ordered pair.
|
||||
<a href="#fnref:5" title="return to text"> ↩</a></p></li><li class="footnote" id="fn:6"><p class="inwebfootnote"><sup id="fnref:6"><a href="#fn:6" rel="footnote">6</a></sup> Some quantifiers also carry a numerical parameter, to express, e.g.,
|
||||
"at least 7" — the parameter for that being 7.
|
||||
<a href="#fnref:6" title="return to text"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>§5. </b>The implementation uses the term "atom" a little more loosely, to include
|
||||
four punctuation marks: <span class="extract"><span class="extract-syntax">NOT<</span></span>, <span class="extract"><span class="extract-syntax">NOT></span></span>, <span class="extract"><span class="extract-syntax">IN<</span></span>, <span class="extract"><span class="extract-syntax">IN></span></span>, which act like
|
||||
opening and closing parentheses. These are considered atoms purely for
|
||||
convenience when building more complicated constructions — they make no sense
|
||||
standing alone. Thus:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● \(\lnot P\) is implemented as <span class="extract"><span class="extract-syntax">NOT< P NOT></span></span>.
|
||||
</li><li>● \(Q v\in D: P\) is implemented as <span class="extract"><span class="extract-syntax">Q IN< D IN></span></span>.
|
||||
</li></ul>
|
||||
<p class="commentary">Note that the domain \(D\) of a quantifier is itself expressed as a proposition.
|
||||
Thus "for all numbers \(n\)" is implemented as <span class="extract"><span class="extract-syntax">ForAll n IN< kind=number(n) IN></span></span>.
|
||||
</p>
|
||||
|
||||
<p class="commentary">In all other cases, adjacent atoms in a sequence are considered to be conjoined:
|
||||
i.e., <span class="extract"><span class="extract-syntax">X Y</span></span> means \(X\land Y\), the proposition which is true if \(X\) and \(Y\) are
|
||||
both true. To emphasise this, the textual notation uses the <span class="extract"><span class="extract-syntax">^</span></span> sign. For
|
||||
example, <span class="extract"><span class="extract-syntax">odd(n) ^ prime(n)</span></span> is the notation for two consecutive atoms <span class="extract"><span class="extract-syntax">odd(n)</span></span>
|
||||
and <span class="extract"><span class="extract-syntax">prime(n)</span></span>.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP6" class="paragraph-anchor"></a><b>§6. Unary predicates. </b>We have a mixed bag of unary predicates, as follows.
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● For each adjective defined in the <a href="../linguistics-module/index.html" class="internal">linguistics</a> module, there is a
|
||||
predicate <span class="extract"><span class="extract-syntax">A(t)</span></span>, true if the adjective currently applies to \(t\).
|
||||
</li><li>● For each kind \(K\), there is a predicate <span class="extract"><span class="extract-syntax">kind=K(t)</span></span>, which is true if \(t\)
|
||||
is of the kind \(K\).
|
||||
</li><li>● For any wording <span class="extract"><span class="extract-syntax">W</span></span>, there is a predicate <span class="extract"><span class="extract-syntax">called=W(t)</span></span>, which is asserts
|
||||
that the current value of \(t\) is something with the name <span class="extract"><span class="extract-syntax">W</span></span>.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">is-a-kind(t)</span></span> asserts that \(t\) represents a kind, not a value.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">is-a-var(t)</span></span> asserts that \(t\) represents a variable, not a value.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">is-a-const(t)</span></span> asserts that \(t\) represents a constant, not a value.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">everywhere(t)</span></span> asserts that \(t\) is an object found everywhere.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">nowhere(t)</span></span> asserts that \(t\) is an object found nowhere.
|
||||
</li><li>● <span class="extract"><span class="extract-syntax">here(t)</span></span> asserts that \(t\) is an object found in the current room.
|
||||
</li></ul>
|
||||
<p class="commentary">As is apparent, the <span class="extract"><span class="extract-syntax">is-a-...</span></span> predicates are a cheat: they exist purely to
|
||||
make it easier to write propositions which change the state of the world,
|
||||
rather than discuss that state. For example, Inform might create the kind
|
||||
"animal" by asserting <span class="extract"><span class="extract-syntax">Exists x : is-a-kind(x) ^ called=animal(x)</span></span>.
|
||||
</p>
|
||||
|
||||
<p class="commentary">Otherwise, while these are all conceptually unary predicates, only the first
|
||||
is a <span class="extract"><span class="extract-syntax">PREDICATE_ATOM</span></span> in our implementation: the others are <span class="extract"><span class="extract-syntax">KIND_ATOM</span></span>,
|
||||
<span class="extract"><span class="extract-syntax">CALLED_ATOM</span></span>,
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>§7. Binary predicates. </b>By contrast all binary predicate atoms use <span class="extract"><span class="extract-syntax">PREDICATE_ATOM</span></span>, and there is only
|
||||
one set of them — but with that said,
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>(a) They can be organised into "families" with shared implementations — see
|
||||
<a href="2-bpf.html" class="internal">Binary Predicate Families</a>.
|
||||
</li><li>(b) The equality predicate \(=\) is predefined by the <a href="index.html" class="internal">calculus</a> module, and
|
||||
its special meaning is used when simplifying propositions. See <a href="2-ter.html" class="internal">The Equality Relation</a>.
|
||||
It is written with the special notation <span class="extract"><span class="extract-syntax">(x == y)</span></span>, though this is just syntactic
|
||||
sugar.
|
||||
</li></ul>
|
||||
<p class="commentary">New BPs can be constructed with <a href="2-bp.html#SP26" class="internal">BinaryPredicates::make_pair</a>. The term "pair"
|
||||
is used because every \(B\) has a "reversal" \(B^r\), such that \(B^r(s, t)\) is true
|
||||
if and only if \(B(t, s)\). \(B\) and \(B^r\) are created in pairs.<sup id="fnref:7"><a href="#fn:7" rel="footnote">7</a></sup>
|
||||
</p>
|
||||
|
||||
<ul class="footnotetexts"><li class="footnote" id="fn:7"><p class="inwebfootnote"><sup id="fnref:7"><a href="#fn:7" rel="footnote">7</a></sup> Except for equality, which is its own reversal. See <a href="2-bp.html#SP25" class="internal">BinaryPredicates::make_equality</a>.
|
||||
<a href="#fnref:7" title="return to text"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>§8. Making propositions. </b>Propositions are built incrementally, like Lego, with a sequence of function
|
||||
calls.
|
||||
</p>
|
||||
|
||||
<p class="commentary">1. Terms are made using the functions <a href="3-trm.html#SP3" class="internal">Calculus::Terms::new_constant</a>,
|
||||
<a href="3-trm.html#SP3" class="internal">Calculus::Terms::new_variable</a> and <a href="3-trm.html#SP3" class="internal">Calculus::Terms::new_function</a>.
|
||||
</p>
|
||||
|
||||
<p class="commentary">2. Unary predicate atoms are made using:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● <a href="3-ap.html#SP19" class="internal">Calculus::Atoms::unary_PREDICATE_from_aph_term</a>, or
|
||||
</li><li>● <a href="3-ap.html#SP17" class="internal">Calculus::Atoms::KIND_new</a>, or
|
||||
</li><li>● <a href="3-ap.html#SP16" class="internal">Calculus::Atoms::CALLED_new</a>, or
|
||||
</li><li>● <a href="3-ap.html#SP6" class="internal">Calculus::Atoms::new</a> for the six oddball unaries,
|
||||
supplying atom types <span class="extract"><span class="extract-syntax">ISAKIND_ATOM</span></span>, <span class="extract"><span class="extract-syntax">ISAVAR_ATOM</span></span>, <span class="extract"><span class="extract-syntax">ISACONST_ATOM</span></span>,
|
||||
<span class="extract"><span class="extract-syntax">EVERYWHERE_ATOM</span></span>, <span class="extract"><span class="extract-syntax">NOWHERE_ATOM</span></span> and <span class="extract"><span class="extract-syntax">HERE_ATOM</span></span>.
|
||||
</li></ul>
|
||||
<p class="commentary">Binary predicate atoms are made using <a href="3-ap.html#SP20" class="internal">Calculus::Atoms::binary_PREDICATE_new</a>.
|
||||
</p>
|
||||
|
||||
<p class="commentary">3. Propositions are then built up from atoms or other propositions<sup id="fnref:8"><a href="#fn:8" rel="footnote">8</a></sup> by calling:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● <a href="3-prp.html#SP15" class="internal">Calculus::Propositions::conjoin</a>.
|
||||
</li><li>● <a href="3-prp.html#SP16" class="internal">Calculus::Propositions::negate</a>.
|
||||
</li><li>● <a href="3-prp.html#SP17" class="internal">Calculus::Propositions::quantify</a>.
|
||||
</li></ul>
|
||||
<ul class="footnotetexts"><li class="footnote" id="fn:8"><p class="inwebfootnote"><sup id="fnref:8"><a href="#fn:8" rel="footnote">8</a></sup> But beware that propositions are passed by reference not value. Use
|
||||
<a href="3-prp.html#SP13" class="internal">Calculus::Propositions::copy</a> before changing one, if you need to use it
|
||||
again.
|
||||
<a href="#fnref:8" title="return to text"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>§9. </b>There are two senses in which it's possible to make an impossible proposition:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>(1) You could make a mess of the punctuation markers improperly, or fail to
|
||||
give a domain set for a quantifier.
|
||||
</li><li>(2) More subtly, you could concatenate two propositions in which the same
|
||||
variable is used with a different meaning in each.
|
||||
</li></ul>
|
||||
<p class="commentary">The functions <a href="3-prp.html#SP11" class="internal">Calculus::Propositions::is_syntactically_valid</a> and
|
||||
<a href="3-bas.html#SP4" class="internal">Calculus::Variables::is_well_formed</a> test that (1) and (2) have not happened.
|
||||
It's because of (2) that it's important to use <a href="3-prp.html#SP15" class="internal">Calculus::Propositions::conjoin</a>
|
||||
and not the simpler <a href="3-prp.html#SP14" class="internal">Calculus::Propositions::concatenate</a>.
|
||||
</p>
|
||||
|
||||
<p class="commentary">To illustrate:
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">new unary even</span><span class="plain-syntax">':</span><span class="string-syntax"> ok</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< NOT> >> is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> false - too many close groups</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Exists x >> is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< ForAll x >> is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> false - ends without domain of final quantifier</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< ForAll x IN< kind = number (x) IN>: even (x) >> is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax"><< Forall x IN< kind = number (x) IN>: even (x) >> is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">set A to << Exists x >></span><span class="plain-syntax">':</span><span class="string-syntax"> a set to << Exists x >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">set B to << Exists x: even (x) >></span><span class="plain-syntax">':</span><span class="string-syntax"> b set to << Exists x : even(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A concatenate B</span><span class="plain-syntax">':</span><span class="string-syntax"> << Exists x : Exists x : even(x) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A conjoin B</span><span class="plain-syntax">':</span><span class="string-syntax"> << Exists x : Exists y : even(y) >></span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A concatenate B is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A conjoin B is syntactically valid</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A concatenate B is well-formed</span><span class="plain-syntax">':</span><span class="string-syntax"> false - x used outside its binding</span>
|
||||
<span class="plain-syntax">'</span><span class="element-syntax">A conjoin B is well-formed</span><span class="plain-syntax">':</span><span class="string-syntax"> true</span>
|
||||
</pre>
|
||||
<nav role="progress"><div class="progresscontainer">
|
||||
<ul class="progressbar"><li class="progressprevoff">❮</li><li class="progresscurrentchapter">P</li><li class="progresscurrent">wtmd</li><li class="progresssection"><a href="P-htitm.html">htitm</a></li><li class="progresssection"><a href="P-itpc.html">itpc</a></li><li class="progresschapter"><a href="1-cm.html">1</a></li><li class="progresschapter"><a href="2-cs.html">2</a></li><li class="progresschapter"><a href="3-trm.html">3</a></li><li class="progressnext"><a href="P-htitm.html">❯</a></li></ul></div>
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ function togglePopup(material_id) {
|
|||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../units.html">Unit Test Tools</a></li><li><a href="index.html">calculus-test</a></li><li><a href="index.html#1">Chapter 1: Scaffolding</a></li><li><b>Declarations</b></li></ul></div>
|
||||
<p class="purpose">Reading declarations from a file.</p>
|
||||
|
||||
<ul class="toc"><li><a href="1-dcl.html#SP1">§1. Keeping the syntax module happy</a></li><li><a href="1-dcl.html#SP2">§2. A sort of REPL</a></li></ul><hr class="tocbar">
|
||||
<ul class="toc"><li><a href="1-dcl.html#SP1">§1. Keeping the syntax module happy</a></li><li><a href="1-dcl.html#SP2">§2. REPL variables</a></li><li><a href="1-dcl.html#SP3">§3. A sort of REPL</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. Keeping the syntax module happy. </b>We are going to need to use the sentence-breaking apparatus from the <a href="../syntax-module/index.html" class="internal">syntax</a>
|
||||
module, which means that the following four nonterminals need to exist. But in
|
||||
|
|
@ -76,7 +76,42 @@ match any text.
|
|||
<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"> { fail }</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="SP2" class="paragraph-anchor"></a><b>§2. A sort of REPL. </b>The following function reads a file whose name is in <span class="extract"><span class="Preform-extract-syntax">arg</span></span>, feeds it into
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. REPL variables. </b></p>
|
||||
|
||||
<pre class="definitions code-font"><span class="definition-keyword">enum</span> <span class="Preform-constant-syntax">repl_var_CLASS</span>
|
||||
</pre>
|
||||
<pre class="Preform-displayed-code all-displayed-code code-font">
|
||||
<span class="Preform-identifier-syntax">DECLARE_CLASS</span><span class="Preform-plain-syntax">(</span><span class="Preform-reserved-syntax">repl_var</span><span class="Preform-plain-syntax">)</span>
|
||||
|
||||
<span class="Preform-reserved-syntax">typedef</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">struct</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">repl_var</span><span class="Preform-plain-syntax"> {</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">struct</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">wording</span><span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">name</span><span class="Preform-plain-syntax">;</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">struct</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">pcalc_prop</span><span class="Preform-plain-syntax"> *</span><span class="Preform-identifier-syntax">val</span><span class="Preform-plain-syntax">;</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">CLASS_DEFINITION</span>
|
||||
<span class="Preform-plain-syntax">} </span><span class="Preform-reserved-syntax">repl_var</span><span class="Preform-plain-syntax">;</span>
|
||||
|
||||
<span class="Preform-function-syntax"><new-repl-variable></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">repl_var</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-identifier-syntax">LOOP_OVER</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">, </span><span class="Preform-reserved-syntax">repl_var</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><a href="../words-module/3-wrd.html#SP13" class="function-link"><span class="Preform-function-syntax">Wordings::match</span></a><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">-></span><span class="Preform-element-syntax">name</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">)) {</span>
|
||||
<span class="Preform-plain-syntax"> ==> { -, </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> }; </span><span class="Preform-reserved-syntax">return</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">TRUE</span><span class="Preform-plain-syntax">;</span>
|
||||
<span class="Preform-plain-syntax"> }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> = </span><span class="Preform-identifier-syntax">CREATE</span><span class="Preform-plain-syntax">(</span><span class="Preform-reserved-syntax">repl_var</span><span class="Preform-plain-syntax">);</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">-></span><span class="Preform-element-syntax">val</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="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">-></span><span class="Preform-element-syntax">name</span><span class="Preform-plain-syntax"> = </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">;</span>
|
||||
<span class="Preform-plain-syntax"> ==> { -, </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> }; </span><span class="Preform-reserved-syntax">return</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">TRUE</span><span class="Preform-plain-syntax">;</span>
|
||||
<span class="Preform-plain-syntax">}</span>
|
||||
|
||||
<span class="Preform-function-syntax"><repl-variable></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">repl_var</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-identifier-syntax">LOOP_OVER</span><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">, </span><span class="Preform-reserved-syntax">repl_var</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><a href="../words-module/3-wrd.html#SP13" class="function-link"><span class="Preform-function-syntax">Wordings::match</span></a><span class="Preform-plain-syntax">(</span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax">-></span><span class="Preform-element-syntax">name</span><span class="Preform-plain-syntax">, </span><span class="Preform-identifier-syntax">W</span><span class="Preform-plain-syntax">)) {</span>
|
||||
<span class="Preform-plain-syntax"> ==> { -, </span><span class="Preform-identifier-syntax">rv</span><span class="Preform-plain-syntax"> }; </span><span class="Preform-reserved-syntax">return</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">TRUE</span><span class="Preform-plain-syntax">;</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-constant-syntax">FALSE</span><span class="Preform-plain-syntax">;</span>
|
||||
<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><li>The structure repl_var is accessed in 2/trs, 3/tff, 1/sc, 2/art, 2/prn, 3/dmn and here.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. A sort of REPL. </b>The following function reads a file whose name is in <span class="extract"><span class="Preform-extract-syntax">arg</span></span>, feeds it into
|
||||
the lexer, builds a syntax tree of its sentences, and then walks through
|
||||
that tree, applying the Preform nonterminal <declaration-line> to each
|
||||
sentence. In effect, this is a read-evaluate-print loop.
|
||||
|
|
@ -84,6 +119,7 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">parse_node_tree</span><span class="plain-syntax"> *</span><span class="identifier-syntax">syntax_tree</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">test_err</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
|
||||
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Declarations::load_from_file</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Declarations::load_from_file</span></span>:<br/>Program Control - <a href="1-pc.html#SP2">§2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">arg</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">filename</span><span class="plain-syntax"> *</span><span class="identifier-syntax">F</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -94,7 +130,8 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">syntax_tree</span><span class="plain-syntax"> = </span><a href="../syntax-module/2-st.html#SP2" class="function-link"><span class="function-syntax">SyntaxTree::new</span></a><span class="plain-syntax">();</span>
|
||||
<span class="plain-syntax"> </span><a href="../syntax-module/3-snt.html#SP5" class="function-link"><span class="function-syntax">Sentences::break</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">syntax_tree</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="../calculus-module/2-bpf.html#SP2" class="function-link"><span class="function-syntax">BinaryPredicateFamilies::first_stock</span></a><span class="plain-syntax">();</span>
|
||||
<span class="plain-syntax"> </span><a href="../syntax-module/2-st.html#SP10" class="function-link"><span class="function-syntax">SyntaxTree::traverse</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">syntax_tree</span><span class="plain-syntax">, </span><a href="1-dcl.html#SP2" class="function-link"><span class="function-syntax">Declarations::parse</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">test_err</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP2" class="function-link"><span class="function-syntax">Str::new</span></a><span class="plain-syntax">();</span>
|
||||
<span class="plain-syntax"> </span><a href="../syntax-module/2-st.html#SP10" class="function-link"><span class="function-syntax">SyntaxTree::traverse</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">syntax_tree</span><span class="plain-syntax">, </span><a href="1-dcl.html#SP3" class="function-link"><span class="function-syntax">Declarations::parse</span></a><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">Declarations::parse</span><span class="plain-syntax">(</span><span class="reserved-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -104,28 +141,38 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b></p>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. </b></p>
|
||||
|
||||
<pre class="Preform-displayed-code all-displayed-code code-font">
|
||||
<span class="Preform-function-syntax"><declaration-line></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">new</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">unary</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">==></span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-dcl.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Create new unary</span><span class="named-paragraph-number">3.1</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">new</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">binary</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">==></span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-dcl.html#SP3_2" class="named-paragraph-link"><span class="named-paragraph">Create new binary</span><span class="named-paragraph-number">3.2</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><result></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="named-paragraph-container code-font"><a href="1-dcl.html#SP3_3" class="named-paragraph-link"><span class="named-paragraph">Show result</span><span class="named-paragraph-number">3.3</span></a></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="named-paragraph-container code-font"><a href="1-dcl.html#SP3_4" class="named-paragraph-link"><span class="named-paragraph">Fail with error</span><span class="named-paragraph-number">3.4</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">new</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">unary</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">==></span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-dcl.html#SP4_2" class="named-paragraph-link"><span class="named-paragraph">Create new unary</span><span class="named-paragraph-number">4.2</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">new</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">binary</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">==></span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-dcl.html#SP4_3" class="named-paragraph-link"><span class="named-paragraph">Create new binary</span><span class="named-paragraph-number">4.3</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">set</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><new-repl-variable></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></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="named-paragraph-container code-font"><a href="1-dcl.html#SP4_4" class="named-paragraph-link"><span class="named-paragraph">Set REPL var</span><span class="named-paragraph-number">4.4</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></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="named-paragraph-container code-font"><a href="1-dcl.html#SP4_5" class="named-paragraph-link"><span class="named-paragraph">Show result</span><span class="named-paragraph-number">4.5</span></a></span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><test></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="named-paragraph-container code-font"><a href="1-dcl.html#SP4_6" class="named-paragraph-link"><span class="named-paragraph">Show result of test</span><span class="named-paragraph-number">4.6</span></a></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="named-paragraph-container code-font"><a href="1-dcl.html#SP4_7" class="named-paragraph-link"><span class="named-paragraph">Fail with error</span><span class="named-paragraph-number">4.7</span></a></span>
|
||||
|
||||
<span class="Preform-function-syntax"><result></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">concatenate</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><proposition></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">conjoin</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><proposition></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"> { -, Calculus::Propositions::conjoin(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-function-syntax"><evaluation></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-function-syntax"><evaluation></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">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">concatenate</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">conjoin</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></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"> { -, Calculus::Propositions::conjoin(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><repl-variable></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"> { -, Calculus::Propositions::copy(((repl_var *) RP[1])->val) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><test></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">syntactically</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">valid</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"> { Calculus::Propositions::is_syntactically_valid(RP[1], test_err), - }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><evaluation></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">well-formed</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { Calculus::Variables::is_well_formed(RP[1], test_err), - }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax"><<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-propositions></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">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax"><<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atoms></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">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax"><<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><quantification></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">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax"><<</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"> { -, NULL }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><atomic-propositions></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><quantification></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">\:</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-propositions></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">\^</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-propositions></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-function-syntax"><atoms></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><quantification></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">\:</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atoms></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><quantification></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">in<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atoms></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-function-syntax"><atoms></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="named-paragraph-container code-font"><a href="1-dcl.html#SP4_1" class="named-paragraph-link"><span class="named-paragraph">Make domain</span><span class="named-paragraph-number">4.1</span></a></span><span class="Preform-constant-syntax">;</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">not<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atoms></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">not></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"> { -, Calculus::Propositions::negate(RP[1]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">\^</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atoms></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"> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><atomic-proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { pass 1 }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><atomic-proposition></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
|
|
@ -139,7 +186,11 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">here</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">(</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><term></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">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::HERE_new(*((pcalc_term *) RP[1])) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is-a-kind</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">(</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><term></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">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::ISAKIND_new(*((pcalc_term *) RP[1]), NULL) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is-a-var</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">(</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><term></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">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::ISAVAR_new(*((pcalc_term *) RP[1])) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is-a-const</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">(</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><term></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"> { -, Calculus::Atoms::ISACONST_new(*((pcalc_term *) RP[1])) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">is-a-const</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">(</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><term></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">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::ISACONST_new(*((pcalc_term *) RP[1])) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">not<</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"> { -, Calculus::Atoms::new(NEGATION_OPEN_ATOM) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">not></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"> { -, Calculus::Atoms::new(NEGATION_CLOSE_ATOM) }</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">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::new(DOMAIN_OPEN_ATOM) }</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"> { -, Calculus::Atoms::new(DOMAIN_CLOSE_ATOM) }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><term></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><pcvar></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { -, Declarations::stash(Calculus::Terms::new_variable(R[1])) }</span>
|
||||
|
|
@ -148,8 +199,22 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><quantifier></span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><pcvar></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { -, Calculus::Atoms::QUANTIFIER_new(RP[1], R[2], R[1]) }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><quantifier></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">exists</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"> { 0, exists_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">forall</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { 0, for_all_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">ForAll</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"> { 0, for_all_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">NotAll</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"> { 0, not_for_all_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Exists</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"> { 0, exists_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">DoesNotExist</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"> { 0, not_exists_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">AllBut</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], all_but_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">NotAllBut</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], not_all_but_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Proportion>=80%</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"> { R[1], almost_all_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Proportion<20%</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"> { R[1], almost_no_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Proportion>50%</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"> { R[1], most_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Proportion<=50%</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"> { R[1], under_half_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card>=</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], at_least_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card<=</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], at_most_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card=</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], exactly_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card<</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], less_than_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card></span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></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"> { R[1], more_than_quantifier }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">Card~=</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><cardinal-number></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { R[1], other_than_quantifier }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><pcvar></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">x</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"> { 0, - }</span>
|
||||
|
|
@ -157,23 +222,42 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">z</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { 2, - }</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="SP3_1" class="paragraph-anchor"></a><b>§3.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Create new unary</span><span class="named-paragraph-number">3.1</span></span><span class="Preform-comment-syntax"> =</span>
|
||||
<p class="commentary firstcommentary"><a id="SP4_1" class="paragraph-anchor"></a><b>§4.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make domain</span><span class="named-paragraph-number">4.1</span></span><span class="Preform-comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> ==> { -, </span><a href="../calculus-module/3-prp2.html#SP17" class="function-link"><span class="function-syntax">Calculus::Propositions::quantify_using</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1], </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[2], </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[3]) }</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_2" class="paragraph-anchor"></a><b>§4.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Create new unary</span><span class="named-paragraph-number">4.2</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><a href="../linguistics-module/2-adj.html#SP3" class="function-link"><span class="function-syntax">Adjectives::declare</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax"><declaration-line></span><span class="plain-syntax">, </span><span class="constant-syntax">1</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">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"'%<W': ok\n"</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="1-dcl.html#SP3">§3</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3_2" class="paragraph-anchor"></a><b>§3.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Create new binary</span><span class="named-paragraph-number">3.2</span></span><span class="comment-syntax"> =</span>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_3" class="paragraph-anchor"></a><b>§4.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Create new binary</span><span class="named-paragraph-number">4.3</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><a href="1-dcl.html#SP4" class="function-link"><span class="function-syntax">Declarations::new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax"><declaration-line></span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><a href="1-dcl.html#SP5" class="function-link"><span class="function-syntax">Declarations::new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">GET_RW</span><span class="plain-syntax">(</span><span class="function-syntax"><declaration-line></span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"'%<W': ok\n"</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="1-dcl.html#SP3">§3</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3_3" class="paragraph-anchor"></a><b>§3.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Show result</span><span class="named-paragraph-number">3.3</span></span><span class="comment-syntax"> =</span>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_4" class="paragraph-anchor"></a><b>§4.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Set REPL var</span><span class="named-paragraph-number">4.4</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[2];</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">repl_var</span><span class="plain-syntax"> *</span><span class="identifier-syntax">rv</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RP</span><span class="plain-syntax">[1];</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">rv</span><span class="plain-syntax">-></span><span class="element-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">P</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"'%<W': %W set to "</span><span class="plain-syntax">, </span><span class="identifier-syntax">W</span><span class="plain-syntax">, </span><span class="identifier-syntax">rv</span><span class="plain-syntax">-></span><span class="element-syntax">name</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="../calculus-module/3-prp2.html#SP8" class="function-link"><span class="function-syntax">Calculus::Propositions::write</span></a><span class="plain-syntax">(</span><span class="constant-syntax">STDOUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_5" class="paragraph-anchor"></a><b>§4.5. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Show result</span><span class="named-paragraph-number">4.5</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
|
|
@ -182,21 +266,34 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="plain-syntax"> </span><a href="../calculus-module/3-prp2.html#SP8" class="function-link"><span class="function-syntax">Calculus::Propositions::write</span></a><span class="plain-syntax">(</span><span class="constant-syntax">STDOUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP3">§3</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3_4" class="paragraph-anchor"></a><b>§3.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Fail with error</span><span class="named-paragraph-number">3.4</span></span><span class="comment-syntax"> =</span>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_6" class="paragraph-anchor"></a><b>§4.6. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Show result of test</span><span class="named-paragraph-number">4.6</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"'%<W': "</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">R</span><span class="plain-syntax">[1]) </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"true"</span><span class="plain-syntax">); </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"false"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP8" class="function-link"><span class="function-syntax">Str::len</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">test_err</span><span class="plain-syntax">) > </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">" - %S"</span><span class="plain-syntax">, </span><span class="identifier-syntax">test_err</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP15" class="function-link"><span class="function-syntax">Str::clear</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">test_err</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4_7" class="paragraph-anchor"></a><b>§4.7. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Fail with error</span><span class="named-paragraph-number">4.7</span></span><span class="comment-syntax"> =</span>
|
||||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">PRINT</span><span class="plain-syntax">(</span><span class="string-syntax">"Declaration not understood: '%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">fail</span><span class="plain-syntax"> }</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP3">§3</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. </b></p>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-dcl.html#SP4">§4</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP5" class="paragraph-anchor"></a><b>§5. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">bp_family</span><span class="plain-syntax"> *</span><span class="identifier-syntax">test_bp_family</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
|
||||
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Declarations::new</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Declarations::new</span></span>:<br/><a href="1-dcl.html#SP3_2">§3.2</a></span></button><span class="plain-syntax">(</span><span class="reserved-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">Declarations::new</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">Declarations::new</span></span>:<br/><a href="1-dcl.html#SP4_3">§4.3</a></span></button><span class="plain-syntax">(</span><span class="reserved-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">test_bp_family</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">test_bp_family</span><span class="plain-syntax"> = </span><a href="../calculus-module/2-bpf.html#SP1" class="function-link"><span class="function-syntax">BinaryPredicateFamilies::new</span></a><span class="plain-syntax">();</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">bp_term_details</span><span class="plain-syntax"> </span><span class="identifier-syntax">number_term</span><span class="plain-syntax"> =</span>
|
||||
|
|
@ -212,7 +309,7 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">stashed</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">stashed_terms</span><span class="plain-syntax">[1000];</span>
|
||||
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="function-syntax">Declarations::stash</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">Declarations::stash</span></span>:<br/><a href="1-dcl.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> *</span><span class="function-syntax">Declarations::stash</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">Declarations::stash</span></span>:<br/><a href="1-dcl.html#SP4">§4</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</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">stashed</span><span class="plain-syntax"> == </span><span class="constant-syntax">1000</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"too many terms in test case"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">stashed_terms</span><span class="plain-syntax">[</span><span class="identifier-syntax">stashed</span><span class="plain-syntax">] = </span><span class="identifier-syntax">t</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">stashed_terms</span><span class="plain-syntax">[</span><span class="identifier-syntax">stashed</span><span class="plain-syntax">++]);</span>
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ function togglePopup(material_id) {
|
|||
<span class="plain-syntax"> </span><a href="../../../inweb/docs/foundation-module/2-str.html#SP20" class="function-link"><span class="function-syntax">Streams::enable_debugging</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DL</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">id</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOAD_CLSW:</span><span class="plain-syntax"> </span><a href="../kinds-module/4-nf.html#SP1" class="function-link"><span class="function-syntax">NeptuneFiles::load</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/3-fln.html#SP3" class="function-link"><span class="function-syntax">Filenames::from_text</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">)); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">INTERPRET_CLSW:</span><span class="plain-syntax"> </span><a href="1-dcl.html#SP2" class="function-link"><span class="function-syntax">Declarations::load_from_file</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">INTERPRET_CLSW:</span><span class="plain-syntax"> </span><a href="1-dcl.html#SP3" class="function-link"><span class="function-syntax">Declarations::load_from_file</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">arg</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">save_DL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
|
|||
|
|
@ -256,23 +256,14 @@ which use this module:
|
|||
or other text streams.
|
||||
</p>
|
||||
|
||||
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">) </span><span class="identifier-syntax">Writers::register_logger</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, &</span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">);</span>
|
||||
<span class="definition-keyword">define</span> <span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">format</span><span class="plain-syntax">, </span><span class="reserved-syntax">void</span><span class="plain-syntax"> *</span><span class="identifier-syntax">obj</span><span class="plain-syntax">) { </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">SDL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DL</span><span class="plain-syntax">; </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">format</span><span class="plain-syntax">; </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">DL</span><span class="plain-syntax">) </span><span class="identifier-syntax">f</span><span class="plain-syntax">((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) </span><span class="identifier-syntax">obj</span><span class="plain-syntax">); </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">SDL</span><span class="plain-syntax">; }</span>
|
||||
<span class="definition-keyword">define</span> <span class="identifier-syntax">REGISTER_WRITER_I</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">) </span><span class="identifier-syntax">Writers::register_logger_I</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, &</span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">);</span>
|
||||
<span class="definition-keyword">define</span> <span class="identifier-syntax">COMPILE_WRITER_I</span><span class="plain-syntax">(</span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">format</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">I</span><span class="plain-syntax">) { </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">SDL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DL</span><span class="plain-syntax">; </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">format</span><span class="plain-syntax">; </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">DL</span><span class="plain-syntax">) </span><span class="identifier-syntax">f</span><span class="plain-syntax">((</span><span class="identifier-syntax">t</span><span class="plain-syntax">) </span><span class="identifier-syntax">I</span><span class="plain-syntax">); </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">SDL</span><span class="plain-syntax">; }</span>
|
||||
<span class="definition-keyword">define</span> <span class="identifier-syntax">REGISTER_WRITER_W</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">) </span><span class="identifier-syntax">Writers::register_logger_W</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, &</span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">);</span>
|
||||
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="identifier-syntax">REGISTER_WRITER_W</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="identifier-syntax">f</span><span class="plain-syntax">) </span><span class="identifier-syntax">Writers::register_logger_W</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">, &</span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">);</span>
|
||||
<span class="definition-keyword">define</span> <span class="identifier-syntax">COMPILE_WRITER_W</span><span class="plain-syntax">(</span><span class="identifier-syntax">f</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="identifier-syntax">f</span><span class="plain-syntax">##</span><span class="identifier-syntax">_writer</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">format</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="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">SDL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">DL</span><span class="plain-syntax">; </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">format</span><span class="plain-syntax">; </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">DL</span><span class="plain-syntax">) </span><span class="identifier-syntax">f</span><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">); </span><span class="identifier-syntax">DL</span><span class="plain-syntax"> = </span><span class="identifier-syntax">SDL</span><span class="plain-syntax">; }</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_term</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">Calculus::Terms::log</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">binary_predicate</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">BinaryPredicates::log</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">table</span><span class="plain-syntax"> *, </span><a href="19-tb.html#SP8" class="function-link"><span class="function-syntax">Tables::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">booking</span><span class="plain-syntax"> *, </span><a href="21-rb.html#SP4" class="function-link"><span class="function-syntax">Rules::Bookings::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">table_column</span><span class="plain-syntax"> *, </span><a href="19-tc.html#SP4" class="function-link"><span class="function-syntax">Tables::Columns::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">Calculus::Propositions::log</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">extension_dictionary_entry</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">ExtensionDictionary::log_entry</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *, </span><a href="25-in.html#SP29" class="function-link"><span class="function-syntax">Invocations::log_list</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *, </span><a href="25-in.html#SP9" class="function-link"><span class="function-syntax">Invocations::log</span></a><span class="plain-syntax">)</span>
|
||||
|
|
@ -285,10 +276,8 @@ or other text streams.
|
|||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">local_variable</span><span class="plain-syntax"> *, </span><a href="24-lv.html#SP34" class="function-link"><span class="function-syntax">LocalVariables::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER_I</span><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax">, </span><a href="16-in.html#SP21" class="function-link"><span class="function-syntax">World::Inferences::log_kind</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">instance</span><span class="plain-syntax"> *, </span><a href="6-ins.html#SP11" class="function-link"><span class="function-syntax">Instances::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">Calculus::Atoms::log</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">equation</span><span class="plain-syntax"> *, </span><a href="20-eq.html#SP51" class="function-link"><span class="function-syntax">Equations::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">phrase</span><span class="plain-syntax"> *, </span><a href="22-ph.html#SP8" class="function-link"><span class="function-syntax">Phrases::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="identifier-syntax">unary_predicate</span><span class="plain-syntax"> *, </span><span class="identifier-syntax">UnaryPredicates::log</span><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">ph_usage_data</span><span class="plain-syntax"> *, </span><a href="22-pu.html#SP16" class="function-link"><span class="function-syntax">Phrases::Usage::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">property</span><span class="plain-syntax"> *, </span><a href="15-pr.html#SP14" class="function-link"><span class="function-syntax">Properties::log</span></a><span class="plain-syntax">)</span>
|
||||
<span class="identifier-syntax">COMPILE_WRITER</span><span class="plain-syntax">(</span><span class="reserved-syntax">nonlocal_variable</span><span class="plain-syntax"> *, </span><a href="6-nv.html#SP7" class="function-link"><span class="function-syntax">NonlocalVariables::log</span></a><span class="plain-syntax">)</span>
|
||||
|
|
@ -453,12 +442,9 @@ we need to use the equivalent of traditional <span class="extract"><span class="
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'0'</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Terms::log</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'2'</span><span class="plain-syntax">, </span><span class="identifier-syntax">BinaryPredicates::log</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'B'</span><span class="plain-syntax">, </span><a href="19-tb.html#SP8" class="function-link"><span class="function-syntax">Tables::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'b'</span><span class="plain-syntax">, </span><a href="21-rb.html#SP4" class="function-link"><span class="function-syntax">Rules::Bookings::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'C'</span><span class="plain-syntax">, </span><a href="19-tc.html#SP4" class="function-link"><span class="function-syntax">Tables::Columns::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'D'</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Propositions::log</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'d'</span><span class="plain-syntax">, </span><span class="identifier-syntax">ExtensionDictionary::log_entry</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'E'</span><span class="plain-syntax">, </span><a href="25-in.html#SP29" class="function-link"><span class="function-syntax">Invocations::log_list</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'e'</span><span class="plain-syntax">, </span><a href="25-in.html#SP9" class="function-link"><span class="function-syntax">Invocations::log</span></a><span class="plain-syntax">);</span>
|
||||
|
|
@ -471,10 +457,8 @@ we need to use the equivalent of traditional <span class="extract"><span class="
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'k'</span><span class="plain-syntax">, </span><a href="24-lv.html#SP34" class="function-link"><span class="function-syntax">LocalVariables::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER_I</span><span class="plain-syntax">(</span><span class="character-syntax">'n'</span><span class="plain-syntax">, </span><a href="16-in.html#SP21" class="function-link"><span class="function-syntax">World::Inferences::log_kind</span></a><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'O'</span><span class="plain-syntax">, </span><a href="6-ins.html#SP11" class="function-link"><span class="function-syntax">Instances::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'o'</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Atoms::log</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'q'</span><span class="plain-syntax">, </span><a href="20-eq.html#SP51" class="function-link"><span class="function-syntax">Equations::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'R'</span><span class="plain-syntax">, </span><a href="22-ph.html#SP8" class="function-link"><span class="function-syntax">Phrases::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'r'</span><span class="plain-syntax">, </span><span class="identifier-syntax">UnaryPredicates::log</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'U'</span><span class="plain-syntax">, </span><a href="22-pu.html#SP16" class="function-link"><span class="function-syntax">Phrases::Usage::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'Y'</span><span class="plain-syntax">, </span><a href="15-pr.html#SP14" class="function-link"><span class="function-syntax">Properties::log</span></a><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">REGISTER_WRITER</span><span class="plain-syntax">(</span><span class="character-syntax">'Z'</span><span class="plain-syntax">, </span><a href="6-nv.html#SP7" class="function-link"><span class="function-syntax">NonlocalVariables::log</span></a><span class="plain-syntax">);</span>
|
||||
|
|
|
|||
|
|
@ -83,7 +83,17 @@ MathJax = {
|
|||
|
||||
<ul class="toc"><li><a href="11-sc.html#SP1">§1. The meaning of a sentence</a></li><li><a href="11-sc.html#SP1_14">§1.14. Simplification</a></li><li><a href="11-sc.html#SP3">§3. The meaning of a noun phrase</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. The meaning of a sentence. </b>This section provides a single, but crucial, function to the rest of Inform:
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. The meaning of a sentence. </b>"Again and again Haddon thought he had found the key to the strange writings,
|
||||
but always he was disappointed. And then one day — he was an old man of seventy
|
||||
now — he fed a trial programme into his computer, and for the first time a
|
||||
translated sentence was delivered — his life-long task was rewarded. Yes,
|
||||
but for the fact that one man had been prepared to devote every spare hour of
|
||||
his life to solving the riddle, the amazing story of the Trigan Empire would
|
||||
never have been given to the world. WHAT FOLLOWS IS THAT STORY."
|
||||
("The Rise and Fall of the Trigan Empire", 1965)
|
||||
</p>
|
||||
|
||||
<p class="commentary">This section provides a single, but crucial, function to the rest of Inform:
|
||||
it takes a sentence subtree output by the S-parser and turns it into a proposition.
|
||||
</p>
|
||||
|
||||
|
|
@ -545,7 +555,7 @@ Still, rule (iii) can only be ensured by writing the routines carefully.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">changed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">NF</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Variables::number_free</span><span class="plain-syntax">(</span><span class="identifier-syntax">proposition</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">proposition</span><span class="plain-syntax">) </span><span class="identifier-syntax">proposition</span><span class="plain-syntax"> = </span><span class="identifier-syntax">simp</span><span class="plain-syntax">(</span><span class="identifier-syntax">proposition</span><span class="plain-syntax">, &</span><span class="identifier-syntax">changed</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">changed</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOGIF</span><span class="plain-syntax">(</span><span class="identifier-syntax">PREDICATE_CALCULUS</span><span class="plain-syntax">, </span><span class="string-syntax">"[%d] %s: $D\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">conv_log_depth</span><span class="plain-syntax">, #</span><span class="identifier-syntax">simp</span><span class="plain-syntax">, </span><span class="identifier-syntax">proposition</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">proposition</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">proposition</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">NF</span><span class="plain-syntax"> != </span><span class="identifier-syntax">Calculus::Variables::number_free</span><span class="plain-syntax">(</span><span class="identifier-syntax">proposition</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">"Failed after applying %s: $D"</span><span class="plain-syntax">, #</span><span class="identifier-syntax">simp</span><span class="plain-syntax">, </span><span class="identifier-syntax">proposition</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="identifier-syntax">simp</span><span class="plain-syntax"> </span><span class="string-syntax">" simplified proposition into one which is not well-formed"</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -556,7 +566,7 @@ Still, rule (iii) can only be ensured by writing the routines carefully.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">sentence_prop</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">sentence_prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">"Failed before simplification: $D"</span><span class="plain-syntax">, </span><span class="identifier-syntax">sentence_prop</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">"tried to simplify proposition which is not well-formed"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
|
|
@ -669,7 +679,8 @@ but missing noun.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">NP_prop</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"malformed NP proposition"</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">NP_prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"malformed NP proposition"</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">NF</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Variables::number_free</span><span class="plain-syntax">(</span><span class="identifier-syntax">NP_prop</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">NF</span><span class="plain-syntax"> >= </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"two or more free variables from NP"</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">subject_of_NP</span><span class="plain-syntax">-></span><span class="identifier-syntax">constant</span><span class="plain-syntax">) {</span>
|
||||
|
|
|
|||
|
|
@ -348,9 +348,10 @@ which is by now inside the "creation proposition".
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">UnaryPredicates::get_parity</span><span class="plain-syntax">(</span><span class="identifier-syntax">pred</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">negate_me</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Node::get_creation_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::conjoin</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_creation_proposition</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">negate_me</span><span class="plain-syntax">) </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::conjoin</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Atoms::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">NEGATION_OPEN_ATOM</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::conjoin</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</span><span class="plain-syntax">(</span><span class="identifier-syntax">UnaryPredicates::get_adj</span><span class="plain-syntax">(</span><span class="identifier-syntax">pred</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">negate_me</span><span class="plain-syntax">) </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::conjoin</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">Calculus::Atoms::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">NEGATION_CLOSE_ATOM</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">adj_prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Atoms::unary_PREDICATE_from_aph</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">UnaryPredicates::get_adj</span><span class="plain-syntax">(</span><span class="identifier-syntax">pred</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">negate_me</span><span class="plain-syntax">) </span><span class="identifier-syntax">adj_prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::negate</span><span class="plain-syntax">(</span><span class="identifier-syntax">adj_prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Propositions::conjoin</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">adj_prop</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="11-tc.html#SP7">§7</a>.</li></ul>
|
||||
<nav role="progress"><div class="progresscontainer">
|
||||
|
|
|
|||
|
|
@ -146,7 +146,7 @@ sense of the proposition by changing it, it will do so.
|
|||
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">prop</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">ALWAYS_MATCH</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"type-checking malformed proposition"</span><span class="plain-syntax">);</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="11-tcp.html#SP4_1" class="named-paragraph-link"><span class="named-paragraph">First make sure any constants in the proposition have themselves been typechecked</span><span class="named-paragraph-number">4.1</span></a></span><span class="plain-syntax">;</span>
|
||||
|
|
@ -504,9 +504,9 @@ of success.
|
|||
</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">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[26], </span><span class="identifier-syntax">c</span><span class="plain-syntax">=0;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[26], </span><span class="identifier-syntax">c</span><span class="plain-syntax">=0;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Calculus::Variables::determine_status</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</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="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">j</span><span class="plain-syntax"><26; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">j</span><span class="plain-syntax"><26; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++)</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] != </span><span class="identifier-syntax">UNUSED_VST</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">"%c%s - %u. "</span><span class="plain-syntax">, </span><span class="identifier-syntax">pcalc_vars</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">],</span>
|
||||
<span class="plain-syntax"> (</span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="identifier-syntax">FREE_VST</span><span class="plain-syntax">)?</span><span class="string-syntax">" (free)"</span><span class="plain-syntax">:</span><span class="string-syntax">""</span><span class="plain-syntax">,</span>
|
||||
|
|
|
|||
|
|
@ -372,10 +372,10 @@ variables, and no others.
|
|||
</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">i</span><span class="plain-syntax">, </span><span class="identifier-syntax">valid</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">[26];</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Calculus::Variables::determine_status</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">, &</span><span class="identifier-syntax">valid</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">var_states</span><span class="plain-syntax">[26];</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">valid</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Variables::determine_status</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">var_states</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">valid</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"tried to assert malformed proposition"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax"><26; </span><span class="identifier-syntax">i</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">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax"><26; </span><span class="identifier-syntax">i</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">set</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">current_interpretation_as_spec</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]) </span><span class="identifier-syntax">set</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">current_interpretation_as_infs</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]) {</span>
|
||||
|
|
|
|||
|
|
@ -1414,7 +1414,7 @@ passes type-checking successfully.
|
|||
<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">EW</span><span class="plain-syntax">)) && (</span><span class="identifier-syntax">constructor</span><span class="plain-syntax">-></span><span class="element-syntax">down</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">EW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">constructor</span><span class="plain-syntax">-></span><span class="element-syntax">down</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</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">Calculus::Variables::is_well_formed</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</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">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"malformed proposition in description verification"</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">N</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Calculus::Variables::number_free</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">);</span>
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>Complete Program</title>
|
||||
<title>Overview</title>
|
||||
<link href="docs-assets/Breadcrumbs.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
<meta name="viewport" content="width=device-width initial-scale=1">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
|
||||
|
|
@ -33,10 +33,10 @@
|
|||
</ul>
|
||||
</nav>
|
||||
<main role="main">
|
||||
<!--Weave of 'Complete Program' generated by Inweb-->
|
||||
<!--Weave of 'Overview' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><b>Overview</b></li></ul></div>
|
||||
<p class="commentary firstcommentary"><a id="SP1"></a><b>§1. </b>This is the home page for the source code for the Inform 7 programming
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b>This is the home page for the source code for the Inform 7 programming
|
||||
language. For the language itself, its documentation, and downloads of the
|
||||
apps for different platforms, see: <a href="http://www.inform7.com" class="external">http://www.inform7.com</a>
|
||||
</p>
|
||||
|
|
@ -51,7 +51,7 @@ for browsing. To obtain and build the software, or to see resources which
|
|||
are not webs and thus not here, see: <a href="https://github.com/ganelson/inform" class="external">https://github.com/ganelson/inform</a>
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP2"></a><b>§2. </b>The Inform 7 compiler comes with a large penumbra of supporting resources,
|
||||
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>§2. </b>The Inform 7 compiler comes with a large penumbra of supporting resources,
|
||||
so there are nearly 50 webs in this repository:
|
||||
</p>
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ source code; and <a href="inrtps/index.html" class="internal">inrtps</a>, to for
|
|||
code: see <a href="extensions.html" class="internal">extensions</a>.
|
||||
</li><li>(d) Small unit-test tools to exercise the modules mentioned in (a): see <a href="units.html" class="internal">units</a>.
|
||||
</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3"></a><b>§3. </b>Three webs are conspicuously missing, but only because they are on similar
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b>Three webs are conspicuously missing, but only because they are on similar
|
||||
mini-websites on other Github repositories:
|
||||
</p>
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="index.html"><span class="selectedlink">inflections-test</span></a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -35,7 +35,9 @@ function togglePopup(material_id) {
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="index.html"><span class="selectedlink">inflections-test</span></a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -25,7 +25,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><span class="unlink">inflections-test</span></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -27,7 +27,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -36,7 +36,9 @@ function togglePopup(material_id) {
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -25,7 +25,9 @@
|
|||
</ul><h2>Unit Test Tools</h2><ul>
|
||||
<li><a href="../arch-test/index.html">arch-test</a></li>
|
||||
<li><a href="../building-test/index.html">building-test</a></li>
|
||||
<li><a href="../calculus-test/index.html">calculus-test</a></li>
|
||||
<li><a href="../inflections-test/index.html">inflections-test</a></li>
|
||||
<li><a href="../kinds-test/index.html">kinds-test</a></li>
|
||||
<li><a href="../linguistics-test/index.html">linguistics-test</a></li>
|
||||
<li><a href="../problems-test/index.html">problems-test</a></li>
|
||||
<li><a href="../syntax-test/index.html">syntax-test</a></li>
|
||||
|
|
|
|||
|
|
@ -1,28 +1,28 @@
|
|||
100.0% in inform7 run
|
||||
67.3% in compilation to Inter
|
||||
25.6% in //Phrases::Manager::compile_first_block//
|
||||
67.2% in compilation to Inter
|
||||
25.9% in //Phrases::Manager::compile_first_block//
|
||||
8.7% in //Phrases::Manager::compile_as_needed//
|
||||
6.8% in //Strings::compile_responses//
|
||||
6.1% in //World::Compile::compile//
|
||||
4.3% in //MajorNodes::pre_pass//
|
||||
3.3% in //MajorNodes::pass_1//
|
||||
1.9% in //Phrases::Manager::RulePrintingRule_routine//
|
||||
1.9% in //Phrases::Manager::rulebooks_array//
|
||||
4.4% in //MajorNodes::pre_pass//
|
||||
3.2% in //MajorNodes::pass_1//
|
||||
2.0% in //Phrases::Manager::RulePrintingRule_routine//
|
||||
1.8% in //Phrases::Manager::rulebooks_array//
|
||||
1.0% in //VerbsAtRunTime::ConjugateVerb//
|
||||
0.8% in //Phrases::Manager::traverse//
|
||||
0.5% in //Phrases::Manager::compile_rulebooks//
|
||||
0.5% in //Phrases::Manager::parse_rule_parameters//
|
||||
0.5% in //World::complete//
|
||||
0.3% in //MajorNodes::pass_2//
|
||||
0.3% in //Phrases::Manager::compile_rulebooks//
|
||||
0.3% in //Relations::compile_defined_relations//
|
||||
0.1% in //Kinds::RunTime::compile_data_type_support_routines//
|
||||
0.1% in //PL::Parsing::Verbs::compile_all//
|
||||
0.1% in //Task::make_built_in_kind_constructors//
|
||||
3.7% not specifically accounted for
|
||||
30.2% in running Inter pipeline
|
||||
9.6% in inter step 2/12: link
|
||||
9.4% in step preparation
|
||||
7.2% in inter step 12/12: generate inform6 -> auto.inf
|
||||
3.4% not specifically accounted for
|
||||
30.3% in running Inter pipeline
|
||||
10.7% in step preparation
|
||||
9.8% in inter step 2/12: link
|
||||
6.9% in inter step 12/12: generate inform6 -> auto.inf
|
||||
0.3% in inter step 9/12: make-identifiers-unique
|
||||
0.1% in inter step 10/12: reconcile-verbs
|
||||
0.1% in inter step 11/12: eliminate-redundant-labels
|
||||
|
|
@ -31,6 +31,6 @@
|
|||
0.1% in inter step 6/12: assimilate
|
||||
0.1% in inter step 7/12: resolve-external-symbols
|
||||
0.1% in inter step 8/12: inspect-plugs
|
||||
2.3% not specifically accounted for
|
||||
2.1% in supervisor
|
||||
1.2% not specifically accounted for
|
||||
2.0% in supervisor
|
||||
0.4% not specifically accounted for
|
||||
|
|
|
|||
|
|
@ -172,25 +172,14 @@ DECLARE_CLASS_ALLOCATED_IN_ARRAYS(value_holster, 100)
|
|||
@ Next we define some functions, by macro, which write to the debugging log
|
||||
or other text streams.
|
||||
|
||||
@d REGISTER_WRITER(c, f) Writers::register_logger(c, &f##_writer);
|
||||
@d COMPILE_WRITER(t, f)
|
||||
void f##_writer(text_stream *format, void *obj) { text_stream *SDL = DL; DL = format; if (DL) f((t) obj); DL = SDL; }
|
||||
|
||||
@d REGISTER_WRITER_I(c, f) Writers::register_logger_I(c, &f##_writer);
|
||||
@d COMPILE_WRITER_I(t, f)
|
||||
void f##_writer(text_stream *format, int I) { text_stream *SDL = DL; DL = format; if (DL) f((t) I); DL = SDL; }
|
||||
|
||||
@d REGISTER_WRITER_W(c, f) Writers::register_logger_W(c, &f##_writer);
|
||||
@d COMPILE_WRITER_W(f)
|
||||
void f##_writer(text_stream *format, wording W) { text_stream *SDL = DL; DL = format; if (DL) f(W); DL = SDL; }
|
||||
|
||||
=
|
||||
COMPILE_WRITER(pcalc_term *, Calculus::Terms::log)
|
||||
COMPILE_WRITER(binary_predicate *, BinaryPredicates::log)
|
||||
COMPILE_WRITER(table *, Tables::log)
|
||||
COMPILE_WRITER(booking *, Rules::Bookings::log)
|
||||
COMPILE_WRITER(table_column *, Tables::Columns::log)
|
||||
COMPILE_WRITER(pcalc_prop *, Calculus::Propositions::log)
|
||||
COMPILE_WRITER(extension_dictionary_entry *, ExtensionDictionary::log_entry)
|
||||
COMPILE_WRITER(parse_node *, Invocations::log_list)
|
||||
COMPILE_WRITER(parse_node *, Invocations::log)
|
||||
|
|
@ -203,10 +192,8 @@ COMPILE_WRITER(rulebook *, Rulebooks::log)
|
|||
COMPILE_WRITER(local_variable *, LocalVariables::log)
|
||||
COMPILE_WRITER_I(int, World::Inferences::log_kind)
|
||||
COMPILE_WRITER(instance *, Instances::log)
|
||||
COMPILE_WRITER(pcalc_prop *, Calculus::Atoms::log)
|
||||
COMPILE_WRITER(equation *, Equations::log)
|
||||
COMPILE_WRITER(phrase *, Phrases::log)
|
||||
COMPILE_WRITER(unary_predicate *, UnaryPredicates::log)
|
||||
COMPILE_WRITER(ph_usage_data *, Phrases::Usage::log)
|
||||
COMPILE_WRITER(property *, Properties::log)
|
||||
COMPILE_WRITER(nonlocal_variable *, NonlocalVariables::log)
|
||||
|
|
@ -354,12 +341,9 @@ we need to use the equivalent of traditional |malloc| and |calloc| routines.
|
|||
Log::declare_aspect(VARIABLE_CREATIONS_DA, L"variable creations", FALSE, FALSE);
|
||||
|
||||
@<Register this module's debugging log writers@> =
|
||||
REGISTER_WRITER('0', Calculus::Terms::log);
|
||||
REGISTER_WRITER('2', BinaryPredicates::log);
|
||||
REGISTER_WRITER('B', Tables::log);
|
||||
REGISTER_WRITER('b', Rules::Bookings::log);
|
||||
REGISTER_WRITER('C', Tables::Columns::log);
|
||||
REGISTER_WRITER('D', Calculus::Propositions::log);
|
||||
REGISTER_WRITER('d', ExtensionDictionary::log_entry);
|
||||
REGISTER_WRITER('E', Invocations::log_list);
|
||||
REGISTER_WRITER('e', Invocations::log);
|
||||
|
|
@ -372,10 +356,8 @@ we need to use the equivalent of traditional |malloc| and |calloc| routines.
|
|||
REGISTER_WRITER('k', LocalVariables::log);
|
||||
REGISTER_WRITER_I('n', World::Inferences::log_kind)
|
||||
REGISTER_WRITER('O', Instances::log);
|
||||
REGISTER_WRITER('o', Calculus::Atoms::log);
|
||||
REGISTER_WRITER('q', Equations::log);
|
||||
REGISTER_WRITER('R', Phrases::log);
|
||||
REGISTER_WRITER('r', UnaryPredicates::log);
|
||||
REGISTER_WRITER('U', Phrases::Usage::log);
|
||||
REGISTER_WRITER('Y', Properties::log);
|
||||
REGISTER_WRITER('Z', NonlocalVariables::log);
|
||||
|
|
|
|||
|
|
@ -4,6 +4,15 @@ The third of the three sources of propositions to conjure with:
|
|||
those which arise by the parsing of complex sentence trees in the S-grammar.
|
||||
|
||||
@h The meaning of a sentence.
|
||||
"Again and again Haddon thought he had found the key to the strange writings,
|
||||
but always he was disappointed. And then one day -- he was an old man of seventy
|
||||
now -- he fed a trial programme into his computer, and for the first time a
|
||||
translated sentence was delivered -- his life-long task was rewarded. Yes,
|
||||
but for the fact that one man had been prepared to devote every spare hour of
|
||||
his life to solving the riddle, the amazing story of the Trigan Empire would
|
||||
never have been given to the world. WHAT FOLLOWS IS THAT STORY."
|
||||
("The Rise and Fall of the Trigan Empire", 1965)
|
||||
|
||||
This section provides a single, but crucial, function to the rest of Inform:
|
||||
it takes a sentence subtree output by the S-parser and turns it into a proposition.
|
||||
|
||||
|
|
@ -392,7 +401,7 @@ The simplification routines can all be found in "Simplifications".
|
|||
int changed = FALSE, NF = Calculus::Variables::number_free(proposition);
|
||||
if (proposition) proposition = simp(proposition, &changed);
|
||||
if (changed) LOGIF(PREDICATE_CALCULUS, "[%d] %s: $D\n", conv_log_depth, #simp, proposition);
|
||||
if ((Calculus::Variables::is_well_formed(proposition) == FALSE) ||
|
||||
if ((Calculus::Variables::is_well_formed(proposition, NULL) == FALSE) ||
|
||||
(NF != Calculus::Variables::number_free(proposition))) {
|
||||
LOG("Failed after applying %s: $D", #simp, proposition);
|
||||
internal_error(#simp " simplified proposition into one which is not well-formed");
|
||||
|
|
@ -400,7 +409,7 @@ The simplification routines can all be found in "Simplifications".
|
|||
}
|
||||
|
||||
@<Simplify the resultant proposition@> =
|
||||
if (Calculus::Variables::is_well_formed(sentence_prop) == FALSE) {
|
||||
if (Calculus::Variables::is_well_formed(sentence_prop, NULL) == FALSE) {
|
||||
LOG("Failed before simplification: $D", sentence_prop);
|
||||
internal_error("tried to simplify proposition which is not well-formed");
|
||||
}
|
||||
|
|
@ -499,7 +508,8 @@ pcalc_prop *Calculus::Propositions::FromSentences::NP_subtree_to_proposition(pca
|
|||
@ ...and also at the end.
|
||||
|
||||
@<Verify that the output satisfies the First Rule, throwing internal errors if not@> =
|
||||
if (Calculus::Variables::is_well_formed(NP_prop) == FALSE) internal_error("malformed NP proposition");
|
||||
if (Calculus::Variables::is_well_formed(NP_prop, NULL) == FALSE)
|
||||
internal_error("malformed NP proposition");
|
||||
int NF = Calculus::Variables::number_free(NP_prop);
|
||||
if (NF >= 2) internal_error("two or more free variables from NP");
|
||||
if (subject_of_NP->constant) {
|
||||
|
|
|
|||
|
|
@ -257,6 +257,7 @@ which is by now inside the "creation proposition".
|
|||
if (UnaryPredicates::get_parity(pred) == FALSE) negate_me = TRUE;
|
||||
if (Node::get_creation_proposition(p))
|
||||
prop = Calculus::Propositions::conjoin(prop, Node::get_creation_proposition(p));
|
||||
if (negate_me) prop = Calculus::Propositions::conjoin(prop, Calculus::Atoms::new(NEGATION_OPEN_ATOM));
|
||||
prop = Calculus::Propositions::conjoin(prop, Calculus::Atoms::unary_PREDICATE_from_aph(UnaryPredicates::get_adj(pred), FALSE));
|
||||
if (negate_me) prop = Calculus::Propositions::conjoin(prop, Calculus::Atoms::new(NEGATION_CLOSE_ATOM));
|
||||
pcalc_prop *adj_prop = Calculus::Atoms::unary_PREDICATE_from_aph(
|
||||
UnaryPredicates::get_adj(pred), FALSE);
|
||||
if (negate_me) adj_prop = Calculus::Propositions::negate(adj_prop);
|
||||
prop = Calculus::Propositions::conjoin(prop, adj_prop);
|
||||
|
|
|
|||
|
|
@ -66,7 +66,7 @@ int Calculus::Propositions::Checker::type_check(pcalc_prop *prop, tc_problem_kit
|
|||
|
||||
int j;
|
||||
if (prop == NULL) return ALWAYS_MATCH;
|
||||
if (Calculus::Variables::is_well_formed(prop) == FALSE)
|
||||
if (Calculus::Variables::is_well_formed(prop, NULL) == FALSE)
|
||||
internal_error("type-checking malformed proposition");
|
||||
|
||||
@<First make sure any constants in the proposition have themselves been typechecked@>;
|
||||
|
|
@ -347,9 +347,9 @@ prints the log to an I6 string. This is the type-checking report in the case
|
|||
of success.
|
||||
|
||||
@<Show the variable assignment in the debugging log@> =
|
||||
int j, var_states[26], c=0;
|
||||
int var_states[26], c=0;
|
||||
Calculus::Variables::determine_status(prop, var_states, NULL);
|
||||
for (j=0; j<26; j++)
|
||||
for (int j=0; j<26; j++)
|
||||
if (var_states[j] != UNUSED_VST) {
|
||||
LOG("%c%s - %u. ", pcalc_vars[j],
|
||||
(var_states[j] == FREE_VST)?" (free)":"",
|
||||
|
|
|
|||
|
|
@ -254,10 +254,10 @@ proposition. So we require that the slate identify exactly the free
|
|||
variables, and no others.
|
||||
|
||||
@<Check the identification slate against variable usage in the proposition@> =
|
||||
int i, valid = TRUE, var_states[26];
|
||||
Calculus::Variables::determine_status(prop, var_states, &valid);
|
||||
int var_states[26];
|
||||
int valid = Calculus::Variables::determine_status(prop, var_states, NULL);
|
||||
if (valid == FALSE) internal_error("tried to assert malformed proposition");
|
||||
for (i=0; i<26; i++) {
|
||||
for (int i=0; i<26; i++) {
|
||||
int set = FALSE;
|
||||
if (current_interpretation_as_spec[i]) set = TRUE;
|
||||
if (current_interpretation_as_infs[i]) {
|
||||
|
|
|
|||
|
|
@ -1226,7 +1226,7 @@ void Calculus::Deferrals::prop_verify_descriptive(pcalc_prop *prop, char *billin
|
|||
if ((Wordings::empty(EW)) && (constructor->down))
|
||||
EW = Node::get_text(constructor->down);
|
||||
|
||||
if (Calculus::Variables::is_well_formed(prop) == FALSE)
|
||||
if (Calculus::Variables::is_well_formed(prop, NULL) == FALSE)
|
||||
internal_error("malformed proposition in description verification");
|
||||
|
||||
int N = Calculus::Variables::number_free(prop);
|
||||
|
|
|
|||
|
|
@ -33,7 +33,18 @@ DECLARE_CLASS_ALLOCATED_IN_ARRAYS(i6_schema, 100)
|
|||
@e PREDICATE_CALCULUS_WORKINGS_DA
|
||||
|
||||
=
|
||||
COMPILE_WRITER(pcalc_prop *, Calculus::Propositions::log)
|
||||
COMPILE_WRITER(pcalc_prop *, Calculus::Atoms::log)
|
||||
COMPILE_WRITER(pcalc_term *, Calculus::Terms::log)
|
||||
COMPILE_WRITER(binary_predicate *, BinaryPredicates::log)
|
||||
COMPILE_WRITER(unary_predicate *, UnaryPredicates::log)
|
||||
|
||||
void CalculusModule::start(void) {
|
||||
REGISTER_WRITER('D', Calculus::Propositions::log);
|
||||
REGISTER_WRITER('o', Calculus::Atoms::log);
|
||||
REGISTER_WRITER('0', Calculus::Terms::log);
|
||||
REGISTER_WRITER('2', BinaryPredicates::log);
|
||||
REGISTER_WRITER('r', UnaryPredicates::log);
|
||||
Log::declare_aspect(PREDICATE_CALCULUS_DA, L"predicate calculus", FALSE, FALSE);
|
||||
Log::declare_aspect(PREDICATE_CALCULUS_WORKINGS_DA, L"predicate calculus workings", FALSE, FALSE);
|
||||
Calculus::Equality::start();
|
||||
|
|
|
|||
|
|
@ -49,8 +49,8 @@ following is our Periodic Table of all possible elements:
|
|||
|
||||
@d NEGATION_OPEN_ATOM 20 /* logical negation $\lnot$ applied to contents of group */
|
||||
@d NEGATION_CLOSE_ATOM 30 /* end of logical negation $\lnot$ */
|
||||
@d DOMAIN_OPEN_ATOM 21 /* logical negation $\lnot$ applied to contents of group */
|
||||
@d DOMAIN_CLOSE_ATOM 31 /* end of logical negation $\lnot$ */
|
||||
@d DOMAIN_OPEN_ATOM 21 /* this holds the domain of a quantifier */
|
||||
@d DOMAIN_CLOSE_ATOM 31
|
||||
|
||||
@ And as with columns in the Periodic Table, these elements come in what are
|
||||
called "groups", because it often happens that atoms of different elements
|
||||
|
|
@ -495,10 +495,10 @@ void Calculus::Atoms::write(text_stream *OUT, pcalc_prop *prop) {
|
|||
case EVERYWHERE_ATOM: WRITE("everywhere"); break;
|
||||
case NOWHERE_ATOM: WRITE("nowhere"); break;
|
||||
case HERE_ATOM: WRITE("here"); break;
|
||||
case NEGATION_OPEN_ATOM: WRITE("NOT["); break;
|
||||
case NEGATION_CLOSE_ATOM: WRITE("NOT]"); break;
|
||||
case DOMAIN_OPEN_ATOM: WRITE("IN["); break;
|
||||
case DOMAIN_CLOSE_ATOM: WRITE("IN]"); break;
|
||||
case NEGATION_OPEN_ATOM: WRITE("NOT<"); break;
|
||||
case NEGATION_CLOSE_ATOM: WRITE("NOT>"); break;
|
||||
case DOMAIN_OPEN_ATOM: WRITE("IN<"); break;
|
||||
case DOMAIN_CLOSE_ATOM: WRITE("IN>"); break;
|
||||
default: WRITE("?bad-atom?"); break;
|
||||
}
|
||||
if (prop->arity > 0) {
|
||||
|
|
|
|||
|
|
@ -71,11 +71,10 @@ the quantifier has finished. We set the |valid| flag if all is well.
|
|||
@d BOUND_VST 3
|
||||
|
||||
=
|
||||
void Calculus::Variables::determine_status(pcalc_prop *prop, int *var_states, int *valid) {
|
||||
int Calculus::Variables::determine_status(pcalc_prop *prop, int *var_states,
|
||||
text_stream *err) {
|
||||
TRAVERSE_VARIABLE(p);
|
||||
int j, unavailable[26], blevel = 0, dummy;
|
||||
if (valid == NULL) valid = &dummy;
|
||||
*valid = TRUE;
|
||||
int j, unavailable[26], blevel = 0, valid = TRUE;
|
||||
for (j=0; j<26; j++) { var_states[j] = UNUSED_VST; unavailable[j] = 0; }
|
||||
TRAVERSE_PROPOSITION(p, prop) {
|
||||
if (Calculus::Atoms::element_get_group(p->element) == OPEN_OPERATORS_GROUP) blevel++;
|
||||
|
|
@ -85,16 +84,18 @@ void Calculus::Variables::determine_status(pcalc_prop *prop, int *var_states, in
|
|||
}
|
||||
for (j=0; j<p->arity; j++) {
|
||||
int v = Calculus::Terms::variable_underlying(&(p->terms[j]));
|
||||
if (v >= 26) internal_error("corrupted variable term");
|
||||
if (v >= 0) {
|
||||
if (v >= 26) {
|
||||
WRITE_TO(err, "corrupted variable term");
|
||||
valid = FALSE;
|
||||
} else if (v >= 0) {
|
||||
if (unavailable[v] == -1) {
|
||||
*valid = FALSE;
|
||||
LOG("$o invalid because of %c unavailable\n", p, pcalc_vars[v]);
|
||||
valid = FALSE;
|
||||
WRITE_TO(err, "%c unavailable", pcalc_vars[v]);
|
||||
}
|
||||
if (p->element == QUANTIFIER_ATOM) {
|
||||
if (var_states[v] != UNUSED_VST) {
|
||||
*valid = FALSE;
|
||||
LOG("$D: $o invalid because of %c Q for F\n", prop, p, pcalc_vars[v]);
|
||||
valid = FALSE;
|
||||
WRITE_TO(err, "%c used outside its binding", pcalc_vars[v]);
|
||||
}
|
||||
var_states[v] = BOUND_VST; unavailable[v] = blevel;
|
||||
} else {
|
||||
|
|
@ -103,17 +104,16 @@ void Calculus::Variables::determine_status(pcalc_prop *prop, int *var_states, in
|
|||
}
|
||||
}
|
||||
}
|
||||
return valid;
|
||||
}
|
||||
|
||||
@ With just a little wrapping, this gives us the test of well-formedness.
|
||||
|
||||
=
|
||||
int Calculus::Variables::is_well_formed(pcalc_prop *prop) {
|
||||
int status, var_states[26];
|
||||
if (Calculus::Propositions::is_syntactically_valid(prop) == FALSE) return FALSE;
|
||||
Calculus::Variables::determine_status(prop, var_states, &status);
|
||||
if (status == FALSE) { LOG("Variable usage malformed\n"); return FALSE; }
|
||||
return TRUE;
|
||||
int Calculus::Variables::is_well_formed(pcalc_prop *prop, text_stream *err) {
|
||||
int var_states[26];
|
||||
if (Calculus::Propositions::is_syntactically_valid(prop, err) == FALSE) return FALSE;
|
||||
return Calculus::Variables::determine_status(prop, var_states, err);
|
||||
}
|
||||
|
||||
@ Occasionally we really do care only about one of the 26 variables:
|
||||
|
|
@ -332,7 +332,7 @@ pcalc_prop *Calculus::Variables::substitute_term(pcalc_prop *prop, int v, pcalc_
|
|||
|
||||
if (verify_only) *allowed = TRUE;
|
||||
if ((v<0) || (v>=26)) DISALLOW("variable substitution out of range");
|
||||
if (Calculus::Variables::is_well_formed(prop) == FALSE)
|
||||
if (Calculus::Variables::is_well_formed(prop, NULL) == FALSE)
|
||||
DISALLOW("substituting into malformed prop");
|
||||
@<Make sure the substitution would not fail because of a circularity@>;
|
||||
if (verify_only) return prop;
|
||||
|
|
@ -346,7 +346,7 @@ pcalc_prop *Calculus::Variables::substitute_term(pcalc_prop *prop, int v, pcalc_
|
|||
*changed = TRUE;
|
||||
}
|
||||
|
||||
if (Calculus::Variables::is_well_formed(prop) == FALSE)
|
||||
if (Calculus::Variables::is_well_formed(prop, NULL) == FALSE)
|
||||
internal_error("substitution made malformed prop");
|
||||
return prop;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -232,39 +232,39 @@ but we can at least test syntactic validity here.
|
|||
@d MAX_PROPOSITION_GROUP_NESTING 100 /* vastly more than could realistically be used */
|
||||
|
||||
=
|
||||
int Calculus::Propositions::is_syntactically_valid(pcalc_prop *prop) {
|
||||
int Calculus::Propositions::is_syntactically_valid(pcalc_prop *prop, text_stream *err) {
|
||||
TRAVERSE_VARIABLE(p);
|
||||
int groups_stack[MAX_PROPOSITION_GROUP_NESTING], group_sp = 0;
|
||||
TRAVERSE_PROPOSITION(p, prop) {
|
||||
/* (1) each individual atom has to be properly built: */
|
||||
char *err = Calculus::Atoms::validate(p);
|
||||
if (err) { LOG("Atom error: %s: $o\n", err, p); return FALSE; }
|
||||
char *v_err = Calculus::Atoms::validate(p);
|
||||
if (v_err) { WRITE_TO(err, "atom error: %s", err); return FALSE; }
|
||||
/* (2) every open bracket must be matched by a close bracket of the same kind: */
|
||||
if (Calculus::Atoms::element_get_group(p->element) == OPEN_OPERATORS_GROUP) {
|
||||
if (group_sp >= MAX_PROPOSITION_GROUP_NESTING) {
|
||||
LOG("Group nesting too deep\n"); return FALSE;
|
||||
WRITE_TO(err, "group nesting too deep"); return FALSE;
|
||||
}
|
||||
groups_stack[group_sp++] = p->element;
|
||||
}
|
||||
if (Calculus::Atoms::element_get_group(p->element) == CLOSE_OPERATORS_GROUP) {
|
||||
if (group_sp <= 0) { LOG("Too many close groups\n"); return FALSE; }
|
||||
if (group_sp <= 0) { WRITE_TO(err, "too many close groups"); return FALSE; }
|
||||
if (Calculus::Atoms::element_get_match(groups_stack[--group_sp]) != p->element) {
|
||||
LOG("Group open/close doesn't match\n"); return FALSE;
|
||||
WRITE_TO(err, "group open/close doesn't match"); return FALSE;
|
||||
}
|
||||
}
|
||||
/* (3) every quantifier except "exists" must be followed by domain brackets, which occur nowhere else: */
|
||||
if ((Calculus::Atoms::is_quantifier(p_prev)) && (Calculus::Atoms::is_existence_quantifier(p_prev) == FALSE)) {
|
||||
if (p->element != DOMAIN_OPEN_ATOM) { LOG("Quant without domain\n"); return FALSE; }
|
||||
if (p->element != DOMAIN_OPEN_ATOM) { WRITE_TO(err, "quant without domain"); return FALSE; }
|
||||
} else {
|
||||
if (p->element == DOMAIN_OPEN_ATOM) { LOG("Domain without quant\n"); return FALSE; }
|
||||
if (p->element == DOMAIN_OPEN_ATOM) { WRITE_TO(err, "domain without quant"); return FALSE; }
|
||||
}
|
||||
if ((p->next == NULL) &&
|
||||
(Calculus::Atoms::is_quantifier(p)) && (Calculus::Atoms::is_existence_quantifier(p) == FALSE)) {
|
||||
LOG("Ends without domain of final quantifier\n"); return FALSE;
|
||||
WRITE_TO(err, "ends without domain of final quantifier"); return FALSE;
|
||||
}
|
||||
}
|
||||
/* (4) a proposition must end with all its brackets closed: */
|
||||
if (group_sp != 0) { LOG("%d group(s) open\n", group_sp); return FALSE; }
|
||||
if (group_sp != 0) { WRITE_TO(err, "%d group(s) open", group_sp); return FALSE; }
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -357,6 +357,37 @@ pcalc_prop *Calculus::Propositions::conjoin(pcalc_prop *existing_body, pcalc_pro
|
|||
LOG("Existing body: $D\n", existing_body);
|
||||
LOG("Tail: $D\n", tail);
|
||||
|
||||
@h Negation.
|
||||
|
||||
=
|
||||
pcalc_prop *Calculus::Propositions::negate(pcalc_prop *prop) {
|
||||
return Calculus::Propositions::concatenate(
|
||||
Calculus::Atoms::new(NEGATION_OPEN_ATOM),
|
||||
Calculus::Propositions::concatenate(
|
||||
prop,
|
||||
Calculus::Atoms::new(NEGATION_CLOSE_ATOM)));
|
||||
}
|
||||
|
||||
@h Quantification.
|
||||
|
||||
=
|
||||
pcalc_prop *Calculus::Propositions::quantify(quantifier *quant, int v, int parameter, pcalc_prop *domain, pcalc_prop *prop) {
|
||||
pcalc_prop *Q = Calculus::Atoms::QUANTIFIER_new(quant, v, parameter);
|
||||
return Calculus::Propositions::quantify_using(Q, domain, prop);
|
||||
}
|
||||
|
||||
pcalc_prop *Calculus::Propositions::quantify_using(pcalc_prop *Q, pcalc_prop *domain, pcalc_prop *prop) {
|
||||
if (domain)
|
||||
Q = Calculus::Propositions::concatenate(
|
||||
Q,
|
||||
Calculus::Propositions::concatenate(
|
||||
Calculus::Atoms::new(DOMAIN_OPEN_ATOM),
|
||||
Calculus::Propositions::concatenate(
|
||||
domain,
|
||||
Calculus::Atoms::new(DOMAIN_CLOSE_ATOM))));
|
||||
return Calculus::Propositions::concatenate(Q, prop);
|
||||
}
|
||||
|
||||
@h Inserting and deleting atoms.
|
||||
Here we insert an atom at a given position, or at the front if the position
|
||||
is |NULL|.
|
||||
|
|
|
|||
14
services/calculus-module/Figures/conjunction.txt
Normal file
14
services/calculus-module/Figures/conjunction.txt
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
'new unary even': ok
|
||||
'<< NOT> >> is syntactically valid': false - too many close groups
|
||||
'<< Exists x >> is syntactically valid': true
|
||||
'<< ForAll x >> is syntactically valid': false - ends without domain of final quantifier
|
||||
'<< ForAll x IN< kind = number (x) IN>: even (x) >> is syntactically valid': true
|
||||
'<< Forall x IN< kind = number (x) IN>: even (x) >> is syntactically valid': true
|
||||
'set A to << Exists x >>': a set to << Exists x >>
|
||||
'set B to << Exists x: even (x) >>': b set to << Exists x : even(x) >>
|
||||
'A concatenate B': << Exists x : Exists x : even(x) >>
|
||||
'A conjoin B': << Exists x : Exists y : even(y) >>
|
||||
'A concatenate B is syntactically valid': true
|
||||
'A conjoin B is syntactically valid': true
|
||||
'A concatenate B is well-formed': false - x used outside its binding
|
||||
'A conjoin B is well-formed': true
|
||||
|
|
@ -12,8 +12,9 @@
|
|||
'<< (x == y) >>': << (x == y) >>
|
||||
'new binary sees': ok
|
||||
'<< sees (x, y) >>': << sees(x, y) >>
|
||||
'<< NOT< ^ blue (x) ^ NOT> >>': << NOT< blue(x) NOT> >>
|
||||
'<< Forall x IN< kind = number (x) IN>: blue (x) >>': << ForAll x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Exists x >>': << Exists x >>
|
||||
'<< ForAll x >>': << ForAll x >>
|
||||
'<< kind = number (x) ^ blue (x) >>': << kind=number(x) ^ blue(x) >>
|
||||
'<< Exists x: blue (x) >>': << Exists x : blue(x) >>
|
||||
'<< ForAll x: blue (x) >>': << ForAll x : blue(x) >>
|
||||
'<< DoesNotExist x IN< kind = number (x) IN>: blue (x) >>': << DoesNotExist x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Forall x IN< kind = number (x) IN>: blue (x) >>': << ForAll x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Card= 6 x IN< kind = number (x) IN>: blue (x) >>': << Card=6 x IN< kind=number(x) IN> : blue(x) >>
|
||||
|
|
|
|||
|
|
@ -2,97 +2,6 @@
|
|||
|
||||
An exposition of the form of predicate calculus used by Inform.
|
||||
|
||||
@ "Again and again Haddon thought he had found the key to the strange writings,
|
||||
but always he was disappointed. And then one day -- he was an old man of seventy
|
||||
now -- he fed a trial programme into his computer, and for the first time a
|
||||
translated sentence was delivered -- his life-long task was rewarded. Yes,
|
||||
but for the fact that one man had been prepared to devote every spare hour of
|
||||
his life to solving the riddle, the amazing story of the Trigan Empire would
|
||||
never have been given to the world. WHAT FOLLOWS IS THAT STORY."
|
||||
("The Rise and Fall of the Trigan Empire", 1965)
|
||||
|
||||
@h Why predicate calculus.
|
||||
Most attempts to codify the meaning of sentences in any systematic way
|
||||
involve predicate calculus, and most people generally seem to agree
|
||||
that linguistic concepts (like verbs, adjectives, and determiners)
|
||||
correspond uncannily well with logical ones (like binary predicates,
|
||||
unary predicates, and quantifiers). Since today's mathematical logic
|
||||
has its roots in work on the philosophy of language (chiefly by Frege and
|
||||
Wittgenstein), this is not altogether a coincidence. All the same, it is
|
||||
striking how good the fit is, considering that human language is so
|
||||
haphazard and logic so regular.
|
||||
|
||||
At any rate Inform goes along with this consensus, and converts the
|
||||
difficult passages in its source text into mathematical propositions
|
||||
-- lines written in logical notation. This is useful partly as a
|
||||
well-defined way to store complicated meanings inside the program, but
|
||||
also because these propositions can then be simplified by logical
|
||||
rules. We can change their form so long as we do not change their
|
||||
meaning, in the hope of finding ways to carry out the same tasks but
|
||||
more efficiently than a simple-minded reading of the text would
|
||||
suggest.
|
||||
|
||||
There are four main tasks to perform:
|
||||
|
||||
(a) Building propositions from the other Inform data structures;
|
||||
|
||||
(b) Simplifying, rearranging and type-checking propositions;
|
||||
|
||||
(c) Asserting that certain propositions are true at the start of play;
|
||||
|
||||
(d) Compiling certain propositions to I6 code which can test them, make them
|
||||
true, or make them false.
|
||||
|
||||
In this chapter, we take these tasks in order. Because it contains all
|
||||
of Inform's predicate calculus lore in one place, it necessarily contains
|
||||
little pieces of algorithms from other chapters: a piece of the
|
||||
type-checker, a piece of the code for asserting the initial state of
|
||||
play, and so on. Well: but the overlap had to go somewhere.
|
||||
|
||||
@ A glimpse of Inform's inner workings can be made by writing a test
|
||||
instruction like so:
|
||||
|
||||
>> Laboratory is a room. The box is a container.
|
||||
|
||||
>> Test sentence (internal) with a man can see the box in the Laboratory.
|
||||
|
||||
At the start of play, the compiled story file will print a textual form of
|
||||
the proposition in predicate calculus which that became:
|
||||
= (text)
|
||||
1. a man can see the box in the Laboratory
|
||||
[ Exists x : man(x) & thing('box') & is('laboratory', ContainerOf('box')) & can-see(x, 'box') ]
|
||||
x - object.
|
||||
=
|
||||
(The |intest| test case |Calculus| runs about 200 sentences like this.)
|
||||
One can similarly "Test description (internal) with..." for any description,
|
||||
such as "animals which are in lighted rooms".
|
||||
|
||||
@h Formal description.
|
||||
There are many flavours of predicate calculus, and though they behave in
|
||||
broadly similar ways, the details vary in practice. Inform's calculus
|
||||
is unusual in several respects, so here is its definition.
|
||||
|
||||
The terms "constant", "variable" and "function" below are used in
|
||||
their predicate-calculus senses, not their Inform ones. In the excerpt
|
||||
|
||||
>> a container in the location of Nicole contains the second noun
|
||||
|
||||
the text "location of Nicole" is a phrase deciding an object -- a function --
|
||||
and "the second noun" is an object that varies -- a variable. But if we are
|
||||
looking at the sentence only for its logical meaning, we have to forget about
|
||||
the passage of time and think about what the sentence means at any single
|
||||
moment. "Location of Nicole" and "the second noun" are both fixed, in
|
||||
this instant; the only thing which varies is the identity of the possible
|
||||
container, because we might have to look at hundreds of different containers
|
||||
to see if the sentence is true. One logical translation might be
|
||||
$$ \exists x: {\it container}(x)\land {\it in}(x, C_1) \land {\it in}(C_2, x) $$
|
||||
where $C_1$ and $C_2$ are constants ("location of Nicole" and "second noun"
|
||||
respectively), while the only variable is $x$, the mysterious container.
|
||||
(The symbol $\exists$ means "there exists".) Because objects move
|
||||
around in play, and $C_1$ and $C_2$ have different values at different
|
||||
moments, this sentence is sometimes true and sometimes false. But its
|
||||
meaning does not change.
|
||||
|
||||
@ The propositions in our predicate calculus are those which can be made
|
||||
using the following ingredients and recipes.
|
||||
|
||||
|
|
|
|||
|
|
@ -15,6 +15,37 @@ and where functions have names like |Tags::add_by_name| rather than |add_by_name
|
|||
uses a module of utility functions called //foundation//.
|
||||
For more, see //foundation: A Brief Guide to Foundation//.
|
||||
|
||||
@h What predicate calculus is.
|
||||
The word "calculus" is often used to mean differentiating and integrating
|
||||
functions, but properly speaking that is "infinitesimal calculus", and there
|
||||
are many others.[1] In logic, different sets of rules for making deductions
|
||||
tend to be given such names, and we will use (a form of) one of the most
|
||||
popular simple systems, "predicate calculus".[2]
|
||||
|
||||
Most attempts to codify the meaning of sentences in any systematic way involve
|
||||
predicate calculus, and most people generally seem to agree that linguistic
|
||||
concepts (like verbs, adjectives, and determiners) correspond uncannily well
|
||||
with logical ones (like binary predicates, unary predicates, and quantifiers).[3]
|
||||
All the same, it is striking how good the fit is, considering that human language
|
||||
is so haphazard at first sight.
|
||||
|
||||
At any rate Inform goes along with this consensus, and converts the difficult
|
||||
passages in its source text into logical "propositions" -- lines written in
|
||||
logical notation. This is useful partly as a tidy way to store complicated
|
||||
meanings inside the program, but also because these propositions can then be
|
||||
simplified by logical rules, without changing their meaning. Without such
|
||||
simplifications, Inform would generate much less efficient code.
|
||||
|
||||
[1] At time of writing, //nearly 40 can be found here -> https://en.wikipedia.org/wiki/Calculus_(disambiguation)//,
|
||||
though admittedly that includes a genus of spider and a Tintin character.
|
||||
|
||||
[2] Specifically, first order predicate calculus with equality, but with
|
||||
generalised quantifiers added, and disjunction removed.
|
||||
|
||||
[3] This is not altogether a coincidence since the pioneers of mathematical
|
||||
logic, and in particular Frege and Wittgenstein, began by thinking about
|
||||
natural language.
|
||||
|
||||
@h Notation.
|
||||
This module deals with propositions in predicate calculus, that is, with
|
||||
logical statements which are normally written in mathematical notation. To
|
||||
|
|
@ -22,10 +53,161 @@ the end user of Inform, these are invisible: they exist only inside the
|
|||
compiler and are never typed in or printed out. But for the debugging log,
|
||||
for unit testing, and for the literate source, we need to do both of these.
|
||||
|
||||
The following demonstrates the notation being read in, and then written back
|
||||
out, by the //calculus-test// module. As with //kinds-test//, this is a REPL:
|
||||
A glimpse of the propositions generated by Inform can be had by running this
|
||||
test, whose output uses our notation:
|
||||
= (text as Inform 7)
|
||||
Laboratory is a room. The box is a container.
|
||||
Test sentence (internal) with a man can see the box in the Laboratory.
|
||||
Test description (internal) with animals which are in lighted rooms.
|
||||
=
|
||||
But a much easier way to test the functions in this module is to use the
|
||||
//calculus-test// tool. As with //kinds-test//, this is a REPL: that is,
|
||||
a read-evaluate-print-loop tool, which reads in calculations, performs them,
|
||||
and prints the result. Here, the "calculations" consist only of being told
|
||||
exactly what the proposition is, and then printing it back.
|
||||
and prints the result.
|
||||
|
||||
= (text from Figures/notation.txt as REPL)
|
||||
|
||||
@h Formal description.
|
||||
1. A "term" is any of the following:
|
||||
(*) A constant, corresponding to anything which can be evaluated to Inform --
|
||||
a number, a text, etc. -- and which has a definite kind.
|
||||
(*) One of 26 variables, which we print to the debugging log as |x|, |y|,
|
||||
|z|, |a|, |b|, |c|, ..., |w|.
|
||||
(*) A function $f$ applied to another term.[1]
|
||||
|
||||
Note that if we have given values to the necessary variables, then any term
|
||||
can be evaluated to a value, and its kind determined. For example, if |x| is 7,
|
||||
then the terms |17|, |x| and |f(x)| evaluate to 17, 7 and $f(7)$ respectively.
|
||||
|
||||
2. An "atomic proposition" is any of the following:
|
||||
(*) A "unary predicate" $U(t)$, where $t$ is a term, which is either true or
|
||||
false depending on the evaluation of $t$.
|
||||
(*) A "binary predicate" $B(t_1, t_2)$ depending on two terms.[2]
|
||||
(*) A "quantifier" $Q(v, n)$ applying to a variable $v$, optionally with a
|
||||
parameter $n$. See //linguistics: Determiners and Quantifiers// for the range
|
||||
of quantifiers available.
|
||||
|
||||
3. A "proposition" is a sequence of 0 or more of the following:
|
||||
(*) A conjunction $P_1\land P_2$, where $P_1$ and $P_2$ are propositions.
|
||||
(*) A negation $\lnot P$, where $P$ is a proposition.
|
||||
(*) A quantification $Q v\in D: P$, where $Q$ is a quantifier, optionally
|
||||
also with a numerical parameter, $v$ is a variable, $D$ is a set
|
||||
specifying the domain of $v$, and $P$ is a proposition.[3]
|
||||
(*) An existential quantification $\exists v: P$ without a domain.
|
||||
|
||||
[1] In this module we use words such as "constant", "variable" and "function" in
|
||||
their predicate-calculus senses, not their Inform ones. For example, if we are
|
||||
to decide whether it is true that "a container in the location of Nicole contains
|
||||
the prize", we have to forget about the passage of time and think only about a
|
||||
single moment. In the resultant proposition, "the location of Nicole" and
|
||||
"the prize" lead to constant terms, "a container" leads to a variable term (since
|
||||
we do not know its identity) and there are no functions.
|
||||
|
||||
[2] We do not support higher arities of predicates as such, but they can be
|
||||
simulated. The universal relation in Inform is in effect a ternary predicate,
|
||||
but is achieved by combining two of its terms into an ordered pair.
|
||||
|
||||
[3] Some quantifiers also carry a numerical parameter, to express, e.g.,
|
||||
"at least 7" -- the parameter for that being 7.
|
||||
|
||||
@ The implementation uses the term "atom" a little more loosely, to include
|
||||
four punctuation marks: |NOT<|, |NOT>|, |IN<|, |IN>|, which act like
|
||||
opening and closing parentheses. These are considered atoms purely for
|
||||
convenience when building more complicated constructions -- they make no sense
|
||||
standing alone. Thus:
|
||||
|
||||
(*) $\lnot P$ is implemented as |NOT< P NOT>|.
|
||||
(*) $Q v\in D: P$ is implemented as |Q IN< D IN>|.
|
||||
|
||||
Note that the domain $D$ of a quantifier is itself expressed as a proposition.
|
||||
Thus "for all numbers $n$" is implemented as |ForAll n IN< kind=number(n) IN>|.
|
||||
|
||||
In all other cases, adjacent atoms in a sequence are considered to be conjoined:
|
||||
i.e., |X Y| means $X\land Y$, the proposition which is true if $X$ and $Y$ are
|
||||
both true. To emphasise this, the textual notation uses the |^| sign. For
|
||||
example, |odd(n) ^ prime(n)| is the notation for two consecutive atoms |odd(n)|
|
||||
and |prime(n)|.
|
||||
|
||||
@h Unary predicates.
|
||||
We have a mixed bag of unary predicates, as follows.
|
||||
(*) For each adjective defined in the //linguistics// module, there is a
|
||||
predicate |A(t)|, true if the adjective currently applies to $t$.
|
||||
(*) For each kind $K$, there is a predicate |kind=K(t)|, which is true if $t$
|
||||
is of the kind $K$.
|
||||
(*) For any wording |W|, there is a predicate |called=W(t)|, which asserts
|
||||
that the current value of $t$ is something named |W|.
|
||||
(*) |is-a-kind(t)| asserts that $t$ represents a kind, not a value.
|
||||
(*) |is-a-var(t)| asserts that $t$ represents a variable, not a value.
|
||||
(*) |is-a-const(t)| asserts that $t$ represents a constant, not a value.
|
||||
(*) |everywhere(t)| asserts that $t$ is an object found everywhere.
|
||||
(*) |nowhere(t)| asserts that $t$ is an object found nowhere.
|
||||
(*) |here(t)| asserts that $t$ is an object found in the current room.
|
||||
|
||||
As is apparent, the |is-a-...| predicates are a cheat: they exist purely to
|
||||
make it easier to write propositions which change the state of the world,
|
||||
rather than discuss that state. For example, Inform might create the kind
|
||||
"animal" by asserting |Exists x : is-a-kind(x) ^ called=animal(x)|.
|
||||
|
||||
Otherwise, while these are all conceptually unary predicates, only the first
|
||||
is a |PREDICATE_ATOM| in our implementation: the others are |KIND_ATOM|,
|
||||
|CALLED_ATOM|,
|
||||
|
||||
@h Binary predicates.
|
||||
By contrast all binary predicate atoms use |PREDICATE_ATOM|, and there is only
|
||||
one set of them -- but with that said,
|
||||
(a) They can be organised into "families" with shared implementations -- see
|
||||
//Binary Predicate Families//.
|
||||
(b) The equality predicate $=$ is predefined by the //calculus// module, and
|
||||
its special meaning is used when simplifying propositions. See //The Equality Relation//.
|
||||
It is written with the special notation |(x == y)|, though this is just syntactic
|
||||
sugar.
|
||||
|
||||
New BPs can be constructed with //BinaryPredicates::make_pair//. The term "pair"
|
||||
is used because every $B$ has a "reversal" $B^r$, such that $B^r(s, t)$ is true
|
||||
if and only if $B(t, s)$. $B$ and $B^r$ are created in pairs.[1]
|
||||
|
||||
[1] Except for equality, which is its own reversal. See //BinaryPredicates::make_equality//.
|
||||
|
||||
@h Making propositions.
|
||||
Propositions are built incrementally, like Lego, with a sequence of function
|
||||
calls.
|
||||
|
||||
1. Terms are made using the functions //Calculus::Terms::new_constant//,
|
||||
//Calculus::Terms::new_variable// and //Calculus::Terms::new_function//.
|
||||
|
||||
2. Unary predicate atoms are made using:
|
||||
(*) //Calculus::Atoms::unary_PREDICATE_from_aph_term//, or
|
||||
(*) //Calculus::Atoms::KIND_new//, or
|
||||
(*) //Calculus::Atoms::CALLED_new//, or
|
||||
(*) //Calculus::Atoms::new// for the six oddball unaries,
|
||||
supplying atom types |ISAKIND_ATOM|, |ISAVAR_ATOM|, |ISACONST_ATOM|,
|
||||
|EVERYWHERE_ATOM|, |NOWHERE_ATOM| and |HERE_ATOM|.
|
||||
|
||||
Binary predicate atoms are made using //Calculus::Atoms::binary_PREDICATE_new//.
|
||||
|
||||
3. Propositions are then built up from atoms or other propositions[1] by calling:
|
||||
(*) //Calculus::Propositions::conjoin//.
|
||||
(*) //Calculus::Propositions::negate//.
|
||||
(*) //Calculus::Propositions::quantify//.
|
||||
|
||||
[1] But beware that propositions are passed by reference not value. Use
|
||||
//Calculus::Propositions::copy// before changing one, if you need to use it
|
||||
again.
|
||||
|
||||
@ There are two senses in which it's possible to make an impossible proposition:
|
||||
|
||||
(1) You could make a mess of the punctuation markers improperly, or fail to
|
||||
give a domain set for a quantifier.
|
||||
(2) More subtly, you could concatenate two propositions in which the same
|
||||
variable is used with a different meaning in each.
|
||||
|
||||
The functions //Calculus::Propositions::is_syntactically_valid// and
|
||||
//Calculus::Variables::is_well_formed// test that (1) and (2) have not happened.
|
||||
It's because of (2) that it's important to use //Calculus::Propositions::conjoin//
|
||||
and not the simpler //Calculus::Propositions::concatenate//.
|
||||
|
||||
To illustrate:
|
||||
= (text from Figures/conjunction.txt as REPL)
|
||||
Note that the conjunction of A and B renamed the variable |x| in B to |y|,
|
||||
so that it no longer clashed with the meaning of |x| in A. The concatenation
|
||||
did not, simply writing one after the other.
|
||||
|
|
|
|||
|
|
@ -21,6 +21,40 @@ match any text.
|
|||
<comma-divisible-sentence> ::=
|
||||
... ==> { fail }
|
||||
|
||||
@h REPL variables.
|
||||
|
||||
@e repl_var_CLASS
|
||||
|
||||
=
|
||||
DECLARE_CLASS(repl_var)
|
||||
|
||||
typedef struct repl_var {
|
||||
struct wording name;
|
||||
struct pcalc_prop *val;
|
||||
CLASS_DEFINITION
|
||||
} repl_var;
|
||||
|
||||
<new-repl-variable> internal {
|
||||
repl_var *rv;
|
||||
LOOP_OVER(rv, repl_var)
|
||||
if (Wordings::match(rv->name, W)) {
|
||||
==> { -, rv }; return TRUE;
|
||||
}
|
||||
rv = CREATE(repl_var);
|
||||
rv->val = NULL;
|
||||
rv->name = W;
|
||||
==> { -, rv }; return TRUE;
|
||||
}
|
||||
|
||||
<repl-variable> internal {
|
||||
repl_var *rv;
|
||||
LOOP_OVER(rv, repl_var)
|
||||
if (Wordings::match(rv->name, W)) {
|
||||
==> { -, rv }; return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@h A sort of REPL.
|
||||
The following function reads a file whose name is in |arg|, feeds it into
|
||||
the lexer, builds a syntax tree of its sentences, and then walks through
|
||||
|
|
@ -29,6 +63,7 @@ sentence. In effect, this is a read-evaluate-print loop.
|
|||
|
||||
=
|
||||
parse_node_tree *syntax_tree = NULL;
|
||||
text_stream *test_err = NULL;
|
||||
|
||||
void Declarations::load_from_file(text_stream *arg) {
|
||||
filename *F = Filenames::from_text(arg);
|
||||
|
|
@ -39,6 +74,7 @@ void Declarations::load_from_file(text_stream *arg) {
|
|||
syntax_tree = SyntaxTree::new();
|
||||
Sentences::break(syntax_tree, W);
|
||||
BinaryPredicateFamilies::first_stock();
|
||||
test_err = Str::new();
|
||||
SyntaxTree::traverse(syntax_tree, Declarations::parse);
|
||||
}
|
||||
|
||||
|
|
@ -53,22 +89,32 @@ void Declarations::parse(parse_node *p) {
|
|||
<declaration-line> ::=
|
||||
new unary ... | ==> @<Create new unary@>
|
||||
new binary ... | ==> @<Create new binary@>
|
||||
<result> | ==> @<Show result@>
|
||||
set <new-repl-variable> to <evaluation> | ==> @<Set REPL var@>
|
||||
<evaluation> | ==> @<Show result@>
|
||||
<test> | ==> @<Show result of test@>
|
||||
... ==> @<Fail with error@>
|
||||
|
||||
<result> ::=
|
||||
<proposition> concatenate <proposition> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<proposition> conjoin <proposition> | ==> { -, Calculus::Propositions::conjoin(RP[1], RP[2]) }
|
||||
<evaluation> ::=
|
||||
( <evaluation> ) | ==> { pass 1 }
|
||||
<evaluation> concatenate <evaluation> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<evaluation> conjoin <evaluation> | ==> { -, Calculus::Propositions::conjoin(RP[1], RP[2]) }
|
||||
<repl-variable> | ==> { -, Calculus::Propositions::copy(((repl_var *) RP[1])->val) }
|
||||
<proposition> ==> { pass 1 }
|
||||
|
||||
<test> ::=
|
||||
<evaluation> is syntactically valid | ==> { Calculus::Propositions::is_syntactically_valid(RP[1], test_err), - }
|
||||
<evaluation> is well-formed ==> { Calculus::Variables::is_well_formed(RP[1], test_err), - }
|
||||
|
||||
<proposition> ::=
|
||||
<< <atomic-propositions> >> | ==> { pass 1 }
|
||||
<< <atoms> >> | ==> { pass 1 }
|
||||
<< <quantification> >> | ==> { pass 1 }
|
||||
<< >> ==> { -, NULL }
|
||||
|
||||
<atomic-propositions> ::=
|
||||
<quantification> \: <atomic-propositions> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<atomic-proposition> \^ <atomic-propositions> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<atoms> ::=
|
||||
<quantification> \: <atoms> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<quantification> in< <atoms> in> \: <atoms> | ==> @<Make domain@>;
|
||||
not< <atoms> not> | ==> { -, Calculus::Propositions::negate(RP[1]) }
|
||||
<atomic-proposition> \^ <atoms> | ==> { -, Calculus::Propositions::concatenate(RP[1], RP[2]) }
|
||||
<atomic-proposition> ==> { pass 1 }
|
||||
|
||||
<atomic-proposition> ::=
|
||||
|
|
@ -82,7 +128,11 @@ void Declarations::parse(parse_node *p) {
|
|||
here ( <term> ) | ==> { -, Calculus::Atoms::HERE_new(*((pcalc_term *) RP[1])) }
|
||||
is-a-kind ( <term> ) | ==> { -, Calculus::Atoms::ISAKIND_new(*((pcalc_term *) RP[1]), NULL) }
|
||||
is-a-var ( <term> ) | ==> { -, Calculus::Atoms::ISAVAR_new(*((pcalc_term *) RP[1])) }
|
||||
is-a-const ( <term> ) ==> { -, Calculus::Atoms::ISACONST_new(*((pcalc_term *) RP[1])) }
|
||||
is-a-const ( <term> ) | ==> { -, Calculus::Atoms::ISACONST_new(*((pcalc_term *) RP[1])) }
|
||||
not< | ==> { -, Calculus::Atoms::new(NEGATION_OPEN_ATOM) }
|
||||
not> | ==> { -, Calculus::Atoms::new(NEGATION_CLOSE_ATOM) }
|
||||
in< | ==> { -, Calculus::Atoms::new(DOMAIN_OPEN_ATOM) }
|
||||
in> ==> { -, Calculus::Atoms::new(DOMAIN_CLOSE_ATOM) }
|
||||
|
||||
<term> ::=
|
||||
<pcvar> ==> { -, Declarations::stash(Calculus::Terms::new_variable(R[1])) }
|
||||
|
|
@ -91,14 +141,31 @@ void Declarations::parse(parse_node *p) {
|
|||
<quantifier> <pcvar> ==> { -, Calculus::Atoms::QUANTIFIER_new(RP[1], R[2], R[1]) }
|
||||
|
||||
<quantifier> ::=
|
||||
exists | ==> { 0, exists_quantifier }
|
||||
forall ==> { 0, for_all_quantifier }
|
||||
ForAll | ==> { 0, for_all_quantifier }
|
||||
NotAll | ==> { 0, not_for_all_quantifier }
|
||||
Exists | ==> { 0, exists_quantifier }
|
||||
DoesNotExist | ==> { 0, not_exists_quantifier }
|
||||
AllBut <cardinal-number> | ==> { R[1], all_but_quantifier }
|
||||
NotAllBut <cardinal-number> | ==> { R[1], not_all_but_quantifier }
|
||||
Proportion>=80% | ==> { R[1], almost_all_quantifier }
|
||||
Proportion<20% | ==> { R[1], almost_no_quantifier }
|
||||
Proportion>50% | ==> { R[1], most_quantifier }
|
||||
Proportion<=50% | ==> { R[1], under_half_quantifier }
|
||||
Card>= <cardinal-number> | ==> { R[1], at_least_quantifier }
|
||||
Card<= <cardinal-number> | ==> { R[1], at_most_quantifier }
|
||||
Card= <cardinal-number> | ==> { R[1], exactly_quantifier }
|
||||
Card< <cardinal-number> | ==> { R[1], less_than_quantifier }
|
||||
Card> <cardinal-number> | ==> { R[1], more_than_quantifier }
|
||||
Card~= <cardinal-number> ==> { R[1], other_than_quantifier }
|
||||
|
||||
<pcvar> ::=
|
||||
x | ==> { 0, - }
|
||||
y | ==> { 1, - }
|
||||
z ==> { 2, - }
|
||||
|
||||
@<Make domain@> =
|
||||
==> { -, Calculus::Propositions::quantify_using(RP[1], RP[2], RP[3]) }
|
||||
|
||||
@<Create new unary@> =
|
||||
Adjectives::declare(GET_RW(<declaration-line>, 1), NULL);
|
||||
PRINT("'%<W': ok\n", W);
|
||||
|
|
@ -107,12 +174,29 @@ void Declarations::parse(parse_node *p) {
|
|||
Declarations::new(GET_RW(<declaration-line>, 1));
|
||||
PRINT("'%<W': ok\n", W);
|
||||
|
||||
@<Set REPL var@> =
|
||||
pcalc_prop *P = RP[2];
|
||||
repl_var *rv = RP[1];
|
||||
rv->val = P;
|
||||
PRINT("'%<W': %W set to ", W, rv->name);
|
||||
Calculus::Propositions::write(STDOUT, P);
|
||||
PRINT("\n");
|
||||
|
||||
@<Show result@> =
|
||||
pcalc_prop *P = RP[1];
|
||||
PRINT("'%<W': ", W);
|
||||
Calculus::Propositions::write(STDOUT, P);
|
||||
PRINT("\n");
|
||||
|
||||
@<Show result of test@> =
|
||||
PRINT("'%<W': ", W);
|
||||
if (R[1]) PRINT("true"); else {
|
||||
PRINT("false");
|
||||
if (Str::len(test_err) > 0) PRINT(" - %S", test_err);
|
||||
}
|
||||
Str::clear(test_err);
|
||||
PRINT("\n");
|
||||
|
||||
@<Fail with error@> =
|
||||
PRINT("Declaration not understood: '%W'\n", W);
|
||||
==> { fail }
|
||||
|
|
|
|||
|
|
@ -0,0 +1,14 @@
|
|||
'new unary even': ok
|
||||
'<< NOT> >> is syntactically valid': false - too many close groups
|
||||
'<< Exists x >> is syntactically valid': true
|
||||
'<< ForAll x >> is syntactically valid': false - ends without domain of final quantifier
|
||||
'<< ForAll x IN< kind = number (x) IN>: even (x) >> is syntactically valid': true
|
||||
'<< Forall x IN< kind = number (x) IN>: even (x) >> is syntactically valid': true
|
||||
'set A to << Exists x >>': a set to << Exists x >>
|
||||
'set B to << Exists x: even (x) >>': b set to << Exists x : even(x) >>
|
||||
'A concatenate B': << Exists x : Exists x : even(x) >>
|
||||
'A conjoin B': << Exists x : Exists y : even(y) >>
|
||||
'A concatenate B is syntactically valid': true
|
||||
'A conjoin B is syntactically valid': true
|
||||
'A concatenate B is well-formed': false - x used outside its binding
|
||||
'A conjoin B is well-formed': true
|
||||
|
|
@ -12,8 +12,9 @@
|
|||
'<< (x == y) >>': << (x == y) >>
|
||||
'new binary sees': ok
|
||||
'<< sees (x, y) >>': << sees(x, y) >>
|
||||
'<< NOT< ^ blue (x) ^ NOT> >>': << NOT< blue(x) NOT> >>
|
||||
'<< Forall x IN< kind = number (x) IN>: blue (x) >>': << ForAll x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Exists x >>': << Exists x >>
|
||||
'<< ForAll x >>': << ForAll x >>
|
||||
'<< kind = number (x) ^ blue (x) >>': << kind=number(x) ^ blue(x) >>
|
||||
'<< Exists x: blue (x) >>': << Exists x : blue(x) >>
|
||||
'<< ForAll x: blue (x) >>': << ForAll x : blue(x) >>
|
||||
'<< DoesNotExist x IN< kind = number (x) IN>: blue (x) >>': << DoesNotExist x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Forall x IN< kind = number (x) IN>: blue (x) >>': << ForAll x IN< kind=number(x) IN> : blue(x) >>
|
||||
'<< Card= 6 x IN< kind = number (x) IN>: blue (x) >>': << Card=6 x IN< kind=number(x) IN> : blue(x) >>
|
||||
|
|
|
|||
|
|
@ -1,27 +1,21 @@
|
|||
new unary blue.
|
||||
<< >>.
|
||||
<< is-a-kind(x) >>.
|
||||
<< is-a-var(x) >>.
|
||||
<< is-a-const(x) >>.
|
||||
<< everywhere(x) >>.
|
||||
<< nowhere(x) >>.
|
||||
<< here(x) >>.
|
||||
<< called = magic passcode(x) >>.
|
||||
<< kind = number(x) >>.
|
||||
new unary even.
|
||||
|
||||
new unary blue.
|
||||
<< blue(x) >>.
|
||||
<< Exists x >> is syntactically valid.
|
||||
<< ForAll x >> is syntactically valid.
|
||||
<< ForAll x : in< ^ kind = number(x) ^ in> >> is syntactically valid.
|
||||
|
||||
<< (x == y) >>.
|
||||
new binary sees.
|
||||
<< sees(x, y) >>.
|
||||
<< kind = number(x) >> concatenate << even(x) >>.
|
||||
<< Exists x >> concatenate << even(x) >>.
|
||||
<< Exists x >> concatenate << Exists x : even(x) >>.
|
||||
<< Exists x >> conjoin << even(x) >>.
|
||||
|
||||
<< Exists x >>.
|
||||
<< ForAll x >>.
|
||||
set A to << Exists x >>.
|
||||
set B to << Exists x : even(x) >>.
|
||||
b.
|
||||
|
||||
<< kind = number(x) ^ blue(x) >>.
|
||||
<< Exists x : blue(x) >>.
|
||||
<< ForAll x : blue(x) >>.
|
||||
|
||||
<< Exists x >> concatenate << blue(x) >>.
|
||||
<< kind = number(x) >> conjoin << blue(x) >>.
|
||||
A concatenate B.
|
||||
A conjoin B.
|
||||
A concatenate B is syntactically valid.
|
||||
A conjoin B is syntactically valid.
|
||||
A concatenate B is well-formed.
|
||||
A conjoin B is well-formed.
|
||||
|
|
|
|||
16
services/calculus-test/Tests/Test Cases/conjunction.txt
Normal file
16
services/calculus-test/Tests/Test Cases/conjunction.txt
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
new unary even.
|
||||
|
||||
<< NOT> >> is syntactically valid.
|
||||
<< Exists x >> is syntactically valid.
|
||||
<< ForAll x >> is syntactically valid.
|
||||
<< ForAll x IN< kind = number(x) IN> : even(x) >> is syntactically valid.
|
||||
<< Forall x IN< kind = number(x) IN> : even(x) >> is syntactically valid.
|
||||
|
||||
set A to << Exists x >>.
|
||||
set B to << Exists x : even(x) >>.
|
||||
A concatenate B.
|
||||
A conjoin B.
|
||||
A concatenate B is syntactically valid.
|
||||
A conjoin B is syntactically valid.
|
||||
A concatenate B is well-formed.
|
||||
A conjoin B is well-formed.
|
||||
|
|
@ -15,9 +15,10 @@ new unary blue.
|
|||
new binary sees.
|
||||
<< sees(x, y) >>.
|
||||
|
||||
<< Exists x >>.
|
||||
<< ForAll x >>.
|
||||
<< NOT< ^ blue(x) ^ NOT> >>.
|
||||
<< Forall x IN< kind = number(x) IN> : blue(x) >>.
|
||||
|
||||
<< kind = number(x) ^ blue(x) >>.
|
||||
<< Exists x : blue(x) >>.
|
||||
<< ForAll x : blue(x) >>.
|
||||
<< Exists x >>.
|
||||
<< DoesNotExist x IN< kind = number(x) IN> : blue(x) >>.
|
||||
<< Forall x IN< kind = number(x) IN> : blue(x) >>.
|
||||
<< Card= 6 x IN< kind = number(x) IN> : blue(x) >>.
|
||||
|
|
|
|||
Loading…
Reference in a new issue