mirror of
https://github.com/ganelson/inform.git
synced 2024-06-30 22:14:58 +03:00
Began work on knowledge module
This commit is contained in:
Graham Nelson
parent
6fa43d8caa
commit
ce1f8291b9
|
|
@ -1,6 +1,6 @@
|
|||
# Inform 7
|
||||
|
||||
v10.1.0-alpha.1+6R18 'Krypton' (7 February 2021)
|
||||
v10.1.0-alpha.1+6R19 'Krypton' (9 February 2021)
|
||||
|
||||
## About Inform 7
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,3 @@
|
|||
Prerelease: alpha.1
|
||||
Build Date: 7 February 2021
|
||||
Build Number: 6R18
|
||||
Build Date: 9 February 2021
|
||||
Build Number: 6R19
|
||||
|
|
|
|||
|
|
@ -489,7 +489,7 @@ table: do they get permission as well? We're going to say that they do.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">P</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-dbtr.html#SP4_2_1" class="named-paragraph-link"><span class="named-paragraph">Ensure that a property with the same name as the column name exists</span><span class="named-paragraph-number">4.2.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">global_pass_state</span><span class="plain-syntax">.</span><span class="element-syntax">pass</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">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</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="identifier-syntax">Kinds::Knowledge::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">t</span><span class="plain-syntax">-></span><span class="element-syntax">kind_defined_in_this_table</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
|
|
|
|||
|
|
@ -524,7 +524,7 @@ differently as a result.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">count</span><span class="plain-syntax"> <= </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::EitherOr::obtain</span><span class="plain-syntax">(</span><span class="identifier-syntax">FW</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::Conditions::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">CNW</span><span class="plain-syntax">, </span><span class="identifier-syntax">the_list</span><span class="plain-syntax">,</span>
|
||||
<span class="plain-syntax"> &</span><span class="identifier-syntax">already_created_instances</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</span></a><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">owner_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
|
|
@ -534,7 +534,7 @@ differently as a result.
|
|||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prnbar</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::EitherOr::obtain</span><span class="plain-syntax">(</span><span class="identifier-syntax">SW</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prnbar</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">owner_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Properties::EitherOr::make_negations</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">, </span><span class="identifier-syntax">prnbar</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -596,7 +596,7 @@ or sky blue pink".
|
|||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-npr.html#SP5_11_1" class="named-paragraph-link"><span class="named-paragraph">Disallow this option name if it clashes with something non-adjectival</span><span class="named-paragraph-number">5.11.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-npr.html#SP5_11_2" class="named-paragraph-link"><span class="named-paragraph">Disallow this option name if it clashes with an either-or</span><span class="named-paragraph-number">5.11.2</span></a></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">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">cnd_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">PW</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="3-npr.html#SP5">§5</a>.</li></ul>
|
||||
|
|
|
|||
|
|
@ -526,7 +526,7 @@ splitting into cases.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">Kinds::RunTime::ensure_basic_heap_present</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">provide_prn</span><span class="plain-syntax">)</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">), </span><span class="identifier-syntax">storage_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nrr.html#SP5_12" class="named-paragraph-link"><span class="named-paragraph">Add in the reducing functions</span><span class="named-paragraph-number">5.12</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
|
|
|
|||
|
|
@ -1999,12 +1999,12 @@ the "creation proposition" of Y, and we now assert this to be true about X.
|
|||
<span class="plain-syntax"> </span><span class="string-syntax">"at once, and it would be clearer to write it as two sentences?"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::to_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</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">K</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">KindPredicates::new_atom</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">Terms::new_variable</span><span class="plain-syntax">(0));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">left_object</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
</pre>
|
||||
|
|
|
|||
|
|
@ -174,7 +174,7 @@ is to store them and sit on them.
|
|||
</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">Propositions::Assert::testable_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">premiss</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">Assert::testable_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">premiss</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">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_BadImplicationDomain</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"that's an implication where the condition to qualify is not "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"one that I can determine in advance of the start of play"</span><span class="plain-syntax">,</span>
|
||||
|
|
@ -346,7 +346,7 @@ no better a certainty level.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">possession_marker</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pom</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::get_possession_marker</span><span class="plain-syntax">(</span><span class="identifier-syntax">conclusion_prop</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-imp.html#SP6_1_2" class="named-paragraph-link"><span class="named-paragraph">Check that the conclusion is not redundant or irrelevant</span><span class="named-paragraph-number">6.1.2</span></a></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">candidate_qualifies</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::test_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">imp</span><span class="plain-syntax">-></span><span class="element-syntax">if_spec</span><span class="plain-syntax">, </span><span class="identifier-syntax">candidate</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">candidate_qualifies</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::test_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">imp</span><span class="plain-syntax">-></span><span class="element-syntax">if_spec</span><span class="plain-syntax">, </span><span class="identifier-syntax">candidate</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">candidate_qualifies</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">IMPLICATIONS</span><span class="plain-syntax">, </span><span class="string-syntax">"PASS: changing property $Y of $j\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">conclusion_prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">candidate</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -397,7 +397,7 @@ no better a certainty level.
|
|||
<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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><a href="6-tap.html#SP2" class="function-link"><span class="function-syntax">AdjectivalPredicates::new_atom_on_x</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">aph</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">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">candidate</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">candidate</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</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>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="4-imp.html#SP6_1">§6.1</a>.</li></ul>
|
||||
|
|
|
|||
|
|
@ -133,7 +133,7 @@ automatically creates it.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">K</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">Kinds::Knowledge::has_properties</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">))</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-npa.html#SP1_1_1" class="named-paragraph-link"><span class="named-paragraph">Disallow this kind as a new owner of a value property</span><span class="named-paragraph-number">1.1.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Properties::Valued::obtain</span><span class="plain-syntax">(</span><span class="identifier-syntax">Node::get_text</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">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</span></a><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">Assert::true_about</span><span class="plain-syntax">(</span><a href="6-cu.html#SP5" class="function-link"><span class="function-syntax">Propositions::Abstract::to_provide_property</span></a><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">owner_infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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">prn</span><span class="plain-syntax">;</span>
|
||||
</pre>
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ and which therefore exists only once.
|
|||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">var</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lvalues::new_actual_NONLOCAL_VARIABLE</span><span class="plain-syntax">(</span><span class="identifier-syntax">q</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">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP4" class="function-link"><span class="function-syntax">Propositions::Abstract::to_set_relation</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">R_equality</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">var</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP2_1" class="paragraph-anchor"></a><b>§2.1. </b>On the face of it, the following looks unnecessary, and it nearly is.
|
||||
|
|
@ -188,7 +188,7 @@ either as an object, a value or a subtree — should have
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">val_subtree</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">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP7" class="function-link"><span class="function-syntax">Propositions::Abstract::from_property_subtree</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">, </span><span class="identifier-syntax">val_subtree</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">owner</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="4-pk.html#SP3_3" class="named-paragraph-link"><span class="named-paragraph">Issue a problem for an unrecognised property owner</span><span class="named-paragraph-number">3.3</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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">Assertions::PropertyKnowledge::assert_property_list</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">Assertions::PropertyKnowledge::assert_property_list</span></span>:<br/>The Creator - <a href="4-tc.html#SP5_2_1">§5.2.1</a><br/>Assertions - <a href="4-ass.html#SP6_3_18">§6.3.18</a>, <a href="4-ass.html#SP6_3_29">§6.3.29</a>, <a href="4-ass.html#SP9">§9</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner_subtree</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">list_subtree</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -211,7 +211,7 @@ either as an object, a value or a subtree — should have
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">kind_clue</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-pk.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Work out the clue kind</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP8" class="function-link"><span class="function-syntax">Propositions::Abstract::from_property_list</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">list_subtree</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind_clue</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP3_1" class="paragraph-anchor"></a><b>§3.1. </b>We pass the "clue kind" to obtain a proposition which includes an atom
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ objects or values, but there are two exceptional cases to take care of.
|
|||
<span class="plain-syntax"> </span><span class="string-syntax">"than positive information. There's no need to tell me something "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"like 'Here is nothing.': just don't put anything there."</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP6" class="function-link"><span class="function-syntax">Propositions::Abstract::to_put_here</span></a><span class="plain-syntax">(),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">value</span><span class="plain-syntax">), </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
|
|
@ -243,7 +243,7 @@ that subtrees \(T_X\) and \(T_Y\), where \(T_X\) is a single value or object and
|
|||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-rk.html#SP3_1" class="named-paragraph-link"><span class="named-paragraph">Normalise the two noun leaves</span><span class="named-paragraph-number">3.1</span></a></span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="4-rk.html#SP3_2" class="named-paragraph-link"><span class="named-paragraph">Impose a tedious restriction on relations between objects and values</span><span class="named-paragraph-number">3.2</span></a></span><span class="plain-syntax">;</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP4" class="function-link"><span class="function-syntax">Propositions::Abstract::to_set_relation</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">bp</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">px</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::get_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">), </span><span class="identifier-syntax">Node::get_evaluation</span><span class="plain-syntax">(</span><span class="identifier-syntax">py</span><span class="plain-syntax">)),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
|
|||
|
|
@ -853,7 +853,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_object</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">is_a_kind</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">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_make_a_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_object</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</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">is_a_kind</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">recent_creation</span><span class="plain-syntax"> = </span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -926,7 +926,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">NULL</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_make_a_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Specifications::from_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_base_kind_of_value</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="4-tc.html#SP5_4_2">§5.4.2</a>.</li></ul>
|
||||
|
|
@ -946,7 +946,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_make_a_const</span></a><span class="plain-syntax">());</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_make_a_var</span></a><span class="plain-syntax">());</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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">NonlocalVariables::get_latest</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">"failed to create"</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lvalues::new_actual_NONLOCAL_VARIABLE</span><span class="plain-syntax">(</span><span class="identifier-syntax">NonlocalVariables::get_latest</span><span class="plain-syntax">());</span>
|
||||
</pre>
|
||||
|
|
@ -958,7 +958,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">create_as</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">such_that</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_creation_proposition</span><span class="plain-syntax">(</span><span class="identifier-syntax">governor</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">such_that</span><span class="plain-syntax">) </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">such_that</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Rvalues::from_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="4-tc.html#SP5_4_2">§5.4.2</a>.</li></ul>
|
||||
|
|
@ -1253,7 +1253,7 @@ to a different vehicle object.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">NW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::truncate</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">, </span><span class="constant-syntax">32</span><span class="plain-syntax">); </span><span class="comment-syntax"> truncate to the maximum length</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">pz</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">PROPER_NOUN_NT</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">prop</span><span class="plain-syntax"> = </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">instance_kind</span><span class="plain-syntax">, </span><span class="identifier-syntax">NW</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">new_instance</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Instances::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_instance</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">named_after</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
|
||||
|
|
@ -1431,7 +1431,7 @@ proposition claiming its existence, then assert it to be true.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">LOOP_OVER</span><span class="plain-syntax">(</span><span class="identifier-syntax">L</span><span class="plain-syntax">, </span><span class="identifier-syntax">inform_language</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">prop</span><span class="plain-syntax"> =</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP1" class="function-link"><span class="function-syntax">Propositions::Abstract::to_create_something</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="plain-syntax">-></span><span class="identifier-syntax">instance_name</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="plain-syntax">-></span><span class="identifier-syntax">nl_instance</span><span class="plain-syntax"> = </span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
|
|||
|
|
@ -115,7 +115,7 @@ their existence.
|
|||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Propositions::Abstract::assert_kind_of_instance</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">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">k</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="6-cu.html#SP2" class="function-link"><span class="function-syntax">Propositions::Abstract::prop_to_set_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">k</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Instances::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">I</span><span class="plain-syntax">), </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
|
|
@ -125,7 +125,7 @@ their existence.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::domain</span><span class="plain-syntax">(</span><span class="identifier-syntax">new</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">KindPredicates::new_atom</span><span class="plain-syntax">(</span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">Terms::new_variable</span><span class="plain-syntax">(0));</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">subject_to</span><span class="plain-syntax">) </span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">subject_to</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">inst</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">inst</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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>Now propositions to assert that relations hold:
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@ sentence.
|
|||
<span class="plain-syntax"> </span><span class="string-syntax">"which is too vague. You must say what kind it does have."</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::subject_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::subject_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::as_object_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">subj</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">ox</span><span class="plain-syntax">) </span><span class="identifier-syntax">Instances::set_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">ox</span><span class="plain-syntax">, </span><span class="identifier-syntax">up</span><span class="plain-syntax">-></span><span class="identifier-syntax">assert_kind</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
|
||||
|
|
|
|||
|
|
@ -162,9 +162,9 @@ success flag.
|
|||
<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="6-tap.html#SP4" class="function-link"><span class="function-syntax">AdjectivalPredicates::to_adjective</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">up</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">parity</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">now_negated</span><span class="plain-syntax">)?</span><span class="identifier-syntax">FALSE:TRUE</span><span class="plain-syntax">, </span><span class="identifier-syntax">found</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="6-tap.html#SP4" class="function-link"><span class="function-syntax">AdjectivalPredicates::parity</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">up</span><span class="plain-syntax">) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">parity</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">parity</span><span class="plain-syntax">)?</span><span class="identifier-syntax">FALSE:TRUE</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::subject_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::subject_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ots</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::spec_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ots</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::spec_of_term</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="element-syntax">terms</span><span class="plain-syntax">[0]);</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">domain_of_definition</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::domain</span><span class="plain-syntax">(</span><span class="identifier-syntax">ox</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_of_definition</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -183,7 +183,7 @@ success flag.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">ox</span><span class="plain-syntax">) </span><span class="identifier-syntax">found</span><span class="plain-syntax"> = </span><a href="6-am.html#SP14" class="function-link"><span class="function-syntax">Adjectives::Meanings::assert</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="identifier-syntax">domain_of_definition</span><span class="plain-syntax">, </span><span class="identifier-syntax">ox</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">parity</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">found</span><span class="plain-syntax"> = </span><a href="6-am.html#SP14" class="function-link"><span class="function-syntax">Adjectives::Meanings::assert</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="identifier-syntax">domain_of_definition</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">ots</span><span class="plain-syntax">, </span><span class="identifier-syntax">parity</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">found</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">Propositions::Assert::issue_couldnt_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="identifier-syntax">parity</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">found</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) </span><span class="identifier-syntax">Assert::issue_couldnt_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">aph</span><span class="plain-syntax">, </span><span class="identifier-syntax">parity</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">AdjectivalPredicates::testable</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">AdjectivalPredicates::testable</span></span>:<br/><a href="6-tap.html#SP2">§2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">up_family</span><span class="plain-syntax"> *</span><span class="identifier-syntax">self</span><span class="plain-syntax">, </span><span class="identifier-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">up</span><span class="plain-syntax">) {</span>
|
||||
|
|
|
|||
|
|
@ -306,7 +306,7 @@ can be said to be "everywhere", which nothing else can).
|
|||
<span class="plain-syntax"> </span><span class="string-syntax">"which doesn't make sense. An individual backdrop can be 'everywhere', "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"but here we're talking about a whole kind, and it's not allowed "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"to talk about general locations of a whole kind of things at once."</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Abstract::to_put_everywhere</span><span class="plain-syntax">(), </span><span class="identifier-syntax">left_subject</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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>
|
||||
|
|
|
|||
|
|
@ -225,7 +225,7 @@ we're dealing with a backdrop. So we play dumb.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="constant-syntax">IF_MODULE</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::as_object_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">subj</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="3-bck.html#SP16" class="function-link"><span class="function-syntax">PL::Backdrops::infer_presence_everywhere</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ox</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> #</span><span class="identifier-syntax">endif</span>
|
||||
|
|
@ -239,7 +239,7 @@ we're dealing with a backdrop. So we play dumb.
|
|||
<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">void</span><span class="plain-syntax"> </span><span class="function-syntax">WherePredicates::assert_nowhere</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">WherePredicates::assert_nowhere</span></span>:<br/><a href="3-enah.html#SP2">§2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">up_family</span><span class="plain-syntax"> *</span><span class="identifier-syntax">self</span><span class="plain-syntax">, </span><span class="identifier-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">up</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">now_negated</span><span class="plain-syntax">, </span><span class="identifier-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">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::as_object_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">subj</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">now_negated</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">BelievedImpossible</span><span class="plain-syntax">),</span>
|
||||
|
|
@ -269,7 +269,7 @@ problem aside for now.
|
|||
<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">void</span><span class="plain-syntax"> </span><span class="function-syntax">WherePredicates::assert_here</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">WherePredicates::assert_here</span></span>:<br/><a href="3-enah.html#SP2">§2</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">up_family</span><span class="plain-syntax"> *</span><span class="identifier-syntax">self</span><span class="plain-syntax">, </span><span class="identifier-syntax">unary_predicate</span><span class="plain-syntax"> *</span><span class="identifier-syntax">up</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">now_negated</span><span class="plain-syntax">, </span><span class="identifier-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">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Assert::subject_of_term</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">instance</span><span class="plain-syntax"> *</span><span class="identifier-syntax">ox</span><span class="plain-syntax"> = </span><span class="identifier-syntax">InferenceSubjects::as_object_instance</span><span class="plain-syntax">(</span><span class="identifier-syntax">subj</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">now_negated</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">BelievedImpossible</span><span class="plain-syntax">),</span>
|
||||
|
|
|
|||
|
|
@ -594,7 +594,7 @@ node using this wording in order to produce better problem messages if need be.
|
|||
<span class="plain-syntax"> </span><span class="string-syntax">"which doesn't make sense. An individual thing can be 'nowhere', "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"but here we're talking about a whole kind, and it's not allowed "</span>
|
||||
<span class="plain-syntax"> </span><span class="string-syntax">"to talk about general locations of a whole kind of things at once."</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Abstract::to_put_nowhere</span><span class="plain-syntax">(), </span><span class="identifier-syntax">left_subject</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</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>
|
||||
|
|
|
|||
|
|
@ -829,7 +829,7 @@ pairs.
|
|||
<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">"map connection in non-direction"</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">x</span><span class="plain-syntax"> = </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> = </span><span class="identifier-syntax">certainty_level</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true_about</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Abstract::to_set_simple_relation</span><span class="plain-syntax">(</span><span class="identifier-syntax">bp</span><span class="plain-syntax">, </span><span class="identifier-syntax">go_to</span><span class="plain-syntax">),</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Instances::as_subject</span><span class="plain-syntax">(</span><span class="identifier-syntax">go_from</span><span class="plain-syntax">), </span><span class="identifier-syntax">certainty_level</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax"> = </span><span class="identifier-syntax">x</span><span class="plain-syntax">;</span>
|
||||
|
|
|
|||
|
|
@ -127,8 +127,8 @@ meaning.
|
|||
</p>
|
||||
|
||||
<p class="commentary">To build or change the model, we assert that propositions about it are true,
|
||||
using <span class="extract"><span class="extract-syntax">Propositions::Assert::assert_true</span></span> or
|
||||
<span class="extract"><span class="extract-syntax">Propositions::Assert::assert_true_about</span></span>. This is the only way to
|
||||
using <span class="extract"><span class="extract-syntax">Assert::true</span></span> or
|
||||
<span class="extract"><span class="extract-syntax">Assert::true_about</span></span>. This is the only way to
|
||||
create kinds, instances, global variables, and constant values, and also the
|
||||
only way to attach properties to objects, to set property values or
|
||||
the kind of a given object or the value of a global variable, or to declare
|
||||
|
|
@ -143,8 +143,8 @@ model world would then not have changed at all.) So creating new properties
|
|||
and new relations is not done by asserting propositions.
|
||||
</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b><span class="extract"><span class="extract-syntax">Propositions::Assert::assert_true</span></span> asserts propositions in which all variables are
|
||||
bound (or which have no variables); <span class="extract"><span class="extract-syntax">Propositions::Assert::assert_true_about</span></span> asserts
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b><span class="extract"><span class="extract-syntax">Assert::true</span></span> asserts propositions in which all variables are
|
||||
bound (or which have no variables); <span class="extract"><span class="extract-syntax">Assert::true_about</span></span> asserts
|
||||
propositions in which \(x\) is free but all other variables are bound, and
|
||||
substitutes either an object \(O\) or a value \(V\) into \(x\) before asserting.
|
||||
These two procedures are the entire API, so to speak, for growing or changing
|
||||
|
|
@ -154,8 +154,8 @@ converts them into a series of propositions which it would like to make true.
|
|||
</p>
|
||||
|
||||
<p class="commentary">Either way those requests come in, they all end up in the central
|
||||
<span class="extract"><span class="extract-syntax">Propositions::Assert::prop_true_in_model</span></span> procedure, one of the most important choke points within
|
||||
Inform. <span class="extract"><span class="extract-syntax">Propositions::Assert::prop_true_in_model</span></span> and its delegates — routines to assert the
|
||||
<span class="extract"><span class="extract-syntax">Assert::prop_true_in_model</span></span> procedure, one of the most important choke points within
|
||||
Inform. <span class="extract"><span class="extract-syntax">Assert::prop_true_in_model</span></span> and its delegates — routines to assert the
|
||||
truth of various adjectives or relations — are allowed to call routines such
|
||||
as <span class="extract"><span class="extract-syntax">Instances::set_kind</span></span> and <span class="extract"><span class="extract-syntax">Instances::new</span></span> which are forbidden for use in the
|
||||
rest of Inform. These are guarded with the following macro, to ensure that
|
||||
|
|
@ -167,19 +167,19 @@ we don't accidentally break this rule:
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"protected model-affecting procedure used outside proposition assert"</span><span class="plain-syntax">);</span>
|
||||
</pre>
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">ptim_recursion_depth</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="comment-syntax"> depth of recursion of </span><span class="extract"><span class="extract-syntax">Propositions::Assert::prop_true_in_model</span></span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">ptim_recursion_depth</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="comment-syntax"> depth of recursion of </span><span class="extract"><span class="extract-syntax">Assert::prop_true_in_model</span></span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP4" class="paragraph-anchor"></a><b>§4. Entrance. </b>This first entrance is a mere alias for the second.
|
||||
</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">Propositions::Assert::assert_true</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">Propositions::Assert::assert_true</span></span>:<br/>Condition Properties - <a href="3-cp.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">certitude</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP7" class="function-link"><span class="function-syntax">Propositions::Assert::prop_true_in_world_model_inner</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">certitude</span><span class="plain-syntax">);</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::true</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">Assert::true</span></span>:<br/>Condition Properties - <a href="3-cp.html#SP3">§3</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">certitude</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP7" class="function-link"><span class="function-syntax">Assert::prop_true_in_world_model_inner</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">certitude</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">Propositions::Assert::assert_true_about</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">Propositions::Assert::assert_true_about</span></span>:<br/>Either-Or Properties - <a href="3-ep.html#SP9">§9</a><br/>Valued Properties - <a href="3-vp.html#SP10">§10</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">infs</span><span class="plain-syntax">,</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::true_about</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">Assert::true_about</span></span>:<br/>Either-Or Properties - <a href="3-ep.html#SP9">§9</a><br/>Valued Properties - <a href="3-vp.html#SP10">§10</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">infs</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">certitude</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP7" class="function-link"><span class="function-syntax">Propositions::Assert::prop_true_in_world_model_inner</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">certitude</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP7" class="function-link"><span class="function-syntax">Assert::prop_true_in_world_model_inner</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">infs</span><span class="plain-syntax">, </span><span class="identifier-syntax">certitude</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>If we are working along a proposition and reach, say, \(door(x)\), we
|
||||
|
|
@ -198,7 +198,7 @@ of the variables — this is called the "identification slate".
|
|||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">last_couldnt_assert_at</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">Propositions::Assert::issue_couldnt_problem</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><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parity</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::issue_couldnt_problem</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><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parity</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_couldnt_assert_at</span><span class="plain-syntax"> != </span><span class="identifier-syntax">current_sentence</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>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Problems::quote_source</span><span class="plain-syntax">(1, </span><span class="identifier-syntax">current_sentence</span><span class="plain-syntax">);</span>
|
||||
|
|
@ -228,12 +228,12 @@ of the variables — this is called the "identification slate".
|
|||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP7" class="paragraph-anchor"></a><b>§7. </b>The second entrance, then, keeps track of the recursion depth but also
|
||||
ensures that the identification slate is always correct, stacking them
|
||||
so that an inner <span class="extract"><span class="extract-syntax">Propositions::Assert::prop_true_in_model</span></span> has an independent slate from an outer
|
||||
so that an inner <span class="extract"><span class="extract-syntax">Assert::prop_true_in_model</span></span> has an independent slate from an outer
|
||||
one.
|
||||
</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">Propositions::Assert::prop_true_in_world_model_inner</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">Propositions::Assert::prop_true_in_world_model_inner</span></span>:<br/><a href="1-ap.html#SP4">§4</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subject</span><span class="plain-syntax">,</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::prop_true_in_world_model_inner</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">Assert::prop_true_in_world_model_inner</span></span>:<br/><a href="1-ap.html#SP4">§4</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subject</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">certainty</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> **</span><span class="identifier-syntax">saved_interpretation_as_infs</span><span class="plain-syntax"> = </span><span class="identifier-syntax">current_interpretation_as_infs</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">saved_interpretation_as_spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">current_interpretation_as_spec</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -245,7 +245,7 @@ one.
|
|||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">ptim_recursion_depth</span><span class="plain-syntax">++;</span>
|
||||
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP8" class="function-link"><span class="function-syntax">Propositions::Assert::prop_true_in_model</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="1-ap.html#SP8" class="function-link"><span class="function-syntax">Assert::prop_true_in_model</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">ptim_recursion_depth</span><span class="plain-syntax">--;</span>
|
||||
|
||||
|
|
@ -267,7 +267,7 @@ been supplied; \(x\) of course is variable number 0.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">current_interpretation_as_infs</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ciawo</span><span class="plain-syntax">; </span><span class="identifier-syntax">current_interpretation_as_spec</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ciats</span><span class="plain-syntax">;</span>
|
||||
</pre>
|
||||
<ul class="endnotetexts"><li>This code is used in <a href="1-ap.html#SP7">§7</a>.</li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>§8. Main procedure. </b>As can be seen, <span class="extract"><span class="extract-syntax">Propositions::Assert::prop_true_in_model</span></span> is a simple procedure. After a little
|
||||
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>§8. Main procedure. </b>As can be seen, <span class="extract"><span class="extract-syntax">Assert::prop_true_in_model</span></span> is a simple procedure. After a little
|
||||
fuss to check that everything is set up right, we simply run through the
|
||||
proposition one atom at a time.
|
||||
</p>
|
||||
|
|
@ -289,7 +289,7 @@ its nesting in negation brackets, which is nice and easy to write:
|
|||
</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">Propositions::Assert::prop_true_in_model</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">Propositions::Assert::prop_true_in_model</span></span>:<br/><a href="1-ap.html#SP3">§3</a>, <a href="1-ap.html#SP7">§7</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">Assert::prop_true_in_model</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">Assert::prop_true_in_model</span></span>:<br/><a href="1-ap.html#SP3">§3</a>, <a href="1-ap.html#SP7">§7</a></span></button><span class="plain-syntax">(</span><span class="identifier-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="reserved-syntax">return</span><span class="plain-syntax">;</span>
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-ap.html#SP8_1" class="named-paragraph-link"><span class="named-paragraph">Record the proposition in the debugging log</span><span class="named-paragraph-number">8.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">Propositions::contains_nonexistence_quantifier</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">))</span>
|
||||
|
|
@ -552,8 +552,8 @@ these kind atoms.
|
|||
|
||||
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="1-ap.html#SP8_7_2" class="named-paragraph-link"><span class="named-paragraph">Determine the BP and terms to be asserted</span><span class="named-paragraph-number">8.7.2</span></a></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">spec0</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP10" class="function-link"><span class="function-syntax">Propositions::Assert::spec_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt0</span><span class="plain-syntax">), *</span><span class="identifier-syntax">spec1</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP10" class="function-link"><span class="function-syntax">Propositions::Assert::spec_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt1</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj0</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP11" class="function-link"><span class="function-syntax">Propositions::Assert::subject_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt0</span><span class="plain-syntax">), *</span><span class="identifier-syntax">subj1</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP11" class="function-link"><span class="function-syntax">Propositions::Assert::subject_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt1</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">spec0</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP10" class="function-link"><span class="function-syntax">Assert::spec_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt0</span><span class="plain-syntax">), *</span><span class="identifier-syntax">spec1</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP10" class="function-link"><span class="function-syntax">Assert::spec_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt1</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">subj0</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP11" class="function-link"><span class="function-syntax">Assert::subject_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt0</span><span class="plain-syntax">), *</span><span class="identifier-syntax">subj1</span><span class="plain-syntax"> = </span><a href="1-ap.html#SP11" class="function-link"><span class="function-syntax">Assert::subject_of_term</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pt1</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">subj0</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">spec0</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) </span><span class="identifier-syntax">spec0</span><span class="plain-syntax"> = </span><a href="4-is.html#SP17" class="function-link"><span class="function-syntax">InferenceSubjects::as_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj0</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">subj1</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">spec1</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">)) </span><span class="identifier-syntax">spec1</span><span class="plain-syntax"> = </span><a href="4-is.html#SP17" class="function-link"><span class="function-syntax">InferenceSubjects::as_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj1</span><span class="plain-syntax">);</span>
|
||||
|
||||
|
|
@ -562,8 +562,8 @@ these kind atoms.
|
|||
<span class="plain-syntax"> #</span><span class="identifier-syntax">endif</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K0</span><span class="plain-syntax"> = </span><span class="identifier-syntax">BinaryPredicates::term_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">bp</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">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">K1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">BinaryPredicates::term_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">bp</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">Kinds::Behaviour::is_subkind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">K0</span><span class="plain-syntax">)) </span><a href="1-ap.html#SP9" class="function-link"><span class="function-syntax">Propositions::Assert::cautiously_set_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj0</span><span class="plain-syntax">, </span><span class="identifier-syntax">K0</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">Kinds::Behaviour::is_subkind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">K1</span><span class="plain-syntax">)) </span><a href="1-ap.html#SP9" class="function-link"><span class="function-syntax">Propositions::Assert::cautiously_set_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj1</span><span class="plain-syntax">, </span><span class="identifier-syntax">K1</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">Kinds::Behaviour::is_subkind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">K0</span><span class="plain-syntax">)) </span><a href="1-ap.html#SP9" class="function-link"><span class="function-syntax">Assert::cautiously_set_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj0</span><span class="plain-syntax">, </span><span class="identifier-syntax">K0</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">Kinds::Behaviour::is_subkind_of_object</span><span class="plain-syntax">(</span><span class="identifier-syntax">K1</span><span class="plain-syntax">)) </span><a href="1-ap.html#SP9" class="function-link"><span class="function-syntax">Assert::cautiously_set_kind</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">subj1</span><span class="plain-syntax">, </span><span class="identifier-syntax">K1</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
|
||||
<span class="plain-syntax"> }</span>
|
||||
<span class="plain-syntax"> #</span><span class="identifier-syntax">endif</span>
|
||||
|
|
@ -645,7 +645,7 @@ need to risk setting the kind here at this stage.
|
|||
</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">Propositions::Assert::cautiously_set_kind</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">Propositions::Assert::cautiously_set_kind</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">inst</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">k</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::cautiously_set_kind</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">Assert::cautiously_set_kind</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">inst</span><span class="plain-syntax">, </span><span class="identifier-syntax">kind</span><span class="plain-syntax"> *</span><span class="identifier-syntax">k</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">inst</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">k</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="plain-syntax"> #</span><span class="identifier-syntax">ifdef</span><span class="plain-syntax"> </span><span class="identifier-syntax">IF_MODULE</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">k</span><span class="plain-syntax">, </span><span class="identifier-syntax">K_thing</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -670,7 +670,7 @@ slate — that was its whole purpose. So the only case left is a constant:
|
|||
</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">Propositions::Assert::spec_of_term</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">Propositions::Assert::spec_of_term</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">) {</span>
|
||||
<span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="function-syntax">Assert::spec_of_term</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">Assert::spec_of_term</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">function</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pt</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">current_interpretation_as_spec</span><span class="plain-syntax">[</span><span class="identifier-syntax">pt</span><span class="plain-syntax">.</span><span class="identifier-syntax">variable</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="identifier-syntax">constant</span><span class="plain-syntax">;</span>
|
||||
|
|
@ -692,7 +692,7 @@ but just in case.
|
|||
</p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="function-syntax">Propositions::Assert::subject_of_term</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">Propositions::Assert::subject_of_term</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_term</span><span class="plain-syntax"> </span><span class="identifier-syntax">pt</span><span class="plain-syntax">) {</span>
|
||||
<span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="function-syntax">Assert::subject_of_term</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">Assert::subject_of_term</span></span>:<br/><a href="1-ap.html#SP8_7">§8.7</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">function</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">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">pt</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">current_interpretation_as_infs</span><span class="plain-syntax">[</span><span class="identifier-syntax">pt</span><span class="plain-syntax">.</span><span class="identifier-syntax">variable</span><span class="plain-syntax">];</span>
|
||||
|
||||
|
|
@ -723,7 +723,7 @@ necessary for the implications code to work.)
|
|||
</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">Propositions::Assert::testable_at_compile_time</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">Propositions::Assert::testable_at_compile_time</span></span>:<br/><a href="1-ap.html#SP13">§13</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">Assert::testable_at_compile_time</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">Assert::testable_at_compile_time</span></span>:<br/><a href="1-ap.html#SP13">§13</a></span></button><span class="plain-syntax">(</span><span class="identifier-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">pl</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">pl</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">switch</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
|
|
@ -751,8 +751,8 @@ necessary for the implications code to work.)
|
|||
</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">Propositions::Assert::test_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">about</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="1-ap.html#SP12" class="function-link"><span class="function-syntax">Propositions::Assert::testable_at_compile_time</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">NOT_APPLICABLE</span><span class="plain-syntax">;</span>
|
||||
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">Assert::test_at_compile_time</span><span class="plain-syntax">(</span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">about</span><span class="plain-syntax">) {</span>
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="1-ap.html#SP12" class="function-link"><span class="function-syntax">Assert::testable_at_compile_time</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">NOT_APPLICABLE</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">pl</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">pl</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">switch</span><span class="plain-syntax">(</span><span class="identifier-syntax">pl</span><span class="plain-syntax">-></span><span class="identifier-syntax">element</span><span class="plain-syntax">) {</span>
|
||||
|
|
|
|||
|
|
@ -163,7 +163,7 @@ possible values these are.)
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Abstract::to_create_something</span><span class="plain-syntax">(</span><span class="identifier-syntax">NULL</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::concatenate</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">Propositions::Abstract::to_make_a_kind</span><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">));</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Propositions::Assert::assert_true</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Assert::true</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">prevailing_mood</span><span class="plain-syntax">);</span>
|
||||
|
||||
<span class="plain-syntax"> </span><span class="reserved-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax"> = </span><a href="3-vp.html#SP1" class="function-link"><span class="function-syntax">Properties::Valued::obtain</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">W</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">prn</span><span class="plain-syntax">-></span><span class="element-syntax">either_or</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
|
||||
|
|
|
|||
|
|
@ -268,7 +268,7 @@ around), but not to break one.
|
|||
<span class="plain-syntax"> </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">parity</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">certainty</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">AdjectivalPredicates::new_atom_on_x</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><a href="3-ep.html#SP8" class="function-link"><span class="function-syntax">Properties::EitherOr::get_aph</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">), (</span><span class="identifier-syntax">parity</span><span class="plain-syntax">)?</span><span class="identifier-syntax">FALSE:TRUE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Propositions::Assert::assert_true_about</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">certainty</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Assert::true_about</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">certainty</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>§10. Compilation. </b>Inform 6 provides "attributes" as a faster-access, more memory-efficient
|
||||
|
|
|
|||
|
|
@ -291,7 +291,7 @@ all to work; the following keep a flag to mark that.
|
|||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Properties::Valued::assert</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">Properties::Valued::assert</span></span>:<br/>Indefinite Appearance - <a href="3-ia.html#SP1">§1</a>, <a href="3-ia.html#SP2">§2</a><br/>Instance Counting - <a href="4-ic.html#SP11_1">§11.1</a>, <a href="4-ic.html#SP11_3_1">§11.3.1</a>, <a href="4-ic.html#SP11_3_2">§11.3.2</a>, <a href="4-ic.html#SP11_3_3">§11.3.3</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">property</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prn</span><span class="plain-syntax">, </span><span class="reserved-syntax">inference_subject</span><span class="plain-syntax"> *</span><span class="identifier-syntax">owner</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><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">certainty</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">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Abstract::to_set_property</span><span class="plain-syntax">(</span><span class="identifier-syntax">prn</span><span class="plain-syntax">, </span><span class="identifier-syntax">val</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Propositions::Assert::assert_true_about</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">certainty</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><a href="1-ap.html#SP4" class="function-link"><span class="function-syntax">Assert::true_about</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">owner</span><span class="plain-syntax">, </span><span class="identifier-syntax">certainty</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<p class="commentary firstcommentary"><a id="SP11" class="paragraph-anchor"></a><b>§11. Compilation. </b>When we compile the value of a valued property, the following is called.
|
||||
|
|
|
|||
|
|
@ -12,6 +12,11 @@
|
|||
<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">
|
||||
<link href="../docs-assets/Colours.css" rel="stylesheet" rev="stylesheet" type="text/css">
|
||||
|
||||
</head>
|
||||
|
|
@ -64,7 +69,7 @@
|
|||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">knowledge</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 knowledge module's role and abilities.</p>
|
||||
|
||||
<ul class="toc"><li><a href="P-wtmd.html#SP1">§1. Prerequisites</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. The Model</a></li></ul><hr class="tocbar">
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. Prerequisites. </b>The knowledge module is a part of the Inform compiler toolset. It is
|
||||
presented as a literate program or "web". Before diving in:
|
||||
|
|
@ -80,6 +85,68 @@ 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. The Model. </b>This module's task is to build the "model world", the initial state of the
|
||||
world as it is chosen by an Inform author.<sup id="fnref:1"><a href="#fn:1" rel="footnote">1</a></sup> This consists of:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● Kinds, such as "vehicle", created in source text.
|
||||
</li><li>● Instances of kinds, such as a specific lorry in a fictional world being
|
||||
created with Inform.
|
||||
</li><li>● Permanently existing variables, which have kinds and initial values.
|
||||
</li><li>● Either-or properties, which individual instances might or might not have:
|
||||
for example, the lorry might be "parked" or "not parked".
|
||||
</li><li>● Properties with values, which some instances will have and some will not,
|
||||
and with differing values: for example, the colour of the lorry might be "yellow".
|
||||
</li><li>● Relationships between instances. For example, a specific person might
|
||||
"know how to drive" the yellow lorry, or might not.
|
||||
</li></ul>
|
||||
<p class="commentary">But the model does not contain:
|
||||
</p>
|
||||
|
||||
<ul class="items"><li>● Kinds, such as "number", built in to Inform.<sup id="fnref:2"><a href="#fn:2" rel="footnote">2</a></sup>
|
||||
</li><li>● Values, such as the number 176, which exist without anyone getting to
|
||||
choose whether they should exist or not.
|
||||
</li><li>● Temporary variables used during phrases or activities, but not existing
|
||||
at the start of play.
|
||||
</li><li>● Adjectives such as "even" as applied to numbers, or "empty" as applied
|
||||
to containers, whose truth or falsity is determined by something other than
|
||||
the author's whim. An author cannot choose that 176 is odd, and whether a
|
||||
container is empty depends only on whether there is something in it.
|
||||
</li><li>● Relationships which are, similarly, determined by an algorithm and not
|
||||
by a specific authorial choice. Like it or not, 176 is "greater than" 8.
|
||||
</li></ul>
|
||||
<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> The term "model" is drawn partly from interactive fiction, but also from
|
||||
model theory in the sense of logic, where a "model" is a specific solution
|
||||
showing that a set of logical propositions can all simultaneously be true.
|
||||
<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> Properly speaking, kinds created by Neptune files inside kits rather than
|
||||
being declared in source text.
|
||||
<a href="#fnref:2" title="return to text"> ↩</a></p></li></ul>
|
||||
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>§3. </b>The model is constructed entirely from a stream of logical propositions
|
||||
sent here by the <a href="../assertions-module/index.html" class="internal">assertions</a> module. Those propositions may be mutually
|
||||
inconsistent — either flatly contradictory or just impossible to reconcile.
|
||||
</p>
|
||||
|
||||
<p class="commentary">The stream of supposed truthful statements comes to this module through calls
|
||||
to either <a href="1-ap.html#SP4" class="internal">Assert::true</a> or <a href="1-ap.html#SP4" class="internal">Assert::true_about</a>. These reduce a
|
||||
proposition to a set of facts concerning things in the model; as we have
|
||||
seen, the model includes kinds, variables, instances and relations, and so
|
||||
we need a unified type for "something you can know a fact about". That
|
||||
type is called <a href="4-is.html#SP4" class="internal">inference_subject</a>. Each subject has its own list of known
|
||||
facts: we call such a fact an <a href="4-inf.html#SP5" class="internal">inference</a> because it has (usually) been
|
||||
inferred from a proposition.
|
||||
</p>
|
||||
|
||||
<p class="commentary"><a href="2-ins.html" class="internal">Chapter 2: Property Owners</a> implements our system of properties: each different value
|
||||
or either-or property is a <a href="3-prp.html#SP1" class="internal">property</a> object. There might be a puritan
|
||||
case for abolishing this type in favour of regarding either-or properties
|
||||
as special cases of <span class="extract"><span class="extract-syntax">unary_predicate</span></span> and value properties as special cases
|
||||
of <span class="extract"><span class="extract-syntax">binary_predicate</span></span> (by identifying a predicate with its setting relation),
|
||||
but I do not think this would clarify anything.
|
||||
</p>
|
||||
|
||||
<p class="commentary"><a href="3-prp.html" class="internal">Chapter 3: Properties</a> then covers <a href="4-is.html" class="internal">Inference Subjects</a> and their <a href="4-inf.html" class="internal">Inferences</a>.
|
||||
</p>
|
||||
|
||||
<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="progresschapter"><a href="1-km.html">1</a></li><li class="progresschapter"><a href="2-ins.html">2</a></li><li class="progresschapter"><a href="3-prp.html">3</a></li><li class="progresschapter"><a href="4-is.html">4</a></li><li class="progressnext"><a href="1-km.html">❯</a></li></ul></div>
|
||||
</nav><!--End of weave-->
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@
|
|||
<main role="main">
|
||||
<!--Weave of 'Multimedia Module' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#1">Chapter 1: Starting Up</a></li><li><b>Multimedia Module</b></li></ul></div>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#1">Chapter 1: Starting Up</a></li><li><b>Multimedia Module</b></li></ul></div>
|
||||
<p class="purpose">Setting up the use of this module.</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b>This section simoly sets up the module in ways expected by <a href="../../../inweb/docs/foundation-module/index.html" class="internal">foundation</a>, and
|
||||
|
|
|
|||
|
|
@ -61,16 +61,16 @@
|
|||
<main role="main">
|
||||
<!--Weave of 'Multimedia Special Meanings' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#1">Chapter 1: Starting Up</a></li><li><b>Multimedia Special Meanings</b></li></ul></div>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#1">Chapter 1: Starting Up</a></li><li><b>Multimedia Special Meanings</b></li></ul></div>
|
||||
<p class="purpose">Setting up the use of this module.</p>
|
||||
|
||||
<p class="commentary firstcommentary"><a id="SP1" class="paragraph-anchor"></a><b>§1. </b></p>
|
||||
|
||||
<pre class="displayed-code all-displayed-code code-font">
|
||||
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">MultimediaMeanings::bootstrap</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-fgr.html#SP7" class="function-link"><span class="function-syntax">PL::Figures::new_figure_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-figure"</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-se.html#SP6" class="function-link"><span class="function-syntax">PL::Sounds::new_sound_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-sound"</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-ef.html#SP9" class="function-link"><span class="function-syntax">PL::Files::new_file_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-file"</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-fgr.html#SP7" class="function-link"><span class="function-syntax">PL::Figures::new_figure_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-figure"</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-se.html#SP6" class="function-link"><span class="function-syntax">PL::Sounds::new_sound_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-sound"</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">SpecialMeanings::declare</span><span class="plain-syntax">(</span><a href="2-ef.html#SP9" class="function-link"><span class="function-syntax">PL::Files::new_file_SMF</span></a><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"new-file"</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax">}</span>
|
||||
</pre>
|
||||
<nav role="progress"><div class="progresscontainer">
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ function togglePopup(material_id) {
|
|||
<main role="main">
|
||||
<!--Weave of 'External Files' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>External Files</b></li></ul></div>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>External Files</b></li></ul></div>
|
||||
<p class="purpose">To register the names associated with external files, and build the small I6 arrays associated with each.</p>
|
||||
|
||||
<ul class="toc"><li><a href="2-ef.html#SP10">§10. I6 arrays of file structures</a></li><li><a href="2-ef.html#SP11">§11. External Files Index</a></li></ul><hr class="tocbar">
|
||||
|
|
@ -328,7 +328,7 @@ letters or digits, with the first being a letter.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_exf_creations</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Abstract::to_create_something</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">K_external_file</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_exf_creations</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">external_file</span><span class="plain-syntax"> *</span><span class="identifier-syntax">exf</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RETRIEVE_POINTER_external_file</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Instances::get_connection</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">));</span>
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ function togglePopup(material_id) {
|
|||
<main role="main">
|
||||
<!--Weave of 'Figures' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>Figures</b></li></ul></div>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>Figures</b></li></ul></div>
|
||||
<p class="purpose">To register the names associated with picture resource numbers, which are defined to allow the final story file to display pictures, and to produce the thumbnail index of figures.</p>
|
||||
|
||||
<ul class="toc"><li><a href="2-fgr.html#SP11">§11. Blurb and manifest</a></li><li><a href="2-fgr.html#SP15">§15. Thumbnail Index</a></li></ul><hr class="tocbar">
|
||||
|
|
@ -155,13 +155,13 @@ within the application.
|
|||
<pre class="Preform-displayed-code all-displayed-code code-font">
|
||||
<span class="Preform-function-syntax"><new-figure-sentence-object></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><definite-article></span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><new-figure-sentence-object-unarticled></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 2 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><new-figure-sentence-object-unarticled></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"><new-figure-sentence-object-unarticled></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"><new-figure-sentence-object-unarticled></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">file</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><np-unparsed></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { TRUE, RP[1] }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">file</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><np-unparsed></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { TRUE, RP[1] }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><nounphrase-figure></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">figure</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, Diagrams::new_UNPARSED_NOUN(W) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">figure</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, Diagrams::new_UNPARSED_NOUN(W) }</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="SP7" class="paragraph-anchor"></a><b>§7. </b></p>
|
||||
|
|
@ -247,7 +247,7 @@ is no need to translate this to other languages.)
|
|||
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_figure_creations</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Abstract::to_create_something</span><span class="plain-syntax">(</span><span class="identifier-syntax">K_figure_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_figure_creations</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">blorb_figure</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bf</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RETRIEVE_POINTER_blorb_figure</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Instances::get_connection</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">));</span>
|
||||
|
|
|
|||
|
|
@ -70,7 +70,7 @@ function togglePopup(material_id) {
|
|||
<main role="main">
|
||||
<!--Weave of 'Sound Effects' generated by Inweb-->
|
||||
<div class="breadcrumbs">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>Sound Effects</b></li></ul></div>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><a href="index.html">multimedia</a></li><li><a href="index.html#2">Chapter 2: Multimedia Features</a></li><li><b>Sound Effects</b></li></ul></div>
|
||||
<p class="purpose">To register the names associated with sound resource numbers, which are defined to allow the final story file to play sound effects, and to produce the index of sound effects.</p>
|
||||
|
||||
<ul class="toc"><li><a href="2-se.html#SP9">§9. Blurb and manifest</a></li><li><a href="2-se.html#SP13">§13. Sounds Index</a></li></ul><hr class="tocbar">
|
||||
|
|
@ -146,13 +146,13 @@ within the application.
|
|||
<pre class="Preform-displayed-code all-displayed-code code-font">
|
||||
<span class="Preform-function-syntax"><new-sound-sentence-object></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><definite-article></span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><new-sound-sentence-object-unarticled></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 2 }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><new-sound-sentence-object-unarticled></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"><new-sound-sentence-object-unarticled></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"><new-sound-sentence-object-unarticled></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">file</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><np-unparsed></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { TRUE, RP[1] }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">file</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax"><np-unparsed></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==></span><span class="Preform-plain-syntax"> { TRUE, RP[1] }</span>
|
||||
|
||||
<span class="Preform-function-syntax"><nounphrase-sound></span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">::=</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">sound</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, Diagrams::new_UNPARSED_NOUN(W) }</span>
|
||||
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">sound</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, Diagrams::new_UNPARSED_NOUN(W) }</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="SP6" class="paragraph-anchor"></a><b>§6. </b></p>
|
||||
|
|
@ -230,7 +230,7 @@ within the application.
|
|||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_sound_creations</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">pcalc_prop</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prop</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Propositions::Abstract::to_create_something</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">K_sound_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">F</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Propositions::Assert::assert_true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Assert::true</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop</span><span class="plain-syntax">, </span><span class="identifier-syntax">CERTAIN_CE</span><span class="plain-syntax">);</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">allow_sound_creations</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">blorb_sound</span><span class="plain-syntax"> *</span><span class="identifier-syntax">bs</span><span class="plain-syntax"> = </span><span class="identifier-syntax">RETRIEVE_POINTER_blorb_sound</span><span class="plain-syntax">(</span>
|
||||
<span class="plain-syntax"> </span><span class="identifier-syntax">Instances::get_connection</span><span class="plain-syntax">(</span><span class="identifier-syntax">latest_instance</span><span class="plain-syntax">));</span>
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@
|
|||
</ul>
|
||||
</nav>
|
||||
<main role="main">
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7 Modules</a></li><li><b>multimedia</b></li></ul>
|
||||
<ul class="crumbs"><li><a href="../index.html">Home</a></li><li><a href="../compiler.html">Inform7</a></li><li><b>multimedia</b></li></ul>
|
||||
<p class="purpose">A multimedia extension module for Inform. This is version 1.</p>
|
||||
<hr>
|
||||
<div class="contentspage">
|
||||
|
|
|
|||
|
|
@ -1,35 +1,36 @@
|
|||
100.0% in inform7 run
|
||||
66.6% in compilation to Inter
|
||||
25.5% in //Phrases::Manager::compile_first_block//
|
||||
8.5% in //Phrases::Manager::compile_as_needed//
|
||||
67.0% in compilation to Inter
|
||||
25.6% in //Phrases::Manager::compile_first_block//
|
||||
8.7% in //Phrases::Manager::compile_as_needed//
|
||||
7.0% in //Strings::compile_responses//
|
||||
6.2% in //World::Compile::compile//
|
||||
3.9% in //MajorNodes::pre_pass//
|
||||
3.4% in //MajorNodes::pass_1//
|
||||
6.5% in //World::Compile::compile//
|
||||
3.8% in //MajorNodes::pre_pass//
|
||||
3.3% in //MajorNodes::pass_1//
|
||||
2.0% in //Phrases::Manager::RulePrintingRule_routine//
|
||||
1.8% in //Phrases::Manager::rulebooks_array//
|
||||
0.9% in //RTVerbs::ConjugateVerb//
|
||||
0.7% in //Phrases::Manager::traverse//
|
||||
1.0% in //RTVerbs::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 //RTRelations::compile_defined_relations//
|
||||
0.1% in //Kinds::RunTime::compile_data_type_support_routines//
|
||||
0.1% in //PL::Parsing::Verbs::compile_all//
|
||||
0.1% in //RTRelations::compile_defined_relations//
|
||||
0.1% in //Task::make_built_in_kind_constructors//
|
||||
3.6% not specifically accounted for
|
||||
30.6% in running Inter pipeline
|
||||
10.0% in step preparation
|
||||
10.7% in step preparation
|
||||
9.8% in inter step 2/12: link
|
||||
7.1% in inter step 12/12: generate inform6 -> auto.inf
|
||||
7.2% in inter step 12/12: generate inform6 -> auto.inf
|
||||
0.3% in inter step 9/12: make-identifiers-unique
|
||||
0.1% in inter step 10/12: reconcile-verbs
|
||||
0.1% in inter step 11/12: eliminate-redundant-labels
|
||||
0.1% in inter step 4/12: parse-linked-matter
|
||||
0.1% in inter step 5/12: resolve-conditional-compilation
|
||||
0.1% in inter step 6/12: assimilate
|
||||
0.1% in inter step 7/12: resolve-external-symbols
|
||||
0.1% in inter step 8/12: inspect-plugs
|
||||
2.1% not specifically accounted for
|
||||
1.3% not specifically accounted for
|
||||
2.0% in supervisor
|
||||
0.6% not specifically accounted for
|
||||
0.4% not specifically accounted for
|
||||
|
|
|
|||
|
|
@ -332,7 +332,7 @@ table: do they get permission as well? We're going to say that they do.
|
|||
property *P = NULL;
|
||||
@<Ensure that a property with the same name as the column name exists@>;
|
||||
if (global_pass_state.pass == 1)
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_provide_property(P),
|
||||
Kinds::Knowledge::as_subject(t->kind_defined_in_this_table),
|
||||
prevailing_mood);
|
||||
|
|
|
|||
|
|
@ -361,13 +361,13 @@ differently as a result.
|
|||
if (count <= 2) prn = Properties::EitherOr::obtain(FW, owner_infs);
|
||||
else prn = Properties::Conditions::new(owner_infs, CNW, the_list,
|
||||
&already_created_instances);
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_provide_property(prn),
|
||||
owner_infs, prevailing_mood);
|
||||
|
||||
@<Make the second option an either/or property which negates the first@> =
|
||||
property *prnbar = Properties::EitherOr::obtain(SW, owner_infs);
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_provide_property(prnbar),
|
||||
owner_infs, prevailing_mood);
|
||||
Properties::EitherOr::make_negations(prn, prnbar);
|
||||
|
|
@ -414,7 +414,7 @@ or sky blue pink".
|
|||
@<Disallow this option name if it clashes with something non-adjectival@>;
|
||||
@<Disallow this option name if it clashes with an either-or@>;
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(cnd_kind, PW);
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
}
|
||||
|
||||
@ The interesting thing here is that we do allow name-clashes with either/or
|
||||
|
|
|
|||
|
|
@ -384,7 +384,7 @@ void RelationRequests::new(binary_predicate *bp, relation_request *RR) {
|
|||
Kinds::RunTime::ensure_basic_heap_present();
|
||||
} else {
|
||||
if (provide_prn)
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_provide_property(prn), storage_infs, prevailing_mood);
|
||||
@<Add in the reducing functions@>;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1497,12 +1497,12 @@ the "creation proposition" of Y, and we now assert this to be true about X.
|
|||
"at once, and it would be clearer to write it as two sentences?");
|
||||
return;
|
||||
}
|
||||
Propositions::Assert::assert_true_about(prop, left_object, prevailing_mood);
|
||||
Assert::true_about(prop, left_object, prevailing_mood);
|
||||
} else {
|
||||
kind *K = Specifications::to_kind(Node::get_evaluation(py));
|
||||
if (K) {
|
||||
pcalc_prop *prop = KindPredicates::new_atom(K, Terms::new_variable(0));
|
||||
Propositions::Assert::assert_true_about(prop, left_object, prevailing_mood);
|
||||
Assert::true_about(prop, left_object, prevailing_mood);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ void Assertions::Implications::new(parse_node *px, parse_node *py) {
|
|||
#endif
|
||||
|
||||
@<Check that the premiss involves only either/or properties and/or a kind@> =
|
||||
if (Propositions::Assert::testable_at_compile_time(premiss) == FALSE) {
|
||||
if (Assert::testable_at_compile_time(premiss) == FALSE) {
|
||||
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_BadImplicationDomain),
|
||||
"that's an implication where the condition to qualify is not "
|
||||
"one that I can determine in advance of the start of play",
|
||||
|
|
@ -229,7 +229,7 @@ int Assertions::Implications::check_implications_of(inference_subject *domain,
|
|||
possession_marker *pom = Properties::get_possession_marker(conclusion_prop);
|
||||
@<Check that the conclusion is not redundant or irrelevant@>;
|
||||
|
||||
int candidate_qualifies = Propositions::Assert::test_at_compile_time(imp->if_spec, candidate);
|
||||
int candidate_qualifies = Assert::test_at_compile_time(imp->if_spec, candidate);
|
||||
|
||||
if (candidate_qualifies) {
|
||||
LOGIF(IMPLICATIONS, "PASS: changing property $Y of $j\n", conclusion_prop, candidate);
|
||||
|
|
@ -267,5 +267,5 @@ int Assertions::Implications::check_implications_of(inference_subject *domain,
|
|||
} else {
|
||||
prop = Propositions::concatenate(prop, AdjectivalPredicates::new_atom_on_x(aph, FALSE));
|
||||
}
|
||||
Propositions::Assert::assert_true_about(prop, candidate, CERTAIN_CE);
|
||||
Assert::true_about(prop, candidate, CERTAIN_CE);
|
||||
return TRUE;
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ automatically creates it.
|
|||
if ((K) && (Kinds::Knowledge::has_properties(K) == FALSE))
|
||||
@<Disallow this kind as a new owner of a value property@>;
|
||||
property *prn = Properties::Valued::obtain(Node::get_text(p));
|
||||
Propositions::Assert::assert_true_about(Propositions::Abstract::to_provide_property(prn),
|
||||
Assert::true_about(Propositions::Abstract::to_provide_property(prn),
|
||||
owner_infs, prevailing_mood);
|
||||
return prn;
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ void Assertions::PropertyKnowledge::igv_dash(nonlocal_variable *q, parse_node *v
|
|||
|
||||
parse_node *var = Lvalues::new_actual_NONLOCAL_VARIABLE(q);
|
||||
pcalc_prop *prop = Propositions::Abstract::to_set_relation(R_equality, NULL, var, NULL, val);
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
}
|
||||
|
||||
@ On the face of it, the following looks unnecessary, and it nearly is.
|
||||
|
|
@ -102,7 +102,7 @@ void Assertions::PropertyKnowledge::assert_property_value_from_property_subtree_
|
|||
inference_subject *owner, parse_node *val_subtree) {
|
||||
pcalc_prop *prop = Propositions::Abstract::from_property_subtree(prn, val_subtree);
|
||||
if (owner == NULL) @<Issue a problem for an unrecognised property owner@>;
|
||||
Propositions::Assert::assert_true_about(prop, owner, prevailing_mood);
|
||||
Assert::true_about(prop, owner, prevailing_mood);
|
||||
}
|
||||
|
||||
void Assertions::PropertyKnowledge::assert_property_list(parse_node *owner_subtree, parse_node *list_subtree) {
|
||||
|
|
@ -125,7 +125,7 @@ void Assertions::PropertyKnowledge::assert_property_list(parse_node *owner_subtr
|
|||
kind *kind_clue = NULL;
|
||||
@<Work out the clue kind@>;
|
||||
pcalc_prop *prop = Propositions::Abstract::from_property_list(list_subtree, kind_clue);
|
||||
Propositions::Assert::assert_true_about(prop, owner, prevailing_mood);
|
||||
Assert::true_about(prop, owner, prevailing_mood);
|
||||
}
|
||||
|
||||
@ We pass the "clue kind" to obtain a proposition which includes an atom
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ void Assertions::Relational::assert_subtree_in_relationship(parse_node *value, p
|
|||
"than positive information. There's no need to tell me something "
|
||||
"like 'Here is nothing.': just don't put anything there.");
|
||||
} else {
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_put_here(),
|
||||
Node::get_subject(value), prevailing_mood);
|
||||
}
|
||||
|
|
@ -139,7 +139,7 @@ void Assertions::Relational::assert_relation_between_subtrees(parse_node *px, bi
|
|||
@<Normalise the two noun leaves@>;
|
||||
@<Impose a tedious restriction on relations between objects and values@>;
|
||||
|
||||
Propositions::Assert::assert_true(
|
||||
Assert::true(
|
||||
Propositions::Abstract::to_set_relation(bp, Node::get_subject(px), Node::get_evaluation(px), Node::get_subject(py), Node::get_evaluation(py)),
|
||||
prevailing_mood);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -602,7 +602,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
pcalc_prop *prop = Propositions::Abstract::to_create_something(K_object, W);
|
||||
if (is_a_kind)
|
||||
prop = Propositions::concatenate(prop, Propositions::Abstract::to_make_a_kind(K_object));
|
||||
Propositions::Assert::assert_true(prop, CERTAIN_CE);
|
||||
Assert::true(prop, CERTAIN_CE);
|
||||
|
||||
if (is_a_kind == FALSE) {
|
||||
recent_creation = latest_instance;
|
||||
|
|
@ -666,7 +666,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
@<Create a new kind of value@> =
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(NULL, W);
|
||||
prop = Propositions::concatenate(prop, Propositions::Abstract::to_make_a_kind(K_value));
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
val = Specifications::from_kind(latest_base_kind_of_value);
|
||||
|
||||
@<Create a new variable@> =
|
||||
|
|
@ -682,7 +682,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
prop = Propositions::concatenate(prop, Propositions::Abstract::to_make_a_const());
|
||||
else
|
||||
prop = Propositions::concatenate(prop, Propositions::Abstract::to_make_a_var());
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
if (NonlocalVariables::get_latest() == NULL) internal_error("failed to create");
|
||||
val = Lvalues::new_actual_NONLOCAL_VARIABLE(NonlocalVariables::get_latest());
|
||||
|
||||
|
|
@ -690,7 +690,7 @@ to abbreviated forms of object names are normally allowed.
|
|||
pcalc_prop *prop = Propositions::Abstract::to_create_something(create_as, W);
|
||||
pcalc_prop *such_that = Node::get_creation_proposition(governor);
|
||||
if (such_that) prop = Propositions::concatenate(prop, such_that);
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
val = Rvalues::from_instance(latest_instance);
|
||||
|
||||
@ Lastly: rulebooks and activities are not part of the model, because they would
|
||||
|
|
@ -930,7 +930,7 @@ to a different vehicle object.
|
|||
NW = Wordings::truncate(NW, 32); /* truncate to the maximum length */
|
||||
parse_node *pz = Node::new(PROPER_NOUN_NT);
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(instance_kind, NW);
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
new_instance = Instances::as_subject(latest_instance);
|
||||
if (named_after) {
|
||||
#ifdef IF_MODULE
|
||||
|
|
@ -1084,7 +1084,7 @@ void Assertions::Creator::stock_nl_kind(kind *K) {
|
|||
LOOP_OVER(L, inform_language) {
|
||||
pcalc_prop *prop =
|
||||
Propositions::Abstract::to_create_something(K, L->instance_name);
|
||||
Propositions::Assert::assert_true(prop, CERTAIN_CE);
|
||||
Assert::true(prop, CERTAIN_CE);
|
||||
L->nl_instance = latest_instance;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -41,7 +41,7 @@ pcalc_prop *Propositions::Abstract::prop_to_set_kind(kind *k) {
|
|||
|
||||
=
|
||||
void Propositions::Abstract::assert_kind_of_instance(instance *I, kind *k) {
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::prop_to_set_kind(k),
|
||||
Instances::as_subject(I), prevailing_mood);
|
||||
}
|
||||
|
|
@ -51,7 +51,7 @@ void Propositions::Abstract::assert_kind_of_subject(inference_subject *inst,
|
|||
kind *K = InferenceSubjects::domain(new);
|
||||
pcalc_prop *prop = KindPredicates::new_atom(K, Terms::new_variable(0));
|
||||
if (subject_to) prop = Propositions::concatenate(prop, subject_to);
|
||||
Propositions::Assert::assert_true_about(prop, inst, prevailing_mood);
|
||||
Assert::true_about(prop, inst, prevailing_mood);
|
||||
}
|
||||
|
||||
@ Now propositions to assert that relations hold:
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ void KindPredicatesRevisited::assert(up_family *self, unary_predicate *up,
|
|||
"which is too vague. You must say what kind it does have.");
|
||||
return;
|
||||
}
|
||||
inference_subject *subj = Propositions::Assert::subject_of_term(pl->terms[0]);
|
||||
inference_subject *subj = Assert::subject_of_term(pl->terms[0]);
|
||||
instance *ox = InferenceSubjects::as_object_instance(subj);
|
||||
if (ox) Instances::set_kind(ox, up->assert_kind);
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -77,9 +77,9 @@ void AdjectivalPredicates::assert(up_family *self, unary_predicate *up,
|
|||
adjective *aph = AdjectivalPredicates::to_adjective(up);
|
||||
int parity = (now_negated)?FALSE:TRUE, found;
|
||||
if (AdjectivalPredicates::parity(up) == FALSE) parity = (parity)?FALSE:TRUE;
|
||||
inference_subject *ox = Propositions::Assert::subject_of_term(pl->terms[0]);
|
||||
inference_subject *ox = Assert::subject_of_term(pl->terms[0]);
|
||||
|
||||
parse_node *ots = Propositions::Assert::spec_of_term(pl->terms[0]);
|
||||
parse_node *ots = Assert::spec_of_term(pl->terms[0]);
|
||||
|
||||
kind *domain_of_definition = InferenceSubjects::domain(ox);
|
||||
if (domain_of_definition == NULL) {
|
||||
|
|
@ -98,7 +98,7 @@ void AdjectivalPredicates::assert(up_family *self, unary_predicate *up,
|
|||
if (ox) found = Adjectives::Meanings::assert(aph, domain_of_definition, ox, NULL, parity);
|
||||
else found = Adjectives::Meanings::assert(aph, domain_of_definition, NULL, ots, parity);
|
||||
|
||||
if (found == FALSE) Propositions::Assert::issue_couldnt_problem(aph, parity);
|
||||
if (found == FALSE) Assert::issue_couldnt_problem(aph, parity);
|
||||
}
|
||||
|
||||
int AdjectivalPredicates::testable(up_family *self, unary_predicate *up) {
|
||||
|
|
|
|||
|
|
@ -205,7 +205,7 @@ int PL::Backdrops::backdrops_intervene_in_assertion(parse_node *px, parse_node *
|
|||
"which doesn't make sense. An individual backdrop can be 'everywhere', "
|
||||
"but here we're talking about a whole kind, and it's not allowed "
|
||||
"to talk about general locations of a whole kind of things at once.");
|
||||
else Propositions::Assert::assert_true_about(
|
||||
else Assert::true_about(
|
||||
Propositions::Abstract::to_put_everywhere(), left_subject, prevailing_mood);
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -151,7 +151,7 @@ void WherePredicates::assert_everywhere(up_family *self, unary_predicate *up,
|
|||
return;
|
||||
}
|
||||
#ifdef IF_MODULE
|
||||
inference_subject *subj = Propositions::Assert::subject_of_term(prop->terms[0]);
|
||||
inference_subject *subj = Assert::subject_of_term(prop->terms[0]);
|
||||
instance *ox = InferenceSubjects::as_object_instance(subj);
|
||||
PL::Backdrops::infer_presence_everywhere(ox);
|
||||
#endif
|
||||
|
|
@ -164,7 +164,7 @@ void WherePredicates::assert_everywhere(up_family *self, unary_predicate *up,
|
|||
#ifdef CORE_MODULE
|
||||
void WherePredicates::assert_nowhere(up_family *self, unary_predicate *up,
|
||||
int now_negated, pcalc_prop *prop) {
|
||||
inference_subject *subj = Propositions::Assert::subject_of_term(prop->terms[0]);
|
||||
inference_subject *subj = Assert::subject_of_term(prop->terms[0]);
|
||||
instance *ox = InferenceSubjects::as_object_instance(subj);
|
||||
if (now_negated) {
|
||||
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible),
|
||||
|
|
@ -193,7 +193,7 @@ problem aside for now.
|
|||
#ifdef CORE_MODULE
|
||||
void WherePredicates::assert_here(up_family *self, unary_predicate *up,
|
||||
int now_negated, pcalc_prop *prop) {
|
||||
inference_subject *subj = Propositions::Assert::subject_of_term(prop->terms[0]);
|
||||
inference_subject *subj = Assert::subject_of_term(prop->terms[0]);
|
||||
instance *ox = InferenceSubjects::as_object_instance(subj);
|
||||
if (now_negated) {
|
||||
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(BelievedImpossible),
|
||||
|
|
|
|||
|
|
@ -487,7 +487,7 @@ int PL::Spatial::spatial_intervene_in_assertion(parse_node *px, parse_node *py)
|
|||
"which doesn't make sense. An individual thing can be 'nowhere', "
|
||||
"but here we're talking about a whole kind, and it's not allowed "
|
||||
"to talk about general locations of a whole kind of things at once.");
|
||||
else Propositions::Assert::assert_true_about(
|
||||
else Assert::true_about(
|
||||
Propositions::Abstract::to_put_nowhere(), left_subject, prevailing_mood);
|
||||
return TRUE;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -672,7 +672,7 @@ void PL::Map::oneway_map_connection(instance *go_from, instance *go_to,
|
|||
if (bp == NULL) internal_error("map connection in non-direction");
|
||||
int x = prevailing_mood;
|
||||
prevailing_mood = certainty_level;
|
||||
Propositions::Assert::assert_true_about(
|
||||
Assert::true_about(
|
||||
Propositions::Abstract::to_set_simple_relation(bp, go_to),
|
||||
Instances::as_subject(go_from), certainty_level);
|
||||
prevailing_mood = x;
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
[Propositions::Assert::] Assert Propositions.
|
||||
[Assert::] Assert Propositions.
|
||||
|
||||
To declare that a given proposition is a true statement about the
|
||||
state of the world when play begins.
|
||||
|
|
@ -39,8 +39,8 @@ declared as literals in the source text: there is no need to analyse their
|
|||
meaning.
|
||||
|
||||
To build or change the model, we assert that propositions about it are true,
|
||||
using |Propositions::Assert::assert_true| or
|
||||
|Propositions::Assert::assert_true_about|. This is the only way to
|
||||
using |Assert::true| or
|
||||
|Assert::true_about|. This is the only way to
|
||||
create kinds, instances, global variables, and constant values, and also the
|
||||
only way to attach properties to objects, to set property values or
|
||||
the kind of a given object or the value of a global variable, or to declare
|
||||
|
|
@ -53,8 +53,8 @@ not to attach scent to anything or to relate any objects by admiring. The
|
|||
model world would then not have changed at all.) So creating new properties
|
||||
and new relations is not done by asserting propositions.
|
||||
|
||||
@ |Propositions::Assert::assert_true| asserts propositions in which all variables are
|
||||
bound (or which have no variables); |Propositions::Assert::assert_true_about| asserts
|
||||
@ |Assert::true| asserts propositions in which all variables are
|
||||
bound (or which have no variables); |Assert::true_about| asserts
|
||||
propositions in which $x$ is free but all other variables are bound, and
|
||||
substitutes either an object $O$ or a value $V$ into $x$ before asserting.
|
||||
These two procedures are the entire API, so to speak, for growing or changing
|
||||
|
|
@ -63,8 +63,8 @@ which takes assertion sentences in the source text and
|
|||
converts them into a series of propositions which it would like to make true.
|
||||
|
||||
Either way those requests come in, they all end up in the central
|
||||
|Propositions::Assert::prop_true_in_model| procedure, one of the most important choke points within
|
||||
Inform. |Propositions::Assert::prop_true_in_model| and its delegates -- routines to assert the
|
||||
|Assert::prop_true_in_model| procedure, one of the most important choke points within
|
||||
Inform. |Assert::prop_true_in_model| and its delegates -- routines to assert the
|
||||
truth of various adjectives or relations -- are allowed to call routines such
|
||||
as |Instances::set_kind| and |Instances::new| which are forbidden for use in the
|
||||
rest of Inform. These are guarded with the following macro, to ensure that
|
||||
|
|
@ -75,19 +75,19 @@ we don't accidentally break this rule:
|
|||
internal_error("protected model-affecting procedure used outside proposition assert");
|
||||
|
||||
= (early code)
|
||||
int ptim_recursion_depth = 0; /* depth of recursion of |Propositions::Assert::prop_true_in_model| */
|
||||
int ptim_recursion_depth = 0; /* depth of recursion of |Assert::prop_true_in_model| */
|
||||
|
||||
@h Entrance.
|
||||
This first entrance is a mere alias for the second.
|
||||
|
||||
=
|
||||
void Propositions::Assert::assert_true(pcalc_prop *prop, int certitude) {
|
||||
Propositions::Assert::prop_true_in_world_model_inner(prop, NULL, certitude);
|
||||
void Assert::true(pcalc_prop *prop, int certitude) {
|
||||
Assert::prop_true_in_world_model_inner(prop, NULL, certitude);
|
||||
}
|
||||
|
||||
void Propositions::Assert::assert_true_about(pcalc_prop *prop, inference_subject *infs,
|
||||
void Assert::true_about(pcalc_prop *prop, inference_subject *infs,
|
||||
int certitude) {
|
||||
Propositions::Assert::prop_true_in_world_model_inner(prop, infs, certitude);
|
||||
Assert::prop_true_in_world_model_inner(prop, infs, certitude);
|
||||
}
|
||||
|
||||
@ If we are working along a proposition and reach, say, $door(x)$, we
|
||||
|
|
@ -104,7 +104,7 @@ parse_node **current_interpretation_as_spec = NULL; /* must point to a 26-elemen
|
|||
=
|
||||
parse_node *last_couldnt_assert_at = NULL;
|
||||
|
||||
void Propositions::Assert::issue_couldnt_problem(adjective *aph, int parity) {
|
||||
void Assert::issue_couldnt_problem(adjective *aph, int parity) {
|
||||
if (last_couldnt_assert_at != current_sentence) {
|
||||
wording W = Adjectives::get_nominative_singular(aph);
|
||||
Problems::quote_source(1, current_sentence);
|
||||
|
|
@ -134,11 +134,11 @@ void Propositions::Assert::issue_couldnt_problem(adjective *aph, int parity) {
|
|||
|
||||
@ The second entrance, then, keeps track of the recursion depth but also
|
||||
ensures that the identification slate is always correct, stacking them
|
||||
so that an inner |Propositions::Assert::prop_true_in_model| has an independent slate from an outer
|
||||
so that an inner |Assert::prop_true_in_model| has an independent slate from an outer
|
||||
one.
|
||||
|
||||
=
|
||||
void Propositions::Assert::prop_true_in_world_model_inner(pcalc_prop *prop, inference_subject *subject,
|
||||
void Assert::prop_true_in_world_model_inner(pcalc_prop *prop, inference_subject *subject,
|
||||
int certainty) {
|
||||
inference_subject **saved_interpretation_as_infs = current_interpretation_as_infs;
|
||||
parse_node **saved_interpretation_as_spec = current_interpretation_as_spec;
|
||||
|
|
@ -150,7 +150,7 @@ void Propositions::Assert::prop_true_in_world_model_inner(pcalc_prop *prop, infe
|
|||
|
||||
ptim_recursion_depth++;
|
||||
|
||||
Propositions::Assert::prop_true_in_model(prop);
|
||||
Assert::prop_true_in_model(prop);
|
||||
|
||||
ptim_recursion_depth--;
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ been supplied; $x$ of course is variable number 0.
|
|||
current_interpretation_as_infs = ciawo; current_interpretation_as_spec = ciats;
|
||||
|
||||
@h Main procedure.
|
||||
As can be seen, |Propositions::Assert::prop_true_in_model| is a simple procedure. After a little
|
||||
As can be seen, |Assert::prop_true_in_model| is a simple procedure. After a little
|
||||
fuss to check that everything is set up right, we simply run through the
|
||||
proposition one atom at a time.
|
||||
|
||||
|
|
@ -186,7 +186,7 @@ That means we can simply assert each atom in turn, with a parity depending on
|
|||
its nesting in negation brackets, which is nice and easy to write:
|
||||
|
||||
=
|
||||
void Propositions::Assert::prop_true_in_model(pcalc_prop *prop) {
|
||||
void Assert::prop_true_in_model(pcalc_prop *prop) {
|
||||
if (prop == NULL) return;
|
||||
@<Record the proposition in the debugging log@>;
|
||||
if (Propositions::contains_nonexistence_quantifier(prop))
|
||||
|
|
@ -402,8 +402,8 @@ these kind atoms.
|
|||
|
||||
@<Determine the BP and terms to be asserted@>;
|
||||
|
||||
parse_node *spec0 = Propositions::Assert::spec_of_term(pt0), *spec1 = Propositions::Assert::spec_of_term(pt1);
|
||||
inference_subject *subj0 = Propositions::Assert::subject_of_term(pt0), *subj1 = Propositions::Assert::subject_of_term(pt1);
|
||||
parse_node *spec0 = Assert::spec_of_term(pt0), *spec1 = Assert::spec_of_term(pt1);
|
||||
inference_subject *subj0 = Assert::subject_of_term(pt0), *subj1 = Assert::subject_of_term(pt1);
|
||||
if ((subj0) && (spec0 == NULL)) spec0 = InferenceSubjects::as_constant(subj0);
|
||||
if ((subj1) && (spec1 == NULL)) spec1 = InferenceSubjects::as_constant(subj1);
|
||||
|
||||
|
|
@ -412,8 +412,8 @@ these kind atoms.
|
|||
#endif
|
||||
kind *K0 = BinaryPredicates::term_kind(bp, 0);
|
||||
kind *K1 = BinaryPredicates::term_kind(bp, 1);
|
||||
if (Kinds::Behaviour::is_subkind_of_object(K0)) Propositions::Assert::cautiously_set_kind(subj0, K0);
|
||||
if (Kinds::Behaviour::is_subkind_of_object(K1)) Propositions::Assert::cautiously_set_kind(subj1, K1);
|
||||
if (Kinds::Behaviour::is_subkind_of_object(K0)) Assert::cautiously_set_kind(subj0, K0);
|
||||
if (Kinds::Behaviour::is_subkind_of_object(K1)) Assert::cautiously_set_kind(subj1, K1);
|
||||
#ifdef IF_MODULE
|
||||
}
|
||||
#endif
|
||||
|
|
@ -483,7 +483,7 @@ things by default when we complete the model world anyway; so there is no
|
|||
need to risk setting the kind here at this stage.
|
||||
|
||||
=
|
||||
void Propositions::Assert::cautiously_set_kind(inference_subject *inst, kind *k) {
|
||||
void Assert::cautiously_set_kind(inference_subject *inst, kind *k) {
|
||||
if ((inst == NULL) || (k == NULL)) return;
|
||||
#ifdef IF_MODULE
|
||||
if (Kinds::eq(k, K_thing)) return;
|
||||
|
|
@ -507,7 +507,7 @@ and won't even try. We can evaluate a variable using the interpretation
|
|||
slate -- that was its whole purpose. So the only case left is a constant:
|
||||
|
||||
=
|
||||
parse_node *Propositions::Assert::spec_of_term(pcalc_term pt) {
|
||||
parse_node *Assert::spec_of_term(pcalc_term pt) {
|
||||
if (pt.function) return NULL;
|
||||
if (pt.variable >= 0) return current_interpretation_as_spec[pt.variable];
|
||||
return pt.constant;
|
||||
|
|
@ -527,7 +527,7 @@ type with a problem message. In practice the A-parser gets there first,
|
|||
but just in case.
|
||||
|
||||
=
|
||||
inference_subject *Propositions::Assert::subject_of_term(pcalc_term pt) {
|
||||
inference_subject *Assert::subject_of_term(pcalc_term pt) {
|
||||
if (pt.function) return NULL;
|
||||
if (pt.variable >= 0) return current_interpretation_as_infs[pt.variable];
|
||||
|
||||
|
|
@ -558,7 +558,7 @@ of a given inference subject at the current stage of the world model. (This is
|
|||
necessary for the implications code to work.)
|
||||
|
||||
=
|
||||
int Propositions::Assert::testable_at_compile_time(pcalc_prop *prop) {
|
||||
int Assert::testable_at_compile_time(pcalc_prop *prop) {
|
||||
TRAVERSE_VARIABLE(pl);
|
||||
TRAVERSE_PROPOSITION(pl, prop) {
|
||||
switch(pl->element) {
|
||||
|
|
@ -581,8 +581,8 @@ int Propositions::Assert::testable_at_compile_time(pcalc_prop *prop) {
|
|||
@ And the actual test:
|
||||
|
||||
=
|
||||
int Propositions::Assert::test_at_compile_time(pcalc_prop *prop, inference_subject *about) {
|
||||
if (Propositions::Assert::testable_at_compile_time(prop) == FALSE) return NOT_APPLICABLE;
|
||||
int Assert::test_at_compile_time(pcalc_prop *prop, inference_subject *about) {
|
||||
if (Assert::testable_at_compile_time(prop) == FALSE) return NOT_APPLICABLE;
|
||||
TRAVERSE_VARIABLE(pl);
|
||||
TRAVERSE_PROPOSITION(pl, prop) {
|
||||
switch(pl->element) {
|
||||
|
|
|
|||
|
|
@ -84,7 +84,7 @@ property *Properties::Conditions::new(inference_subject *infs, wording NW, parse
|
|||
pcalc_prop *prop = Propositions::Abstract::to_create_something(NULL, W);
|
||||
prop = Propositions::concatenate(prop,
|
||||
Propositions::Abstract::to_make_a_kind(K_value));
|
||||
Propositions::Assert::assert_true(prop, prevailing_mood);
|
||||
Assert::true(prop, prevailing_mood);
|
||||
|
||||
property *prn = Properties::Valued::obtain(W);
|
||||
prn->either_or = FALSE;
|
||||
|
|
|
|||
|
|
@ -192,7 +192,7 @@ void Properties::EitherOr::assert(property *prn,
|
|||
inference_subject *owner, int parity, int certainty) {
|
||||
pcalc_prop *prop = AdjectivalPredicates::new_atom_on_x(
|
||||
Properties::EitherOr::get_aph(prn), (parity)?FALSE:TRUE);
|
||||
Propositions::Assert::assert_true_about(prop, owner, certainty);
|
||||
Assert::true_about(prop, owner, certainty);
|
||||
}
|
||||
|
||||
@h Compilation.
|
||||
|
|
|
|||
|
|
@ -210,7 +210,7 @@ int Properties::Valued::is_used_for_non_typesafe_relation(property *prn) {
|
|||
void Properties::Valued::assert(property *prn, inference_subject *owner,
|
||||
parse_node *val, int certainty) {
|
||||
pcalc_prop *prop = Propositions::Abstract::to_set_property(prn, val);
|
||||
Propositions::Assert::assert_true_about(prop, owner, certainty);
|
||||
Assert::true_about(prop, owner, certainty);
|
||||
}
|
||||
|
||||
@h Compilation.
|
||||
|
|
|
|||
|
|
@ -14,3 +14,61 @@ and where functions have names like |Tags::add_by_name| rather than just |add_by
|
|||
(c) This module uses other modules drawn from the //compiler//, and also
|
||||
uses a module of utility functions called //foundation//.
|
||||
For more, see //foundation: A Brief Guide to Foundation//.
|
||||
|
||||
@h The Model.
|
||||
This module's task is to build the "model world", the initial state of the
|
||||
world as it is chosen by an Inform author.[1] This consists of:
|
||||
|
||||
(*) Kinds, such as "vehicle", created in source text.
|
||||
(*) Instances of kinds, such as a specific lorry in a fictional world being
|
||||
created with Inform.
|
||||
(*) Permanently existing variables, which have kinds and initial values.
|
||||
(*) Either-or properties, which individual instances might or might not have:
|
||||
for example, the lorry might be "parked" or "not parked".
|
||||
(*) Properties with values, which some instances will have and some will not,
|
||||
and with differing values: for example, the colour of the lorry might be "yellow".
|
||||
(*) Relationships between instances. For example, a specific person might
|
||||
"know how to drive" the yellow lorry, or might not.
|
||||
|
||||
But the model does not contain:
|
||||
|
||||
(*) Kinds, such as "number", built in to Inform.[2]
|
||||
(*) Values, such as the number 176, which exist without anyone getting to
|
||||
choose whether they should exist or not.
|
||||
(*) Temporary variables used during phrases or activities, but not existing
|
||||
at the start of play.
|
||||
(*) Adjectives such as "even" as applied to numbers, or "empty" as applied
|
||||
to containers, whose truth or falsity is determined by something other than
|
||||
the author's whim. An author cannot choose that 176 is odd, and whether a
|
||||
container is empty depends only on whether there is something in it.
|
||||
(*) Relationships which are, similarly, determined by an algorithm and not
|
||||
by a specific authorial choice. Like it or not, 176 is "greater than" 8.
|
||||
|
||||
[1] The term "model" is drawn partly from interactive fiction, but also from
|
||||
model theory in the sense of logic, where a "model" is a specific solution
|
||||
showing that a set of logical propositions can all simultaneously be true.
|
||||
|
||||
[2] Properly speaking, kinds created by Neptune files inside kits rather than
|
||||
being declared in source text.
|
||||
|
||||
@ The model is constructed entirely from a stream of logical propositions
|
||||
sent here by the //assertions// module. Those propositions may be mutually
|
||||
inconsistent -- either flatly contradictory or just impossible to reconcile.
|
||||
|
||||
The stream of supposed truthful statements comes to this module through calls
|
||||
to either //Assert::true// or //Assert::true_about//. These reduce a
|
||||
proposition to a set of facts concerning things in the model; as we have
|
||||
seen, the model includes kinds, variables, instances and relations, and so
|
||||
we need a unified type for "something you can know a fact about". That
|
||||
type is called //inference_subject//. Each subject has its own list of known
|
||||
facts: we call such a fact an //inference// because it has (usually) been
|
||||
inferred from a proposition.
|
||||
|
||||
//Chapter 2// implements our system of properties: each different value
|
||||
or either-or property is a //property// object. There might be a puritan
|
||||
case for abolishing this type in favour of regarding either-or properties
|
||||
as special cases of |unary_predicate| and value properties as special cases
|
||||
of |binary_predicate| (by identifying a predicate with its setting relation),
|
||||
but I do not think this would clarify anything.
|
||||
|
||||
//Chapter 3// then covers //Inference Subjects// and their //Inferences//.
|
||||
|
|
|
|||
|
|
@ -228,7 +228,7 @@ void PL::Files::register_file(wording F, wording FN) {
|
|||
allow_exf_creations = TRUE;
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(
|
||||
K_external_file, F);
|
||||
Propositions::Assert::assert_true(prop, CERTAIN_CE);
|
||||
Assert::true(prop, CERTAIN_CE);
|
||||
allow_exf_creations = FALSE;
|
||||
external_file *exf = RETRIEVE_POINTER_external_file(
|
||||
Instances::get_connection(latest_instance));
|
||||
|
|
|
|||
|
|
@ -153,7 +153,7 @@ void PL::Figures::register_figure(wording F, wording FN) {
|
|||
|
||||
allow_figure_creations = TRUE;
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(K_figure_name, F);
|
||||
Propositions::Assert::assert_true(prop, CERTAIN_CE);
|
||||
Assert::true(prop, CERTAIN_CE);
|
||||
allow_figure_creations = FALSE;
|
||||
blorb_figure *bf = RETRIEVE_POINTER_blorb_figure(
|
||||
Instances::get_connection(latest_instance));
|
||||
|
|
|
|||
|
|
@ -140,7 +140,7 @@ void PL::Sounds::register_sound(wording F, wording FN) {
|
|||
allow_sound_creations = TRUE;
|
||||
pcalc_prop *prop = Propositions::Abstract::to_create_something(
|
||||
K_sound_name, F);
|
||||
Propositions::Assert::assert_true(prop, CERTAIN_CE);
|
||||
Assert::true(prop, CERTAIN_CE);
|
||||
allow_sound_creations = FALSE;
|
||||
blorb_sound *bs = RETRIEVE_POINTER_blorb_sound(
|
||||
Instances::get_connection(latest_instance));
|
||||
|
|
|
|||
Loading…
Reference in a new issue