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

Got C undo/restore working

Browse source
This commit is contained in:
Graham Nelson 2021-09-08 23:26:09 +01:00
parent 4535a8711a
commit 6761e556bf
28 changed files with 6038 additions and 85 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -512,17 +512,25 @@ yes/no questions and the like, without invoking the rest of the parser.
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == -1) </span><span class="identifier-syntax">undo_flag</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">undo_flag</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">i</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">VM_RestoreWindowColours</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_Style</span><span class="plain-syntax">(</span><span class="identifier-syntax">SUBHEADER_VMSTY</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SL_Location</span><span class="plain-syntax">(); </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"^"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="comment-syntax">print (name) location, "^";</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_Style</span><span class="plain-syntax">(</span><span class="identifier-syntax">NORMAL_VMSTY</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">IMMEDIATELY_UNDO_RM</span><span class="plain-syntax">(</span><span class="character-syntax">'E'</span><span class="plain-syntax">); </span><span class="reserved-syntax">new_line</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">DealWithUndo</span><span class="plain-syntax">();</span>
<span class="comment-syntax"> VM_RestoreWindowColours();</span>
<span class="comment-syntax"> VM_Style(SUBHEADER_VMSTY);</span>
<span class="comment-syntax"> SL_Location(); print "^";</span>
<span class="comment-syntax"> VM_Style(NORMAL_VMSTY);</span>
<span class="comment-syntax"> IMMEDIATELY_UNDO_RM('E'); new_line;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">continue</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">nw</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax">];</span>
<span class="plain-syntax">[ </span><span class="identifier-syntax">DealWithUndo</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_RestoreWindowColours</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_Style</span><span class="plain-syntax">(</span><span class="identifier-syntax">SUBHEADER_VMSTY</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">SL_Location</span><span class="plain-syntax">(); </span><span class="reserved-syntax">print</span><span class="plain-syntax"> </span><span class="string-syntax">"^"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">VM_Style</span><span class="plain-syntax">(</span><span class="identifier-syntax">NORMAL_VMSTY</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">IMMEDIATELY_UNDO_RM</span><span class="plain-syntax">(</span><span class="character-syntax">'E'</span><span class="plain-syntax">); </span><span class="reserved-syntax">new_line</span><span class="plain-syntax">;</span>
<span class="plain-syntax">];</span>
</pre>
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. Parser Proper. </b>The main parser routine is something of a leviathan, and it has traditionally
been divided into 11 lettered parts:

6
docs/final-module/2-cal.html
View file

@ -242,7 +242,7 @@ is 20. We instead compile this as
<span class="string-syntax"> "</span><span class="identifier-syntax">Con</span><span class="plain-syntax"> %</span><span class="identifier-syntax">S</span><span class="plain-syntax"> </span><span class="identifier-syntax">has</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> %</span><span class="identifier-syntax">d</span><span class="plain-syntax">\</span><span class="identifier-syntax">n</span><span class="string-syntax">", con_name-&gt;symbol_name, depth);</span>
<span class="string-syntax"> CodeGen::CL::constant_depth(con_name);</span>
<span class="string-syntax"> }</span>
<span class="string-syntax"> generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, depth));</span>
<span class="string-syntax"> generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, con_name, depth));</span>
<span class="string-syntax"> text_stream *OUT = CodeGen::current(gen);</span>
<span class="string-syntax"> if (CodeGen::Targets::begin_constant(gen, CodeGen::CL::name(con_name), con_name, P, TRUE, FALSE)) {</span>
<span class="string-syntax"> WRITE("</span><span class="plain-syntax">(</span><span class="string-syntax">");</span>
@ -269,7 +269,7 @@ is 20. We instead compile this as
<span class="string-syntax"> int depth = CodeGen::CL::constant_depth(con_name);</span>
<span class="string-syntax"> if (depth &gt; 1) LOGIF(CONSTANT_DEPTH_CALCULATION,</span>
<span class="string-syntax"> "</span><span class="identifier-syntax">Con</span><span class="plain-syntax"> %</span><span class="identifier-syntax">S</span><span class="plain-syntax"> </span><span class="identifier-syntax">has</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> %</span><span class="identifier-syntax">d</span><span class="plain-syntax">\</span><span class="identifier-syntax">n</span><span class="string-syntax">", con_name-&gt;symbol_name, depth);</span>
<span class="string-syntax"> generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, depth));</span>
<span class="string-syntax"> generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, con_name, depth));</span>
<span class="string-syntax"> if (CodeGen::Targets::begin_constant(gen, CodeGen::CL::name(con_name), con_name, P, TRUE, ifndef_me)) {</span>
<span class="string-syntax"> inter_ti val1 = P-&gt;W.data[DATA_CONST_IFLD];</span>
<span class="string-syntax"> inter_ti val2 = P-&gt;W.data[DATA_CONST_IFLD + 1];</span>
@ -461,7 +461,7 @@ is 20. We instead compile this as
<span class="string-syntax"> return symb-&gt;symbol_name;</span>
<span class="string-syntax">}</span>
</pre>
<ul class="endnotetexts"><li>The function CodeGen::CL::constant_depth appears nowhere else.</li><li>The function CodeGen::CL::constant_depth_inner appears nowhere else.</li><li>The function CodeGen::CL::literal_text_at is used in Frame Control (<a href="2-fc.html#SP1">&#167;1</a>).</li><li>The function CodeGen::CL::compare_tlh appears nowhere else.</li><li>The function CodeGen::CL::sort_literals is used in Code Generation (<a href="2-cg.html#SP8_3">&#167;8.3</a>).</li><li>The function CodeGen::CL::enter_box_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::exit_box_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::enter_print_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::exit_print_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::evaluate appears nowhere else.</li><li>The function CodeGen::CL::literal is used in Frame Control (<a href="2-fc.html#SP2">&#167;2</a>), Instances and Properties (<a href="2-iap.html#SP5_8_5_1_1">&#167;5.8.5.1.1</a>, <a href="2-iap.html#SP8">&#167;8</a>), Generating Inform 6 (<a href="4-fi6.html#SP8">&#167;8</a>, <a href="4-fi6.html#SP9">&#167;9</a>), C Global Variables (<a href="5-cgv.html#SP2">&#167;2</a>).</li><li>The function CodeGen::CL::name is used in Frame Control (<a href="2-fc.html#SP2">&#167;2</a>), Instances and Properties (<a href="2-iap.html#SP4_5">&#167;4.5</a>, <a href="2-iap.html#SP4_6">&#167;4.6</a>, <a href="2-iap.html#SP5_5">&#167;5.5</a>, <a href="2-iap.html#SP5_7">&#167;5.7</a>, <a href="2-iap.html#SP5_8_4">&#167;5.8.4</a>, <a href="2-iap.html#SP5_9">&#167;5.9</a>, <a href="2-iap.html#SP5_11">&#167;5.11</a>, <a href="2-iap.html#SP5_11_2">&#167;5.11.2</a>, <a href="2-iap.html#SP5_11_2_1">&#167;5.11.2.1</a>, <a href="2-iap.html#SP5_11_2_2">&#167;5.11.2.2</a>, <a href="2-iap.html#SP6">&#167;6</a>, <a href="2-iap.html#SP8">&#167;8</a>), Generating Inform 6 (<a href="4-fi6.html#SP7">&#167;7</a>, <a href="4-fi6.html#SP8">&#167;8</a>, <a href="4-fi6.html#SP9">&#167;9</a>), C Global Variables (<a href="5-cgv.html#SP2">&#167;2</a>), C Memory Model (<a href="5-cmm.html#SP12">&#167;12</a>), C Object Model (<a href="5-com.html#SP6">&#167;6</a>), C Function Model (<a href="5-cfm.html#SP1">&#167;1</a>), C Literals (<a href="5-clt.html#SP2">&#167;2</a>).</li><li>The structure text_literal_holder is private to this section.</li></ul>
<ul class="endnotetexts"><li>The function CodeGen::CL::constant_depth appears nowhere else.</li><li>The function CodeGen::CL::constant_depth_inner appears nowhere else.</li><li>The function CodeGen::CL::literal_text_at is used in Frame Control (<a href="2-fc.html#SP1">&#167;1</a>).</li><li>The function CodeGen::CL::compare_tlh appears nowhere else.</li><li>The function CodeGen::CL::sort_literals is used in Code Generation (<a href="2-cg.html#SP8_3">&#167;8.3</a>).</li><li>The function CodeGen::CL::enter_box_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::exit_box_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::enter_print_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::exit_print_mode is used in Frame Control (<a href="2-fc.html#SP3">&#167;3</a>).</li><li>The function CodeGen::CL::evaluate appears nowhere else.</li><li>The function CodeGen::CL::literal is used in Frame Control (<a href="2-fc.html#SP2">&#167;2</a>), Instances and Properties (<a href="2-iap.html#SP5_8_5_1_1">&#167;5.8.5.1.1</a>, <a href="2-iap.html#SP8">&#167;8</a>), Generating Inform 6 (<a href="4-fi6.html#SP8">&#167;8</a>, <a href="4-fi6.html#SP9">&#167;9</a>), C Global Variables (<a href="5-cgv.html#SP2">&#167;2</a>).</li><li>The function CodeGen::CL::name is used in Frame Control (<a href="2-fc.html#SP2">&#167;2</a>), Instances and Properties (<a href="2-iap.html#SP4_5">&#167;4.5</a>, <a href="2-iap.html#SP4_6">&#167;4.6</a>, <a href="2-iap.html#SP5_5">&#167;5.5</a>, <a href="2-iap.html#SP5_7">&#167;5.7</a>, <a href="2-iap.html#SP5_8_4">&#167;5.8.4</a>, <a href="2-iap.html#SP5_9">&#167;5.9</a>, <a href="2-iap.html#SP5_11">&#167;5.11</a>, <a href="2-iap.html#SP5_11_2">&#167;5.11.2</a>, <a href="2-iap.html#SP5_11_2_1">&#167;5.11.2.1</a>, <a href="2-iap.html#SP5_11_2_2">&#167;5.11.2.2</a>, <a href="2-iap.html#SP6">&#167;6</a>, <a href="2-iap.html#SP8">&#167;8</a>), Generating Inform 6 (<a href="4-fi6.html#SP7">&#167;7</a>, <a href="4-fi6.html#SP8">&#167;8</a>, <a href="4-fi6.html#SP9">&#167;9</a>), Generating C (<a href="5-fnc.html#SP5">&#167;5</a>), C Global Variables (<a href="5-cgv.html#SP2">&#167;2</a>), C Memory Model (<a href="5-cmm.html#SP12">&#167;12</a>), C Object Model (<a href="5-com.html#SP6">&#167;6</a>), C Function Model (<a href="5-cfm.html#SP1">&#167;1</a>), C Literals (<a href="5-clt.html#SP2">&#167;2</a>).</li><li>The structure text_literal_holder is private to this section.</li></ul>
<p class="commentary firstcommentary"><a id="SP3" class="paragraph-anchor"></a><b>&#167;3. </b></p>
<pre class="displayed-code all-displayed-code code-font">

6
docs/final-module/2-ft.html
View file

@ -140,7 +140,7 @@ function togglePopup(material_id) {
<pre class="displayed-code all-displayed-code code-font">
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">GENERAL_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_tree_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">P</span><span class="plain-syntax">)</span>
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">DEFAULT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">)</span>
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">BASIC_CONSTANT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax">)</span>
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">BASIC_CONSTANT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_symbol</span><span class="plain-syntax"> *</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax">)</span>
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">CONSTANT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">)</span>
<span class="identifier-syntax">INT_METHOD_TYPE</span><span class="plain-syntax">(</span><span class="constant-syntax">TL_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">)</span>
@ -162,9 +162,9 @@ function togglePopup(material_id) {
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">rv</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">CodeGen::Targets::basic_constant_segment</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">CodeGen::Targets::basic_constant_segment</span></span>:<br/>Constants and Literals - <a href="2-cal.html#SP2">&#167;2</a><br/>Instances and Properties - <a href="2-iap.html#SP4_5">&#167;4.5</a>, <a href="2-iap.html#SP6">&#167;6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CodeGen::Targets::basic_constant_segment</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">CodeGen::Targets::basic_constant_segment</span></span>:<br/>Constants and Literals - <a href="2-cal.html#SP2">&#167;2</a><br/>Instances and Properties - <a href="2-iap.html#SP4_5">&#167;4.5</a>, <a href="2-iap.html#SP6">&#167;6</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_symbol</span><span class="plain-syntax"> *</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</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">rv</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">INT_METHOD_CALL</span><span class="plain-syntax">(</span><span class="identifier-syntax">rv</span><span class="plain-syntax">, </span><span class="identifier-syntax">gen</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">target</span><span class="plain-syntax">, </span><span class="constant-syntax">BASIC_CONSTANT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">depth</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">INT_METHOD_CALL</span><span class="plain-syntax">(</span><span class="identifier-syntax">rv</span><span class="plain-syntax">, </span><span class="identifier-syntax">gen</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">target</span><span class="plain-syntax">, </span><span class="constant-syntax">BASIC_CONSTANT_SEGMENT_MTID</span><span class="plain-syntax">, </span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">con_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">depth</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">rv</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

4
docs/final-module/2-iap.html
View file

@ -359,7 +359,7 @@ in the I6 template, or some extension), and we therefore do nothing.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><a href="2-ft.html#SP4" class="function-link"><span class="function-syntax">CodeGen::Targets::basic_constant_segment</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</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">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><a href="2-ft.html#SP4" class="function-link"><span class="function-syntax">CodeGen::Targets::basic_constant_segment</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">prop_name</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">Inter::Symbols::read_annotation</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">ASSIMILATED_IANN</span><span class="plain-syntax">) &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">A</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Inter::Symbols::get_translate</span><span class="plain-syntax">(</span><span class="identifier-syntax">prop_name</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">A</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">A</span><span class="plain-syntax"> = </span><a href="2-cal.html#SP2" class="function-link"><span class="function-syntax">CodeGen::CL::name</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">prop_name</span><span class="plain-syntax">);</span>
@ -1121,7 +1121,7 @@ linearly with the size of the source text, even though \(N\) does.
<span class="plain-syntax"> </span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax"> </span><span class="identifier-syntax">val2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">P</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">W</span><span class="plain-syntax">.</span><span class="identifier-syntax">data</span><span class="plain-syntax">[</span><span class="identifier-syntax">VAL2_INST_IFLD</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">defined</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">val1</span><span class="plain-syntax"> == </span><span class="identifier-syntax">UNDEF_IVAL</span><span class="plain-syntax">) </span><span class="identifier-syntax">defined</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">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><a href="2-ft.html#SP4" class="function-link"><span class="function-syntax">CodeGen::Targets::basic_constant_segment</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</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">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><a href="2-ft.html#SP4" class="function-link"><span class="function-syntax">CodeGen::Targets::basic_constant_segment</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inst_name</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">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP7" class="function-link"><span class="function-syntax">CodeGen::current</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="2-ft.html#SP14" class="function-link"><span class="function-syntax">CodeGen::Targets::begin_constant</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><a href="2-cal.html#SP2" class="function-link"><span class="function-syntax">CodeGen::CL::name</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">inst_name</span><span class="plain-syntax">), </span><span class="identifier-syntax">inst_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">defined</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">defined</span><span class="plain-syntax">) {</span>

2
docs/final-module/4-fi6.html
View file

@ -343,7 +343,7 @@ It's used in the I6 veneer, and need not exist on any other final compilation ta
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CodeGen::I6::constant_segment</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">CodeGen::I6::constant_segment</span></span>:<br/><a href="4-fi6.html#SP2">&#167;2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">early_matter_I7CGS</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">CodeGen::I6::basic_constant_segment</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">CodeGen::I6::basic_constant_segment</span></span>:<br/><a href="4-fi6.html#SP2">&#167;2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CodeGen::I6::basic_constant_segment</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">CodeGen::I6::basic_constant_segment</span></span>:<br/><a href="4-fi6.html#SP2">&#167;2</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_symbol</span><span class="plain-syntax"> *</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</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">depth</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">10</span><span class="plain-syntax">) </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> = </span><span class="constant-syntax">10</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">constants_1_I7CGS</span><span class="plain-syntax"> + </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> - </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

35
docs/final-module/5-cas.html
View file

@ -163,6 +163,7 @@ function togglePopup(material_id) {
<span class="plain-syntax"> </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[3] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">vararg_operands_from</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">; </span><span class="identifier-syntax">vararg_operands_to</span><span class="plain-syntax"> = </span><span class="identifier-syntax">operand_count</span><span class="plain-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">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@hasundo"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[1] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@log"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[2] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@mod"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[3] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@mul"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[3] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
@ -170,6 +171,8 @@ function togglePopup(material_id) {
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@numtof"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[2] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@pow"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[3] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@random"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[2] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@restoreundo"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[1] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@saveundo"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[1] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@shiftl"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[3] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@sin"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[2] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">opcode</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"@sqrt"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">store_this_operand</span><span class="plain-syntax">[2] = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
@ -241,12 +244,14 @@ function togglePopup(material_id) {
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_binarysearch</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">key</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">keysize</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">start</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">structsize</span><span class="Extracts-plain-syntax">,</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">numstructs</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">keyoffset</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">options</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">s1</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_shiftl</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">y</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">z</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restoreundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_saveundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restoreundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_saveundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restart</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restore</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">y</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_save</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">y</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_verify</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_hasundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_discardundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This is part of the extract file inform7_clib.h.</li></ul>
<pre class="Extracts-displayed-code all-displayed-code code-font">
@ -425,10 +430,32 @@ function togglePopup(material_id) {
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restoreundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restoreundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">just_undid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">i7_has_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">ifdef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_mgl_DealWithUndo</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">fn_i7_mgl_DealWithUndo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">endif</span>
<span class="Extracts-plain-syntax"> } </span><span class="Extracts-identifier-syntax">else</span><span class="Extracts-plain-syntax"> {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_saveundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_saveundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">just_undid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_save_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_hasundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">rv</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">i7_has_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">)) </span><span class="Extracts-identifier-syntax">rv</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax">) *</span><span class="Extracts-identifier-syntax">x</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">rv</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_discardundo</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_latest_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">glulx_restart</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>

4
docs/final-module/5-cfm.html
View file

@ -158,7 +158,9 @@ function togglePopup(material_id) {
<span class="plain-syntax">}</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">CFunctionModel::declare_fcf</span><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="reserved-syntax">final_c_function</span><span class="plain-syntax"> *</span><span class="identifier-syntax">fcf</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="constant-syntax">c_predeclarations_I7CGS</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">seg</span><span class="plain-syntax"> = </span><span class="constant-syntax">c_predeclarations_I7CGS</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">Str::eq</span><span class="plain-syntax">(</span><span class="identifier-syntax">fcf</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">identifier_as_constant</span><span class="plain-syntax">, </span><span class="identifier-syntax">I</span><span class="string-syntax">"DealWithUndo"</span><span class="plain-syntax">)) </span><span class="identifier-syntax">seg</span><span class="plain-syntax"> = </span><span class="constant-syntax">c_ids_and_maxima_I7CGS</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">generated_segment</span><span class="plain-syntax"> *</span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">seg</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">OUT</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP7" class="function-link"><span class="function-syntax">CodeGen::current</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"#define "</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="5-cnm.html#SP1" class="function-link"><span class="function-syntax">CNamespace::mangle</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">fcf</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">identifier_as_constant</span><span class="plain-syntax">);</span>

2
docs/final-module/5-cim.html
View file

@ -105,7 +105,7 @@ function togglePopup(material_id) {
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STYLEUNDERLINE_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_style(proc, i7_underline)"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STYLEREVERSE_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_style(proc, i7_reverse)"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINT_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_C_string(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1_PRINTMODE</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">")"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTRET_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_C_string(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1_PRINTMODE</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"); return 1"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTRET_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_C_string(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1_PRINTMODE</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"); i7_print_char(proc, '\\n'); return 1"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTCHAR_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_char(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">")"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTOBJ_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_object(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">")"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">PRINTNUMBER_BIP:</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"i7_print_decimal(proc, "</span><span class="plain-syntax">); </span><span class="constant-syntax">INV_A1</span><span class="plain-syntax">; </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">")"</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>

6
docs/final-module/5-clt.html
View file

@ -813,6 +813,7 @@ function togglePopup(material_id) {
<pre class="Extracts-displayed-code all-displayed-code code-font">
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_print_dword</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">at</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">char</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">i7_text_of_string</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">str</span><span class="Extracts-plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This is part of the extract file inform7_clib.h.</li></ul>
<pre class="Extracts-displayed-code all-displayed-code code-font">
@ -823,6 +824,11 @@ function togglePopup(material_id) {
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_print_char</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">c</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">char</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">dqs</span><span class="Extracts-plain-syntax">[];</span>
<span class="Extracts-identifier-syntax">char</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">i7_text_of_string</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">str</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">return</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">dqs</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">str</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-identifier-syntax">I7VAL_STRINGS_BASE</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax">}</span>
</pre>
<ul class="endnotetexts"><li>This is part of the extract file inform7_clib.c.</li></ul>
<nav role="progress"><div class="progresscontainer">

14
docs/final-module/5-cmm.html
View file

@ -155,7 +155,7 @@ in C.
<span class="plain-syntax"> </span><span class="identifier-syntax">saved</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::select</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="constant-syntax">c_ids_and_maxima_I7CGS</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">OUT</span><span class="plain-syntax"> = </span><a href="2-cg.html#SP7" class="function-link"><span class="function-syntax">CodeGen::current</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"#define i7_himem %d\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">C_GEN_DATA</span><span class="plain-syntax">(</span><span class="identifier-syntax">memdata</span><span class="plain-syntax">.</span><span class="element-syntax">himem</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"#define i7_static_himem %d\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">C_GEN_DATA</span><span class="plain-syntax">(</span><span class="identifier-syntax">memdata</span><span class="plain-syntax">.</span><span class="element-syntax">himem</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><a href="2-cg.html#SP5" class="function-link"><span class="function-syntax">CodeGen::deselect</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">saved</span><span class="plain-syntax">);</span>
<span class="plain-syntax">}</span>
</pre>
@ -168,13 +168,14 @@ in C.
<pre class="Extracts-displayed-code all-displayed-code code-font">
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_initialise_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax"> != </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_himem</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">allocation</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">failed</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">");</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">i7_himem</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">i7_initial_memory</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">i7_initial_memory</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">ifdef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_mgl_Release</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x34</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">I7BYTE_2</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_mgl_Release</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x35</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">I7BYTE_3</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_mgl_Release</span><span class="Extracts-plain-syntax">);</span>
@ -184,7 +185,8 @@ in C.
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x35</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">I7BYTE_3</span><span class="Extracts-plain-syntax">(1);</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">endif</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">ifdef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_mgl_Serial</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;6; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x36</span><span class="Extracts-plain-syntax"> + </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = (</span><span class="Extracts-identifier-syntax">dqs</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i7_mgl_Serial</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-identifier-syntax">I7VAL_STRINGS_BASE</span><span class="Extracts-plain-syntax">])[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">char</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">p</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">i7_text_of_string</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_mgl_Serial</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;6; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x36</span><span class="Extracts-plain-syntax"> + </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">p</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">endif</span>
<span class="Extracts-plain-syntax"> #</span><span class="Extracts-identifier-syntax">ifndef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_mgl_Serial</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;6; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">mem</span><span class="Extracts-plain-syntax">[0</span><span class="Extracts-identifier-syntax">x36</span><span class="Extracts-plain-syntax"> + </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = '0';</span>
@ -238,7 +240,7 @@ challenging since we need to pack and unpack them.
<span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_read_word</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">array_address</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">array_index</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">data</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">array_address</span><span class="Extracts-plain-syntax"> + </span><span class="Extracts-constant-syntax">4</span><span class="Extracts-plain-syntax">*</span><span class="Extracts-identifier-syntax">array_index</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> ((</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) || (</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &gt;= </span><span class="Extracts-identifier-syntax">i7_himem</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> ((</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) || (</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &gt;= </span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">access</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">out</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">of</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">range</span><span class="Extracts-plain-syntax">: %</span><span class="Extracts-identifier-syntax">d</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">", </span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
@ -296,7 +298,7 @@ express a packed word in constant context, which we will need later.
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">case</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_lvalue_CLEARBIT</span><span class="Extracts-plain-syntax">: </span><span class="Extracts-identifier-syntax">new_val</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">old_val</span><span class="Extracts-plain-syntax"> &amp;(~</span><span class="Extracts-identifier-syntax">new_val</span><span class="Extracts-plain-syntax">); </span><span class="Extracts-identifier-syntax">return_val</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">new_val</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">break</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">array_address</span><span class="Extracts-plain-syntax"> + </span><span class="Extracts-constant-syntax">4</span><span class="Extracts-plain-syntax">*</span><span class="Extracts-identifier-syntax">array_index</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> ((</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) || (</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &gt;= </span><span class="Extracts-identifier-syntax">i7_himem</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> ((</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) || (</span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax"> &gt;= </span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">access</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">out</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">of</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">range</span><span class="Extracts-plain-syntax">: %</span><span class="Extracts-identifier-syntax">d</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">", </span><span class="Extracts-identifier-syntax">byte_position</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>

131
docs/final-module/5-fnc.html
View file

@ -140,6 +140,7 @@ first of those:
<span class="Extracts-identifier-syntax">typedef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">struct</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">stack</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">I7_ASM_STACK_CAPACITY</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax">;</span>
@ -148,17 +149,37 @@ first of those:
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">tmp</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">} </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-identifier-syntax">typedef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">struct</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">struct</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">then</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">jmp_buf</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">env</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">} </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">#</span><span class="Extracts-identifier-syntax">define</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-constant-syntax">10</span>
<span class="Extracts-identifier-syntax">typedef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">struct</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">jmp_buf</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">execution_env</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">termination_code</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">just_undid</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">} </span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_process</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_save_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_has_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot_from</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">ss</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_latest_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_run_process</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> (*</span><span class="Extracts-identifier-syntax">receiver</span><span class="Extracts-plain-syntax">)(</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">id</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">wchar_t</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">c</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_initializer</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">old</span><span class="Extracts-plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This is part of the extract file inform7_clib.h.</li></ul>
<pre class="Extracts-displayed-code all-displayed-code code-font">
@ -168,6 +189,7 @@ first of those:
<span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">tmp</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">;</span>
@ -177,12 +199,117 @@ first of those:
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">return</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">S</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_copy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7byte</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">allocation</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">failed</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">");</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">i7_static_himem</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">tmp</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">tmp</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_max_objects</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_child</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_max_objects</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_sibling</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_max_objects</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> ((</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) ||</span>
<span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_child</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) ||</span>
<span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_sibling</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">)) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">allocation</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">failed</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">");</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">i7_max_objects</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_child</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_child</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_sibling</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_sibling</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">calloc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7_no_variables</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">sizeof</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7val</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">NULL</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Memory</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">allocation</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">failed</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">");</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">i7_no_variables</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++)</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">to</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">from</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">];</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7state</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">memory</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">himem</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_parent</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_child</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">i7_object_tree_sibling</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">stack_pointer</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">free</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">s</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">variables</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">old</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">old</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">then</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">old</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">SS</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">SS</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">SS</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">then</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">i7_new_state</span><span class="Extracts-plain-syntax">();</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">return</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">SS</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_new_process</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">i7_new_state</span><span class="Extracts-plain-syntax">();</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">for</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">=0; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">&lt;</span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax">; </span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">++) </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">i</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">i7_new_snapshot</span><span class="Extracts-plain-syntax">();</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">just_undid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">.</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">return</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_save_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax">)</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">]));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">] = </span><span class="Extracts-identifier-syntax">i7_new_snapshot</span><span class="Extracts-plain-syntax">();</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_copy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">then</span><span class="Extracts-plain-syntax">), &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">was</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">++;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">// </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">setjmp</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">was</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">env</span><span class="Extracts-plain-syntax">)) </span><span class="Extracts-identifier-syntax">fprintf</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">stdout</span><span class="Extracts-plain-syntax">, "*** </span><span class="Extracts-identifier-syntax">Restore</span><span class="Extracts-plain-syntax">! %</span><span class="Extracts-identifier-syntax">d</span><span class="Extracts-plain-syntax"> ***\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">", </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">just_undid</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_has_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">return</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_latest_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax">)</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">]));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> &lt; </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">I7_MAX_SNAPSHOTS</span><span class="Extracts-plain-syntax"> - </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">valid</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-constant-syntax">0</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">printf</span><span class="Extracts-plain-syntax">("</span><span class="Extracts-identifier-syntax">Restore</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">impossible</span><span class="Extracts-plain-syntax">\</span><span class="Extracts-identifier-syntax">n</span><span class="Extracts-plain-syntax">");</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_fatal_exit</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax"> }</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot_from</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">]));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_snapshot</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">]));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">was</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshot_pos</span><span class="Extracts-plain-syntax"> = </span><span class="Extracts-identifier-syntax">will_be</span><span class="Extracts-plain-syntax">;</span>
<span class="Extracts-plain-syntax">// </span><span class="Extracts-identifier-syntax">longjmp</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">snapshots</span><span class="Extracts-plain-syntax">[</span><span class="Extracts-identifier-syntax">was</span><span class="Extracts-plain-syntax">].</span><span class="Extracts-identifier-syntax">env</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-constant-syntax">1</span><span class="Extracts-plain-syntax">);</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_restore_snapshot_from</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">i7process</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">i7snapshot</span><span class="Extracts-plain-syntax"> *</span><span class="Extracts-identifier-syntax">ss</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_destroy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">i7_copy_state</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">, &amp;(</span><span class="Extracts-identifier-syntax">proc</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">state</span><span class="Extracts-plain-syntax">), &amp;(</span><span class="Extracts-identifier-syntax">ss</span><span class="Extracts-plain-syntax">-&gt;</span><span class="Extracts-identifier-syntax">then</span><span class="Extracts-plain-syntax">));</span>
<span class="Extracts-plain-syntax">}</span>
<span class="Extracts-plain-syntax">#</span><span class="Extracts-identifier-syntax">ifndef</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">I7_NO_MAIN</span>
<span class="Extracts-identifier-syntax">void</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">default_receiver</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">int</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">id</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">wchar_t</span><span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">c</span><span class="Extracts-plain-syntax">) {</span>
<span class="Extracts-plain-syntax"> </span><span class="Extracts-identifier-syntax">if</span><span class="Extracts-plain-syntax"> (</span><span class="Extracts-identifier-syntax">id</span><span class="Extracts-plain-syntax"> == </span><span class="Extracts-constant-syntax">201</span><span class="Extracts-plain-syntax">) </span><span class="Extracts-identifier-syntax">fputc</span><span class="Extracts-plain-syntax">(</span><span class="Extracts-identifier-syntax">c</span><span class="Extracts-plain-syntax">, </span><span class="Extracts-identifier-syntax">stdout</span><span class="Extracts-plain-syntax">);</span>
@ -375,7 +502,9 @@ first of those:
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CTarget::constant_segment</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">CTarget::constant_segment</span></span>:<br/><a href="5-fnc.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">c_early_matter_I7CGS</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">CTarget::basic_constant_segment</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">CTarget::basic_constant_segment</span></span>:<br/><a href="5-fnc.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CTarget::basic_constant_segment</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">CTarget::basic_constant_segment</span></span>:<br/><a href="5-fnc.html#SP1">&#167;1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">code_generation_target</span><span class="plain-syntax"> *</span><span class="identifier-syntax">cgt</span><span class="plain-syntax">, </span><span class="reserved-syntax">code_generation</span><span class="plain-syntax"> *</span><span class="identifier-syntax">gen</span><span class="plain-syntax">, </span><span class="identifier-syntax">inter_symbol</span><span class="plain-syntax"> *</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">depth</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">Str::eq</span><span class="plain-syntax">(</span><a href="2-cal.html#SP2" class="function-link"><span class="function-syntax">CodeGen::CL::name</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Release"</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">c_ids_and_maxima_I7CGS</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">Str::eq</span><span class="plain-syntax">(</span><a href="2-cal.html#SP2" class="function-link"><span class="function-syntax">CodeGen::CL::name</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">con_name</span><span class="plain-syntax">), </span><span class="identifier-syntax">I</span><span class="string-syntax">"Serial"</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">c_ids_and_maxima_I7CGS</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">depth</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">10</span><span class="plain-syntax">) </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> = </span><span class="constant-syntax">10</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="constant-syntax">c_constants_1_I7CGS</span><span class="plain-syntax"> + </span><span class="identifier-syntax">depth</span><span class="plain-syntax"> - </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>

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

@ -1,6 +1,6 @@
Total memory consumption was 387857K = 379 MB
Total memory consumption was 387861K = 379 MB
61.6% was used for 1997529 objects, in 371272 frames in 299 x 800K = 239200K = 233 MB:
61.6% was used for 1997535 objects, in 371278 frames in 299 x 800K = 239200K = 233 MB:
10.5% inter_tree_node_array 58 x 8192 = 475136 objects, 41813824 bytes
7.2% text_stream_array 5142 x 100 = 514200 objects, 28959744 bytes
@ -14,11 +14,11 @@ Total memory consumption was 387857K = 379 MB
0.6% kind_array 68 x 1000 = 68000 objects, 2722176 bytes
0.5% inter_name_generator_array 53 x 1000 = 53000 objects, 2121696 bytes
0.4% inter_schema_token 13472 objects, 1939968 bytes
0.4% inter_package 26570 objects, 1913040 bytes
0.4% inter_package 26572 objects, 1913184 bytes
0.4% package_request 21138 objects, 1860144 bytes
0.4% vocabulary_entry_array 161 x 100 = 16100 objects, 1808352 bytes
0.4% inter_symbols_table 26570 objects, 1700480 bytes
0.4% dictionary 33267 objects, 1596816 bytes
0.4% inter_symbols_table 26572 objects, 1700608 bytes
0.4% dictionary 33269 objects, 1596912 bytes
0.3% match_trie_array 11 x 1000 = 11000 objects, 1496352 bytes
0.3% i6_schema_array 23 x 100 = 2300 objects, 1380736 bytes
0.3% dict_entry_array 398 x 100 = 39800 objects, 1286336 bytes
@ -238,16 +238,16 @@ Total memory consumption was 387857K = 379 MB
38.3% was used for memory not allocated for objects:
19.2% text stream storage 76350496 bytes in 531891 claims
4.5% dictionary storage 18176000 bytes in 33267 claims
19.2% text stream storage 76353888 bytes in 531913 claims
4.5% dictionary storage 18177024 bytes in 33269 claims
---- sorting 744 bytes in 3 claims
1.8% source text 7200000 bytes in 3 claims
2.7% source text details 10800000 bytes in 2 claims
---- documentation fragments 262144 bytes in 1 claim
---- linguistic stock array 81920 bytes in 2 claims
---- small word set array 105600 bytes in 22 claims
1.0% inter symbols storage 4175216 bytes in 27681 claims
4.2% inter bytecode storage 16802800 bytes in 14 claims
1.0% inter symbols storage 4175472 bytes in 27683 claims
4.2% inter bytecode storage 16802820 bytes in 14 claims
4.0% inter links storage 16174208 bytes in 266 claims
---- inter tree location list storage 191232 bytes in 32 claims
0.4% instance-of-kind counting 1695204 bytes in 1 claim
@ -256,5 +256,5 @@ Total memory consumption was 387857K = 379 MB
---- code generation workspace for objects 9648 bytes in 9 claims
---- emitter array storage 161920 bytes in 2064 claims
18.8% was overhead - 75009856 bytes = 73251K = 71 MB
18.8% was overhead - 75009488 bytes = 73251K = 71 MB

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

@ -1,27 +1,27 @@
100.0% in inform7 run
54.2% in compilation to Inter
39.3% in //Sequence::undertake_queued_tasks//
3.4% in //MajorNodes::pre_pass//
2.6% in //MajorNodes::pass_1//
54.3% in compilation to Inter
39.5% in //Sequence::undertake_queued_tasks//
3.5% in //MajorNodes::pre_pass//
2.5% in //MajorNodes::pass_1//
1.5% in //RTPhrasebook::compile_entries//
1.4% in //ImperativeDefinitions::assess_all//
1.1% in //RTKindConstructors::compile//
0.4% in //ImperativeDefinitions::compile_first_block//
0.4% in //MajorNodes::pass_2//
0.4% in //Sequence::undertake_queued_tasks//
0.4% in //Sequence::undertake_queued_tasks//
0.4% in //World::stage_V//
0.2% in //CompletionModule::compile//
0.2% in //Sequence::undertake_queued_tasks//
0.1% in //InferenceSubjects::emit_all//
0.1% in //RTKindConstructors::compile_permissions//
0.1% in //Task::make_built_in_kind_constructors//
0.1% in //World::stages_II_and_III//
1.7% not specifically accounted for
43.7% in running Inter pipeline
1.6% not specifically accounted for
43.6% in running Inter pipeline
11.8% in step preparation
9.6% in inter step 7/15: consolidate-text
8.2% in inter step 15/15: generate inform6 -> auto.inf
7.9% in inter step 2/15: link
9.7% in inter step 7/15: consolidate-text
7.9% in inter step 15/15: generate inform6 -> auto.inf
7.8% in inter step 2/15: link
1.5% in inter step 11/15: make-identifiers-unique
0.4% in inter step 12/15: reconcile-verbs
0.2% in inter step 14/15: eliminate-redundant-operations
@ -32,6 +32,6 @@
0.1% in inter step 13/15: eliminate-redundant-labels
0.1% in inter step 4/15: parse-linked-matter
0.1% in inter step 5/15: resolve-conditional-compilation
2.2% not specifically accounted for
2.6% not specifically accounted for
1.7% in supervisor
0.3% not specifically accounted for

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

@ -449,18 +449,26 @@ The return value is the number of words typed.
if (i == -1) undo_flag = 0;
if (i == 0) undo_flag = 1;
if (i == 2) {
VM_RestoreWindowColours();
VM_Style(SUBHEADER_VMSTY);
SL_Location(); print "^";
! print (name) location, "^";
VM_Style(NORMAL_VMSTY);
IMMEDIATELY_UNDO_RM('E'); new_line;
DealWithUndo();
! VM_RestoreWindowColours();
! VM_Style(SUBHEADER_VMSTY);
! SL_Location(); print "^";
! VM_Style(NORMAL_VMSTY);
! IMMEDIATELY_UNDO_RM('E'); new_line;
continue;
}
return nw;
}
];
[ DealWithUndo;
VM_RestoreWindowColours();
VM_Style(SUBHEADER_VMSTY);
SL_Location(); print "^";
VM_Style(NORMAL_VMSTY);
IMMEDIATELY_UNDO_RM('E'); new_line;
];
@h Parser Proper.
The main parser routine is something of a leviathan, and it has traditionally
been divided into 11 lettered parts:

149
inform7/Internal/Miscellany/inform7_clib.c
View file

@ -4,6 +4,7 @@
i7state i7_new_state(void) {
i7state S;
S.memory = NULL;
S.himem = 0;
S.tmp = 0;
S.stack_pointer = 0;
S.i7_object_tree_parent = NULL;
@ -13,12 +14,117 @@ i7state i7_new_state(void) {
return S;
}
void i7_copy_state(i7process *proc, i7state *to, i7state *from) {
to->himem = from->himem;
to->memory = calloc(i7_static_himem, sizeof(i7byte));
if (to->memory == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_static_himem; i++) to->memory[i] = from->memory[i];
to->tmp = from->tmp;
to->stack_pointer = from->stack_pointer;
for (int i=0; i<from->stack_pointer; i++) to->stack[i] = from->stack[i];
to->i7_object_tree_parent = calloc(i7_max_objects, sizeof(i7val));
to->i7_object_tree_child = calloc(i7_max_objects, sizeof(i7val));
to->i7_object_tree_sibling = calloc(i7_max_objects, sizeof(i7val));
if ((to->i7_object_tree_parent == NULL) ||
(to->i7_object_tree_child == NULL) ||
(to->i7_object_tree_sibling == NULL)) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_max_objects; i++) {
to->i7_object_tree_parent[i] = from->i7_object_tree_parent[i];
to->i7_object_tree_child[i] = from->i7_object_tree_child[i];
to->i7_object_tree_sibling[i] = from->i7_object_tree_sibling[i];
}
to->variables = calloc(i7_no_variables, sizeof(i7val));
if (to->variables == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_no_variables; i++)
to->variables[i] = from->variables[i];
}
void i7_destroy_state(i7process *proc, i7state *s) {
free(s->memory);
s->himem = 0;
free(s->i7_object_tree_parent);
free(s->i7_object_tree_child);
free(s->i7_object_tree_sibling);
s->stack_pointer = 0;
free(s->variables);
}
void i7_destroy_snapshot(i7process *proc, i7snapshot *old) {
i7_destroy_state(proc, &(old->then));
old->valid = 0;
}
i7snapshot i7_new_snapshot(void) {
i7snapshot SS;
SS.valid = 0;
SS.then = i7_new_state();
return SS;
}
i7process i7_new_process(void) {
i7process proc;
proc.state = i7_new_state();
for (int i=0; i<I7_MAX_SNAPSHOTS; i++) proc.snapshots[i] = i7_new_snapshot();
proc.just_undid = 0;
proc.snapshot_pos = 0;
return proc;
}
void i7_save_snapshot(i7process *proc) {
if (proc->snapshots[proc->snapshot_pos].valid)
i7_destroy_snapshot(proc, &(proc->snapshots[proc->snapshot_pos]));
proc->snapshots[proc->snapshot_pos] = i7_new_snapshot();
proc->snapshots[proc->snapshot_pos].valid = 1;
i7_copy_state(proc, &(proc->snapshots[proc->snapshot_pos].then), &(proc->state));
int was = proc->snapshot_pos;
proc->snapshot_pos++;
if (proc->snapshot_pos == I7_MAX_SNAPSHOTS) proc->snapshot_pos = 0;
// if (setjmp(proc->snapshots[was].env)) fprintf(stdout, "*** Restore! %d ***\n", proc->just_undid);
}
int i7_has_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
return proc->snapshots[will_be].valid;
}
int i7_destroy_latest_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
if (proc->snapshots[will_be].valid)
i7_destroy_snapshot(proc, &(proc->snapshots[will_be]));
proc->snapshot_pos = will_be;
}
void i7_restore_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
if (proc->snapshots[will_be].valid == 0) {
printf("Restore impossible\n");
i7_fatal_exit(proc);
}
i7_restore_snapshot_from(proc, &(proc->snapshots[will_be]));
i7_destroy_snapshot(proc, &(proc->snapshots[will_be]));
int was = proc->snapshot_pos;
proc->snapshot_pos = will_be;
// longjmp(proc->snapshots[was].env, 1);
}
void i7_restore_snapshot_from(i7process *proc, i7snapshot *ss) {
i7_destroy_state(proc, &(proc->state));
i7_copy_state(proc, &(proc->state), &(ss->then));
}
#ifndef I7_NO_MAIN
void default_receiver(int id, wchar_t c) {
if (id == 201) fputc(c, stdout);
@ -55,13 +161,14 @@ void i7_fatal_exit(i7process *proc) {
void i7_initialise_state(i7process *proc) {
if (proc->state.memory != NULL) free(proc->state.memory);
i7byte *mem = calloc(i7_himem, sizeof(i7byte));
i7byte *mem = calloc(i7_static_himem, sizeof(i7byte));
if (mem == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
proc->state.memory = mem;
for (int i=0; i<i7_himem; i++) mem[i] = i7_initial_memory[i];
proc->state.himem = i7_static_himem;
for (int i=0; i<i7_static_himem; i++) mem[i] = i7_initial_memory[i];
#ifdef i7_mgl_Release
mem[0x34] = I7BYTE_2(i7_mgl_Release);
mem[0x35] = I7BYTE_3(i7_mgl_Release);
@ -71,7 +178,8 @@ void i7_initialise_state(i7process *proc) {
mem[0x35] = I7BYTE_3(1);
#endif
#ifdef i7_mgl_Serial
for (int i=0; i<6; i++) mem[0x36 + i] = (dqs[i7_mgl_Serial - I7VAL_STRINGS_BASE])[i];
char *p = i7_text_of_string(i7_mgl_Serial);
for (int i=0; i<6; i++) mem[0x36 + i] = p[i];
#endif
#ifndef i7_mgl_Serial
for (int i=0; i<6; i++) mem[0x36 + i] = '0';
@ -109,7 +217,7 @@ i7byte i7_read_byte(i7process *proc, i7val address) {
i7val i7_read_word(i7process *proc, i7val array_address, i7val array_index) {
i7byte *data = proc->state.memory;
int byte_position = array_address + 4*array_index;
if ((byte_position < 0) || (byte_position >= i7_himem)) {
if ((byte_position < 0) || (byte_position >= i7_static_himem)) {
printf("Memory access out of range: %d\n", byte_position);
i7_fatal_exit(proc);
}
@ -150,7 +258,7 @@ i7val i7_write_word(i7process *proc, i7val array_address, i7val array_index, i7v
case i7_lvalue_CLEARBIT: new_val = old_val &(~new_val); return_val = new_val; break;
}
int byte_position = array_address + 4*array_index;
if ((byte_position < 0) || (byte_position >= i7_himem)) {
if ((byte_position < 0) || (byte_position >= i7_static_himem)) {
printf("Memory access out of range: %d\n", byte_position);
i7_fatal_exit(proc);
}
@ -373,10 +481,32 @@ void glulx_shiftl(i7process *proc, i7val x, i7val y, i7val *z) {
i7_fatal_exit(proc);
}
void glulx_restoreundo(i7process *proc, i7val x) {
void glulx_restoreundo(i7process *proc, i7val *x) {
proc->just_undid = 1;
if (i7_has_snapshot(proc)) {
i7_restore_snapshot(proc);
if (x) *x = 0;
#ifdef i7_mgl_DealWithUndo
fn_i7_mgl_DealWithUndo(proc);
#endif
} else {
if (x) *x = 1;
}
}
void glulx_saveundo(i7process *proc, i7val x) {
void glulx_saveundo(i7process *proc, i7val *x) {
proc->just_undid = 0;
i7_save_snapshot(proc);
if (x) *x = 0;
}
void glulx_hasundo(i7process *proc, i7val *x) {
i7val rv = 0; if (i7_has_snapshot(proc)) rv = 1;
if (x) *x = rv;
}
void glulx_discardundo(i7process *proc) {
i7_destroy_latest_snapshot(proc);
}
void glulx_restart(i7process *proc) {
@ -944,6 +1074,11 @@ void i7_print_dword(i7process *proc, i7val at) {
i7_print_char(proc, c);
}
}
char *dqs[];
char *i7_text_of_string(i7val str) {
return dqs[str - I7VAL_STRINGS_BASE];
}
void i7_style(i7process *proc, int what) {
}

28
inform7/Internal/Miscellany/inform7_clib.h
View file

@ -22,6 +22,7 @@ typedef unsigned char i7byte;
typedef struct i7state {
i7byte *memory;
i7val himem;
i7val stack[I7_ASM_STACK_CAPACITY];
int stack_pointer;
i7val *i7_object_tree_parent;
@ -30,17 +31,37 @@ typedef struct i7state {
i7val *variables;
i7val tmp;
} i7state;
typedef struct i7snapshot {
int valid;
struct i7state then;
jmp_buf env;
} i7snapshot;
#define I7_MAX_SNAPSHOTS 10
typedef struct i7process {
i7state state;
i7snapshot snapshots[I7_MAX_SNAPSHOTS];
int snapshot_pos;
jmp_buf execution_env;
int termination_code;
int just_undid;
} i7process;
i7state i7_new_state(void);
i7process i7_new_process(void);
i7snapshot i7_new_snapshot(void);
void i7_save_snapshot(i7process *proc);
int i7_has_snapshot(i7process *proc);
void i7_restore_snapshot(i7process *proc);
void i7_restore_snapshot_from(i7process *proc, i7snapshot *ss);
int i7_destroy_latest_snapshot(i7process *proc);
void i7_run_process(i7process *proc, void (*receiver)(int id, wchar_t c));
void i7_initializer(i7process *proc);
void i7_fatal_exit(i7process *proc);
void i7_destroy_state(i7process *proc, i7state *s);
void i7_destroy_snapshot(i7process *proc, i7snapshot *old);
#define i7_lvalue_SET 1
#define i7_lvalue_PREDEC 2
#define i7_lvalue_POSTDEC 3
@ -90,12 +111,14 @@ void glulx_aloadb(i7process *proc, i7val x, i7val y, i7val *z);
void glulx_binarysearch(i7process *proc, i7val key, i7val keysize, i7val start, i7val structsize,
i7val numstructs, i7val keyoffset, i7val options, i7val *s1);
void glulx_shiftl(i7process *proc, i7val x, i7val y, i7val *z);
void glulx_restoreundo(i7process *proc, i7val x);
void glulx_saveundo(i7process *proc, i7val x);
void glulx_restoreundo(i7process *proc, i7val *x);
void glulx_saveundo(i7process *proc, i7val *x);
void glulx_restart(i7process *proc);
void glulx_restore(i7process *proc, i7val x, i7val y);
void glulx_save(i7process *proc, i7val x, i7val y);
void glulx_verify(i7process *proc, i7val x);
void glulx_hasundo(i7process *proc, i7val *x);
void glulx_discardundo(i7process *proc);
void glulx_random(i7process *proc, i7val x, i7val *y);
i7val fn_i7_mgl_random(i7process *proc, i7val x);
void glulx_setrandom(i7process *proc, i7val s);
@ -166,6 +189,7 @@ i7val i7_mcall_3(i7process *proc, i7val to, i7val prop, i7val v, i7val v2, i7val
i7val i7_gen_call(i7process *proc, i7val fn_ref, i7val *args, int argc);
void glulx_call(i7process *proc, i7val fn_ref, i7val varargc, i7val *z);
void i7_print_dword(i7process *proc, i7val at);
char *i7_text_of_string(i7val str);
#define i7_bold 1
#define i7_roman 2
#define i7_underline 3

4776
inform7/Tests/Test Cases/_Results_Ideal/Obedience-C.txt Normal file
View file

File diff suppressed because it is too large Load diff

670
inform7/Tests/Test Cases/_Results_Ideal/Parts-C.txt Normal file
View file

@ -0,0 +1,670 @@
Welcome
An Interactive Fiction
Release 1 / Serial number 160428 / Inform 7 v10.1.0 / D
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty), a clown car (closed and empty) and a satchel (empty) here.
>** x tightrope
The tightrope features a bicycle.
>** x bicycle
The bicycle is empty.
>** get on bicycle
You get into the bicycle.
>** get out
You get out of the bicycle.
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty), a clown car (closed and empty) and a satchel (empty) here.
>** x sky
The sky features a flock of geese, a hot air balloon, a flying saucer and a flying kettle.
>** x geese
The flock of geese features two eyes.
>** ask geese about geese
There is no reply.
>** x balloon
In the hot air balloon is a picnic basket.
>** get in balloon
You get into the hot air balloon.
In the hot air balloon you can see a picnic basket (empty).
>** get all
satchel: You're carrying too many things already.
picnic basket: You're carrying too many things already.
leash: You're carrying too many things already.
very very small pair of sunglasses: You're carrying too many things already.
Fru-Yo bottle: You're carrying too many things already.
tollbooth coin: You're carrying too many things already.
squashed clown hat: You're carrying too many things already.
outsized green shoe: You're carrying too many things already.
>** out
You get out of the hot air balloon.
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty), a clown car (closed and empty) and a satchel (empty) here.
>** put all in satchle
You can't see any such thing.
>** put all in satchel
plastic daisy: Done.
whip: Done.
>** get satchel
Taken.
>** get in balloon
You get into the hot air balloon.
In the hot air balloon you can see a picnic basket (empty).
>** get all
picnic basket: Taken.
leash: (putting the picnic basket into the satchel to make room)
Taken.
very very small pair of sunglasses: (putting the leash into the satchel to make room)
Taken.
Fru-Yo bottle: (putting the very very small pair of sunglasses into the satchel to make room)
Taken.
tollbooth coin: (putting the Fru-Yo bottle into the satchel to make room)
Taken.
squashed clown hat: (putting the tollbooth coin into the satchel to make room)
Taken.
outsized green shoe: (putting the squashed clown hat into the satchel to make room)
Taken.
>** get out
You get out of the hot air balloon.
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** get on saucer
You get onto the flying saucer.
>** drop all
outsized green shoe: Dropped.
satchel: Dropped.
>** get out
You get off the flying saucer.
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** take all from saucer
satchel: Taken.
outsized green shoe: Taken.
>** i
You are carrying:
an outsized green shoe
a satchel (open)
a squashed clown hat
a tollbooth coin
a Fru-Yo bottle
a very very small pair of sunglasses
a leash
a picnic basket
a whip
a plastic daisy
>** turn on the kettle
You switch the flying kettle on.
>** turn it off
You switch the flying kettle off.
>** look
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** x unicycle
The unicycle features two pedals and a carrier basket.
>** get on it
You get into the unicycle.
>** look in carrier basket
The carrier basket is empty.
>** put leash in basket
Which do you mean, the carrier basket or the picnic basket?
>** carrier
(first taking the leash)
(putting the outsized green shoe into the satchel to make room)
You put the leash into the carrier basket.
>** take leash. put it in carrier basket.
Taken.
You put the leash into the carrier basket.
>** get out
You get out of the unicycle.
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** get leash
Taken.
>** x car
The clown car features a dashboard, a glove compartment, an inflatable driver, a start switch and a small spatial anomaly.
>** put coin on dashboard
(first taking the tollbooth coin)
(putting the leash into the satchel to make room)
You put the tollbooth coin on the dashboard.
>** take it
Taken.
>** put it on dashboard
You put the tollbooth coin on the dashboard.
>** x dashboard
The dashboard features a cup holder and an ashtray.
>** look in cup holder
The cup holder is empty.
>** look in ashtray
You can't see inside, since the ashtray is closed.
>** open it
You open the ashtray, revealing cigar ash.
>** take ash
Taken.
>** close ashtray
You close the ashtray.
>** put ash in ashtray
The ashtray is closed.
>** put ash in cup holder
You put cigar ash into the cup holder.
>** open ashtray
You open the ashtray.
>** put the fru in the ashtray
You can't see any such thing.
>** put the bottle in the ashtray
(first taking the Fru-Yo bottle)
You put the Fru-Yo bottle into the ashtray.
>** take it
Taken.
>** put it in the ashtray
You put the Fru-Yo bottle into the ashtray.
>** put the satchel in the glove compartment
You put the satchel into the glove compartment.
>** take satchel
Taken.
>** look
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** x driver
The inflatable driver features two eyes.
>** ask the driver about hot night spots
There is no reply.
>** look
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** x door
The rotating door features a control.
>** turn the door on
It isn't something you can switch.
>** turn the control on
You turn on the control on the rotating door; it begins to spin dizzily, but you could go through, if you wanted.
>** e
Striped Tent
Dusty light, filtered into alternating bars of red and yellow; sand and straw on the ground failing to entirely soak up the leavings from the performing animals; rows of flimsy benches without spectators.
Bobo is hanging from one of the supports. He gives you a look of consternation.
The Circus is too poor, or perhaps too nervous, to own a real lion. Instead it possesses a robot.
The Living Rug is lying around in a funk. It resembles a bearskin rug, but is in fact a freak of natur-- oh, well, that's just what you tell the guests. It's a big fur costume which someone puts on and walks around in.
The Visible Sheep is a purchase from an agricultural college. A door in the side of the sheep opens to reveal (through glass) all the sheep organs doing their assorted business.
You can also see a mother kangaroo, an elephant and a glass door here.
>** x bobo
The monkey features two eyes and a monkey's back.
>** x lion
(the robot lion)
The lion pathetically fails to respond.
>** x rug
The Living Rug features two eyes and a costume.
>** x sheep
The Visible Sheep features two eyes.
>** x kangaroo
(the mother kangaroo)
The mother kangaroo features two eyes and a pouch.
>** x elephant
The elephant features two eyes and a howdah.
>** get in howdah
You get into the howdah.
>** n
You can't go that way.
>** get out
You get out of the howdah.
Striped Tent
Dusty light, filtered into alternating bars of red and yellow; sand and straw on the ground failing to entirely soak up the leavings from the performing animals; rows of flimsy benches without spectators.
Bobo is hanging from one of the supports. He gives you a look of consternation.
The Circus is too poor, or perhaps too nervous, to own a real lion. Instead it possesses a robot.
The Living Rug is lying around in a funk. It resembles a bearskin rug, but is in fact a freak of natur-- oh, well, that's just what you tell the guests. It's a big fur costume which someone puts on and walks around in.
The Visible Sheep is a purchase from an agricultural college. A door in the side of the sheep opens to reveal (through glass) all the sheep organs doing their assorted business.
You can also see a mother kangaroo, an elephant and a glass door here.
>** look in pouch
In the pouch is a baby kangaroo.
>** get baby
That seems to belong to the mother kangaroo.
>** put satchel in outer compartment
You can't put something inside itself.
>** put kangaroo in pouch
(the mother kangaroo in the pouch)
(first taking the mother kangaroo)
I don't suppose the mother kangaroo would care for that.
>** open glass door
You open the glass door.
>** enter it
You can't, since the glass door leads nowhere.
>** wear rug
(first taking the Living Rug)
I don't suppose the Living Rug would care for that.
>** turn on lion switch
You switch the lion switch on.
>** x lion
(the robot lion)
The robot lion features two eyes and a lion switch.
>** put satchel on monkey's back
You put the satchel on the monkey's back.
>** get it
That seems to belong to the monkey.
>** purloin it
[Purloined.]
>** look
Striped Tent
Dusty light, filtered into alternating bars of red and yellow; sand and straw on the ground failing to entirely soak up the leavings from the performing animals; rows of flimsy benches without spectators.
Bobo is hanging from one of the supports. He gives you a look of consternation.
The Circus is too poor, or perhaps too nervous, to own a real lion. Instead it possesses a robot.
The Living Rug is lying around in a funk. It resembles a bearskin rug, but is in fact a freak of natur-- oh, well, that's just what you tell the guests. It's a big fur costume which someone puts on and walks around in.
The Visible Sheep is a purchase from an agricultural college. A door in the side of the sheep opens to reveal (through glass) all the sheep organs doing their assorted business.
You can also see a mother kangaroo, an elephant and a glass door here.
>** w
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** w
Mirror Funhouse
You can see a rotating door, a reflecting door and a trapdoor here.
>** z
Time passes.
>** put all on trapdoor
satchel: Done.
>** d
(first opening the trapdoor)
The satchel is in your way.
>** open trapdoor
The satchel is in your way.
>** take all from surface
(the satchel from the surface)
Taken.
>** open trapdoor
You open the trapdoor.
>** d
Oubliette
You can see a trapdoor here.
>** u
Mirror Funhouse
You can see a trapdoor, a rotating door and a reflecting door here.
>** x reflecting
The reflecting door features a doppelganger.
>** x doppelganger
The doppelganger features two eyes.
>** say hi to doppelganger
Your image responds in kind.
>** ask it about Tories
You can only do that to something animate.
>** ask doppelganger about tories
Your image responds in kind.
>** n
(first opening the reflecting door)
esouhnuF rorriM
You can see a reflecting door and a platform here.
>** open door
That's already open.
>** reflecting
That's not a verb I recognise.
>** n
You can't go that way.
>** open platform
You open the platform.
>** d
Bottom of the Well
You can see a platform here.
>** u
esouhnuF rorriM
You can see a platform and a reflecting door here.
>** put all in bucket
satchel: Done.
>** get all from bucket
(the satchel from the bucket)
Taken.
>** w
You can't go that way.
>** s
Mirror Funhouse
You can see a reflecting door, a trapdoor and a rotating door here.
>** w
You can't go that way.
>** e
Circus Backlot
Storage for the various contraptions that are used in acts -- or were once used, before being given up as no good.
There is a chasm here which can only be traversed by riding a bicycle along a tightrope. A cinch, really.
You can also see a rotating door, an unicycle (empty) and a clown car (closed and empty) here.
>** n
Wardrobe Trailer
Paneled inside and out in seductively hideous faux-walnut veneer.
You can see a painted box (on which is a silver key) (closed) here.
>** take key
Taken.
>** open box
You open the painted box, revealing a pair of spangled tights, a busker's apron and a tall hat.
>** x key
You see nothing special about the silver key.
>** take all from box
pair of spangled tights: (putting the silver key into the satchel to make room)
Taken.
busker's apron: (putting the pair of spangled tights into the satchel to make room)
Taken.
tall hat: (putting the busker's apron into the satchel to make room)
Taken.
>** wear apron
(first taking the busker's apron)
(putting the tall hat into the satchel to make room)
You put on the busker's apron.
>** put apron in the pocket
You can't put something inside itself.
>** take hat
Which do you mean, the tall hat or the squashed clown hat?
>** tall
Taken.
>** x tall hat
The tall hat features a crown.
>** search crown
On the crown is frightened-looking rabbit.
>** take rabbit
(putting the tall hat into the satchel to make room)
Taken.
>** i
You are carrying:
frightened-looking rabbit
a busker's apron (being worn)
a satchel (open)
a tall hat
a pair of spangled tights
a silver key
a leash
an outsized green shoe
a squashed clown hat
a very very small pair of sunglasses
a picnic basket
a whip
a plastic daisy
>** put whip on crown
(first taking the whip)
(putting frightened-looking rabbit into the satchel to make room)
You put the whip on the crown.
>** take it
Taken.
>** put it on crown
You put the whip on the crown.
>** wear hat
Which do you mean, the tall hat or the squashed clown hat?
>** tall
(first taking the tall hat)
You put on the tall hat.
>** put whip on crown
(first taking the whip)
You put the whip on the crown.
>** take whip
Taken.
>** put whip on crown
You put the whip on the crown.
>** i
You are carrying:
a tall hat (being worn)
a busker's apron (being worn)
a satchel (open)
frightened-looking rabbit
a pair of spangled tights
a silver key
a leash
an outsized green shoe
a squashed clown hat
a very very small pair of sunglasses
a picnic basket
a plastic daisy
>** put hat on crown
(the tall hat on the crown)
You can't put something on top of itself.
>** look
Wardrobe Trailer
Paneled inside and out in seductively hideous faux-walnut veneer.
You can see a painted box (empty) here.
>** i
You are carrying:
a tall hat (being worn)
a busker's apron (being worn)
a satchel (open)
frightened-looking rabbit
a pair of spangled tights
a silver key
a leash
an outsized green shoe
a squashed clown hat
a very very small pair of sunglasses
a picnic basket
a plastic daisy
>** wear tights
(first taking the pair of spangled tights)
Can't you put your spangled tights on one leg at a time like any other man?
>** wear left leg
(first taking the left leg)
That seems to be a part of the pair of spangled tights.
>** wear right leg
(first taking the right leg)
That seems to be a part of the pair of spangled tights.
>** i
You are carrying:
a pair of spangled tights
a tall hat (being worn)
a busker's apron (being worn)
a satchel (open)
frightened-looking rabbit
a silver key
a leash
an outsized green shoe
a squashed clown hat
a very very small pair of sunglasses
a picnic basket
a plastic daisy
>** quit
Are you sure you want to quit? ** y

4
inter/final-module/Chapter 2/Constants and Literals.w
View file

@ -168,7 +168,7 @@ void CodeGen::CL::constant(code_generation *gen, inter_tree_node *P) {
"Con %S has depth %d\n", con_name->symbol_name, depth);
CodeGen::CL::constant_depth(con_name);
}
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, depth));
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, con_name, depth));
text_stream *OUT = CodeGen::current(gen);
if (CodeGen::Targets::begin_constant(gen, CodeGen::CL::name(con_name), con_name, P, TRUE, FALSE)) {
WRITE("(");
@ -195,7 +195,7 @@ void CodeGen::CL::constant(code_generation *gen, inter_tree_node *P) {
int depth = CodeGen::CL::constant_depth(con_name);
if (depth > 1) LOGIF(CONSTANT_DEPTH_CALCULATION,
"Con %S has depth %d\n", con_name->symbol_name, depth);
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, depth));
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, con_name, depth));
if (CodeGen::Targets::begin_constant(gen, CodeGen::CL::name(con_name), con_name, P, TRUE, ifndef_me)) {
inter_ti val1 = P->W.data[DATA_CONST_IFLD];
inter_ti val2 = P->W.data[DATA_CONST_IFLD + 1];

6
inter/final-module/Chapter 2/Final Targets.w
View file

@ -65,7 +65,7 @@ int CodeGen::Targets::end_generation(code_generation *gen) {
=
INT_METHOD_TYPE(GENERAL_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen, inter_tree_node *P)
INT_METHOD_TYPE(DEFAULT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(BASIC_CONSTANT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen, int depth)
INT_METHOD_TYPE(BASIC_CONSTANT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen, inter_symbol *con_name, int depth)
INT_METHOD_TYPE(CONSTANT_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
INT_METHOD_TYPE(TL_SEGMENT_MTID, code_generation_target *cgt, code_generation *gen)
@ -87,9 +87,9 @@ int CodeGen::Targets::constant_segment(code_generation *gen) {
return rv;
}
int CodeGen::Targets::basic_constant_segment(code_generation *gen, int depth) {
int CodeGen::Targets::basic_constant_segment(code_generation *gen, inter_symbol *con_name, int depth) {
int rv = 0;
INT_METHOD_CALL(rv, gen->target, BASIC_CONSTANT_SEGMENT_MTID, gen, depth);
INT_METHOD_CALL(rv, gen->target, BASIC_CONSTANT_SEGMENT_MTID, gen, con_name, depth);
return rv;
}

4
inter/final-module/Chapter 2/Instances and Properties.w
View file

@ -238,7 +238,7 @@ we assume that's the name of an attribute already declared (for example
in the I6 template, or some extension), and we therefore do nothing.
@<Declare as an I6 attribute@> =
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, 1));
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, prop_name, 1));
if (Inter::Symbols::read_annotation(prop_name, ASSIMILATED_IANN) >= 0) {
text_stream *A = Inter::Symbols::get_translate(prop_name);
if (A == NULL) A = CodeGen::CL::name(prop_name);
@ -880,7 +880,7 @@ void CodeGen::IP::instance(code_generation *gen, inter_tree_node *P) {
inter_ti val2 = P->W.data[VAL2_INST_IFLD];
int defined = TRUE;
if (val1 == UNDEF_IVAL) defined = FALSE;
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, 1));
generated_segment *saved = CodeGen::select(gen, CodeGen::Targets::basic_constant_segment(gen, inst_name, 1));
text_stream *OUT = CodeGen::current(gen);
if (CodeGen::Targets::begin_constant(gen, CodeGen::CL::name(inst_name), inst_name, P, defined, FALSE)) {
if (defined) {

2
inter/final-module/Chapter 4/Final Inform 6.w
View file

@ -269,7 +269,7 @@ int CodeGen::I6::default_segment(code_generation_target *cgt) {
int CodeGen::I6::constant_segment(code_generation_target *cgt, code_generation *gen) {
return early_matter_I7CGS;
}
int CodeGen::I6::basic_constant_segment(code_generation_target *cgt, code_generation *gen, int depth) {
int CodeGen::I6::basic_constant_segment(code_generation_target *cgt, code_generation *gen, inter_symbol *con_name, int depth) {
if (depth >= 10) depth = 10;
return constants_1_I7CGS + depth - 1;
}

35
inter/final-module/Chapter 5/C Assembly.w
View file

@ -92,6 +92,7 @@ void CAssembly::assembly(code_generation_target *cgt, code_generation *gen,
store_this_operand[3] = TRUE;
vararg_operands_from = 2; vararg_operands_to = operand_count-1;
}
if (Str::eq(opcode, I"@hasundo")) store_this_operand[1] = TRUE;
if (Str::eq(opcode, I"@log")) store_this_operand[2] = TRUE;
if (Str::eq(opcode, I"@mod")) store_this_operand[3] = TRUE;
if (Str::eq(opcode, I"@mul")) store_this_operand[3] = TRUE;
@ -99,6 +100,8 @@ void CAssembly::assembly(code_generation_target *cgt, code_generation *gen,
if (Str::eq(opcode, I"@numtof")) store_this_operand[2] = TRUE;
if (Str::eq(opcode, I"@pow")) store_this_operand[3] = TRUE;
if (Str::eq(opcode, I"@random")) store_this_operand[2] = TRUE;
if (Str::eq(opcode, I"@restoreundo")) store_this_operand[1] = TRUE;
if (Str::eq(opcode, I"@saveundo")) store_this_operand[1] = TRUE;
if (Str::eq(opcode, I"@shiftl")) store_this_operand[3] = TRUE;
if (Str::eq(opcode, I"@sin")) store_this_operand[2] = TRUE;
if (Str::eq(opcode, I"@sqrt")) store_this_operand[2] = TRUE;
@ -170,12 +173,14 @@ void glulx_aloadb(i7process *proc, i7val x, i7val y, i7val *z);
void glulx_binarysearch(i7process *proc, i7val key, i7val keysize, i7val start, i7val structsize,
i7val numstructs, i7val keyoffset, i7val options, i7val *s1);
void glulx_shiftl(i7process *proc, i7val x, i7val y, i7val *z);
void glulx_restoreundo(i7process *proc, i7val x);
void glulx_saveundo(i7process *proc, i7val x);
void glulx_restoreundo(i7process *proc, i7val *x);
void glulx_saveundo(i7process *proc, i7val *x);
void glulx_restart(i7process *proc);
void glulx_restore(i7process *proc, i7val x, i7val y);
void glulx_save(i7process *proc, i7val x, i7val y);
void glulx_verify(i7process *proc, i7val x);
void glulx_hasundo(i7process *proc, i7val *x);
void glulx_discardundo(i7process *proc);
=
= (text to inform7_clib.c)
@ -354,10 +359,32 @@ void glulx_shiftl(i7process *proc, i7val x, i7val y, i7val *z) {
i7_fatal_exit(proc);
}
void glulx_restoreundo(i7process *proc, i7val x) {
void glulx_restoreundo(i7process *proc, i7val *x) {
proc->just_undid = 1;
if (i7_has_snapshot(proc)) {
i7_restore_snapshot(proc);
if (x) *x = 0;
#ifdef i7_mgl_DealWithUndo
fn_i7_mgl_DealWithUndo(proc);
#endif
} else {
if (x) *x = 1;
}
}
void glulx_saveundo(i7process *proc, i7val x) {
void glulx_saveundo(i7process *proc, i7val *x) {
proc->just_undid = 0;
i7_save_snapshot(proc);
if (x) *x = 0;
}
void glulx_hasundo(i7process *proc, i7val *x) {
i7val rv = 0; if (i7_has_snapshot(proc)) rv = 1;
if (x) *x = rv;
}
void glulx_discardundo(i7process *proc) {
i7_destroy_latest_snapshot(proc);
}
void glulx_restart(i7process *proc) {

4
inter/final-module/Chapter 5/C Function Model.w
View file

@ -86,7 +86,9 @@ final_c_function *CFunctionModel::new_fcf(text_stream *unmangled_name) {
}
void CFunctionModel::declare_fcf(code_generation *gen, final_c_function *fcf) {
generated_segment *saved = CodeGen::select(gen, c_predeclarations_I7CGS);
int seg = c_predeclarations_I7CGS;
if (Str::eq(fcf->identifier_as_constant, I"DealWithUndo")) seg = c_ids_and_maxima_I7CGS;
generated_segment *saved = CodeGen::select(gen, seg);
text_stream *OUT = CodeGen::current(gen);
WRITE("#define ");
CNamespace::mangle(NULL, OUT, fcf->identifier_as_constant);

2
inter/final-module/Chapter 5/C Input-Output Model.w
View file

@ -31,7 +31,7 @@ int CInputOutputModel::compile_primitive(code_generation *gen, inter_ti bip, int
case STYLEUNDERLINE_BIP: WRITE("i7_style(proc, i7_underline)"); break;
case STYLEREVERSE_BIP: WRITE("i7_style(proc, i7_reverse)"); break;
case PRINT_BIP: WRITE("i7_print_C_string(proc, "); INV_A1_PRINTMODE; WRITE(")"); break;
case PRINTRET_BIP: WRITE("i7_print_C_string(proc, "); INV_A1_PRINTMODE; WRITE("); return 1"); break;
case PRINTRET_BIP: WRITE("i7_print_C_string(proc, "); INV_A1_PRINTMODE; WRITE("); i7_print_char(proc, '\\n'); return 1"); break;
case PRINTCHAR_BIP: WRITE("i7_print_char(proc, "); INV_A1; WRITE(")"); break;
case PRINTOBJ_BIP: WRITE("i7_print_object(proc, "); INV_A1; WRITE(")"); break;
case PRINTNUMBER_BIP: WRITE("i7_print_decimal(proc, "); INV_A1; WRITE(")"); break;

6
inter/final-module/Chapter 5/C Literals.w
View file

@ -736,6 +736,7 @@ int CLiteralsModel::compile_primitive(code_generation *gen, inter_ti bip, inter_
= (text to inform7_clib.h)
void i7_print_dword(i7process *proc, i7val at);
char *i7_text_of_string(i7val str);
=
= (text to inform7_clib.c)
@ -746,4 +747,9 @@ void i7_print_dword(i7process *proc, i7val at) {
i7_print_char(proc, c);
}
}
char *dqs[];
char *i7_text_of_string(i7val str) {
return dqs[str - I7VAL_STRINGS_BASE];
}
=

14
inter/final-module/Chapter 5/C Memory Model.w
View file

@ -77,7 +77,7 @@ void CMemoryModel::end(code_generation *gen) {
saved = CodeGen::select(gen, c_ids_and_maxima_I7CGS);
OUT = CodeGen::current(gen);
WRITE("#define i7_himem %d\n", C_GEN_DATA(memdata.himem));
WRITE("#define i7_static_himem %d\n", C_GEN_DATA(memdata.himem));
CodeGen::deselect(gen, saved);
}
@ -90,13 +90,14 @@ void i7_initialise_state(i7process *proc);
= (text to inform7_clib.c)
void i7_initialise_state(i7process *proc) {
if (proc->state.memory != NULL) free(proc->state.memory);
i7byte *mem = calloc(i7_himem, sizeof(i7byte));
i7byte *mem = calloc(i7_static_himem, sizeof(i7byte));
if (mem == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
proc->state.memory = mem;
for (int i=0; i<i7_himem; i++) mem[i] = i7_initial_memory[i];
proc->state.himem = i7_static_himem;
for (int i=0; i<i7_static_himem; i++) mem[i] = i7_initial_memory[i];
#ifdef i7_mgl_Release
mem[0x34] = I7BYTE_2(i7_mgl_Release);
mem[0x35] = I7BYTE_3(i7_mgl_Release);
@ -106,7 +107,8 @@ void i7_initialise_state(i7process *proc) {
mem[0x35] = I7BYTE_3(1);
#endif
#ifdef i7_mgl_Serial
for (int i=0; i<6; i++) mem[0x36 + i] = (dqs[i7_mgl_Serial - I7VAL_STRINGS_BASE])[i];
char *p = i7_text_of_string(i7_mgl_Serial);
for (int i=0; i<6; i++) mem[0x36 + i] = p[i];
#endif
#ifndef i7_mgl_Serial
for (int i=0; i<6; i++) mem[0x36 + i] = '0';
@ -159,7 +161,7 @@ i7byte i7_read_byte(i7process *proc, i7val address) {
i7val i7_read_word(i7process *proc, i7val array_address, i7val array_index) {
i7byte *data = proc->state.memory;
int byte_position = array_address + 4*array_index;
if ((byte_position < 0) || (byte_position >= i7_himem)) {
if ((byte_position < 0) || (byte_position >= i7_static_himem)) {
printf("Memory access out of range: %d\n", byte_position);
i7_fatal_exit(proc);
}
@ -216,7 +218,7 @@ i7val i7_write_word(i7process *proc, i7val array_address, i7val array_index, i7v
case i7_lvalue_CLEARBIT: new_val = old_val &(~new_val); return_val = new_val; break;
}
int byte_position = array_address + 4*array_index;
if ((byte_position < 0) || (byte_position >= i7_himem)) {
if ((byte_position < 0) || (byte_position >= i7_static_himem)) {
printf("Memory access out of range: %d\n", byte_position);
i7_fatal_exit(proc);
}

131
inter/final-module/Chapter 5/Final C.w
View file

@ -65,6 +65,7 @@ typedef unsigned char i7byte;
typedef struct i7state {
i7byte *memory;
i7val himem;
i7val stack[I7_ASM_STACK_CAPACITY];
int stack_pointer;
i7val *i7_object_tree_parent;
@ -73,17 +74,37 @@ typedef struct i7state {
i7val *variables;
i7val tmp;
} i7state;
typedef struct i7snapshot {
int valid;
struct i7state then;
jmp_buf env;
} i7snapshot;
#define I7_MAX_SNAPSHOTS 10
typedef struct i7process {
i7state state;
i7snapshot snapshots[I7_MAX_SNAPSHOTS];
int snapshot_pos;
jmp_buf execution_env;
int termination_code;
int just_undid;
} i7process;
i7state i7_new_state(void);
i7process i7_new_process(void);
i7snapshot i7_new_snapshot(void);
void i7_save_snapshot(i7process *proc);
int i7_has_snapshot(i7process *proc);
void i7_restore_snapshot(i7process *proc);
void i7_restore_snapshot_from(i7process *proc, i7snapshot *ss);
int i7_destroy_latest_snapshot(i7process *proc);
void i7_run_process(i7process *proc, void (*receiver)(int id, wchar_t c));
void i7_initializer(i7process *proc);
void i7_fatal_exit(i7process *proc);
void i7_destroy_state(i7process *proc, i7state *s);
void i7_destroy_snapshot(i7process *proc, i7snapshot *old);
=
= (text to inform7_clib.c)
@ -93,6 +114,7 @@ void i7_fatal_exit(i7process *proc);
i7state i7_new_state(void) {
i7state S;
S.memory = NULL;
S.himem = 0;
S.tmp = 0;
S.stack_pointer = 0;
S.i7_object_tree_parent = NULL;
@ -102,12 +124,117 @@ i7state i7_new_state(void) {
return S;
}
void i7_copy_state(i7process *proc, i7state *to, i7state *from) {
to->himem = from->himem;
to->memory = calloc(i7_static_himem, sizeof(i7byte));
if (to->memory == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_static_himem; i++) to->memory[i] = from->memory[i];
to->tmp = from->tmp;
to->stack_pointer = from->stack_pointer;
for (int i=0; i<from->stack_pointer; i++) to->stack[i] = from->stack[i];
to->i7_object_tree_parent = calloc(i7_max_objects, sizeof(i7val));
to->i7_object_tree_child = calloc(i7_max_objects, sizeof(i7val));
to->i7_object_tree_sibling = calloc(i7_max_objects, sizeof(i7val));
if ((to->i7_object_tree_parent == NULL) ||
(to->i7_object_tree_child == NULL) ||
(to->i7_object_tree_sibling == NULL)) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_max_objects; i++) {
to->i7_object_tree_parent[i] = from->i7_object_tree_parent[i];
to->i7_object_tree_child[i] = from->i7_object_tree_child[i];
to->i7_object_tree_sibling[i] = from->i7_object_tree_sibling[i];
}
to->variables = calloc(i7_no_variables, sizeof(i7val));
if (to->variables == NULL) {
printf("Memory allocation failed\n");
i7_fatal_exit(proc);
}
for (int i=0; i<i7_no_variables; i++)
to->variables[i] = from->variables[i];
}
void i7_destroy_state(i7process *proc, i7state *s) {
free(s->memory);
s->himem = 0;
free(s->i7_object_tree_parent);
free(s->i7_object_tree_child);
free(s->i7_object_tree_sibling);
s->stack_pointer = 0;
free(s->variables);
}
void i7_destroy_snapshot(i7process *proc, i7snapshot *old) {
i7_destroy_state(proc, &(old->then));
old->valid = 0;
}
i7snapshot i7_new_snapshot(void) {
i7snapshot SS;
SS.valid = 0;
SS.then = i7_new_state();
return SS;
}
i7process i7_new_process(void) {
i7process proc;
proc.state = i7_new_state();
for (int i=0; i<I7_MAX_SNAPSHOTS; i++) proc.snapshots[i] = i7_new_snapshot();
proc.just_undid = 0;
proc.snapshot_pos = 0;
return proc;
}
void i7_save_snapshot(i7process *proc) {
if (proc->snapshots[proc->snapshot_pos].valid)
i7_destroy_snapshot(proc, &(proc->snapshots[proc->snapshot_pos]));
proc->snapshots[proc->snapshot_pos] = i7_new_snapshot();
proc->snapshots[proc->snapshot_pos].valid = 1;
i7_copy_state(proc, &(proc->snapshots[proc->snapshot_pos].then), &(proc->state));
int was = proc->snapshot_pos;
proc->snapshot_pos++;
if (proc->snapshot_pos == I7_MAX_SNAPSHOTS) proc->snapshot_pos = 0;
// if (setjmp(proc->snapshots[was].env)) fprintf(stdout, "*** Restore! %d ***\n", proc->just_undid);
}
int i7_has_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
return proc->snapshots[will_be].valid;
}
int i7_destroy_latest_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
if (proc->snapshots[will_be].valid)
i7_destroy_snapshot(proc, &(proc->snapshots[will_be]));
proc->snapshot_pos = will_be;
}
void i7_restore_snapshot(i7process *proc) {
int will_be = proc->snapshot_pos - 1;
if (will_be < 0) will_be = I7_MAX_SNAPSHOTS - 1;
if (proc->snapshots[will_be].valid == 0) {
printf("Restore impossible\n");
i7_fatal_exit(proc);
}
i7_restore_snapshot_from(proc, &(proc->snapshots[will_be]));
i7_destroy_snapshot(proc, &(proc->snapshots[will_be]));
int was = proc->snapshot_pos;
proc->snapshot_pos = will_be;
// longjmp(proc->snapshots[was].env, 1);
}
void i7_restore_snapshot_from(i7process *proc, i7snapshot *ss) {
i7_destroy_state(proc, &(proc->state));
i7_copy_state(proc, &(proc->state), &(ss->then));
}
#ifndef I7_NO_MAIN
void default_receiver(int id, wchar_t c) {
if (id == 201) fputc(c, stdout);
@ -298,7 +425,9 @@ int CTarget::default_segment(code_generation_target *cgt) {
int CTarget::constant_segment(code_generation_target *cgt, code_generation *gen) {
return c_early_matter_I7CGS;
}
int CTarget::basic_constant_segment(code_generation_target *cgt, code_generation *gen, int depth) {
int CTarget::basic_constant_segment(code_generation_target *cgt, code_generation *gen, inter_symbol *con_name, int depth) {
if (Str::eq(CodeGen::CL::name(con_name), I"Release")) return c_ids_and_maxima_I7CGS;
if (Str::eq(CodeGen::CL::name(con_name), I"Serial")) return c_ids_and_maxima_I7CGS;
if (depth >= 10) depth = 10;
return c_constants_1_I7CGS + depth - 1;
}