ifhub/inform7
1
0
Fork 0
mirror of https://github.com/ganelson/inform.git synced 2024-06-26 04:00:43 +03:00
Code Issues Projects Releases Wiki Activity

Further experiments with literal notation

Browse source
This commit is contained in:
Graham Nelson 2023-07-10 11:04:12 +01:00
parent 3418a5098f
commit 21f9331dce
23 changed files with 881 additions and 245 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -1,6 +1,6 @@
# Inform 7
[Version](notes/versioning.md): 10.2.0-beta+6W76 'Krypton' (9 July 2023)
[Version](notes/versioning.md): 10.2.0-beta+6W77 'Krypton' (10 July 2023)
## About Inform

4
build.txt
View file

@ -1,3 +1,3 @@
Prerelease: beta
Build Date: 9 July 2023
Build Number: 6W76
Build Date: 10 July 2023
Build Number: 6W77

83
docs/assertions-module/3-nlpr.html
View file

@ -430,11 +430,70 @@ by a bracketed list of up to three options in any order.
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">with</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">leading</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">zeros</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { WITH_LEADING_ZEROS_LSO, - }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">without</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">leading</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">zeros</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { WITHOUT_LEADING_ZEROS_LSO, - }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">in</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;number-base&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { BASE_LSO*R[1], - }</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">maximum</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> { MAXIMUM_LSO, - }; &lt;&lt;max_part_val&gt;&gt; = R[1];</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">......</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_1" class="named-paragraph-link"><span class="named-paragraph">Issue PM_BadLPPartOption problem</span><span class="named-paragraph-number">8.1</span></a></span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> &lt;&lt;max_part_val&gt;&gt; = R[2]; </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_1" class="named-paragraph-link"><span class="named-paragraph">Apply range</span><span class="named-paragraph-number">8.1</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">up</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;number-base&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">digit/digits</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_4" class="named-paragraph-link"><span class="named-paragraph">Apply based max digit count</span><span class="named-paragraph-number">8.4</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">up</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">to</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">digit/digits</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_2" class="named-paragraph-link"><span class="named-paragraph">Apply max digit count</span><span class="named-paragraph-number">8.2</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;number-base&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">digit/digits</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_5" class="named-paragraph-link"><span class="named-paragraph">Apply based digit count</span><span class="named-paragraph-number">8.5</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-function-syntax">&lt;cardinal-number&gt;</span><span class="Preform-plain-syntax"> </span><span class="Preform-constant-syntax">digit/digits</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">|</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_3" class="named-paragraph-link"><span class="named-paragraph">Apply digit count</span><span class="named-paragraph-number">8.3</span></a></span><span class="Preform-constant-syntax">;</span>
<span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">......</span><span class="Preform-plain-syntax"> </span><span class="Preform-reserved-syntax">==&gt;</span><span class="Preform-plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-nlpr.html#SP8_6" class="named-paragraph-link"><span class="named-paragraph">Issue PM_BadLPPartOption problem</span><span class="named-paragraph-number">8.6</span></a></span>
</pre>
<ul class="endnotetexts"><li>This is <a href="../words-module/4-ap.html" class="internal">Preform grammar</a>, not regular C code.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_1" class="paragraph-anchor"></a><b>&#167;8.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue PM_BadLPPartOption problem</span><span class="named-paragraph-number">8.1</span></span><span class="Preform-comment-syntax"> =</span>
<p class="commentary firstcommentary"><a id="SP8_1" class="paragraph-anchor"></a><b>&#167;8.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply range</span><span class="named-paragraph-number">8.1</span></span><span class="Preform-comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] != </span><span class="constant-syntax">0</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the range in a named part has to begin at 0"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"for the moment at least."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> ==&gt; { </span><span class="constant-syntax">MAXIMUM_LSO</span><span class="plain-syntax">, - };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-nlpr.html#SP8">&#167;8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_2" class="paragraph-anchor"></a><b>&#167;8.2. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply max digit count</span><span class="named-paragraph-number">8.2</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] &lt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the digit count in a named part has to be at least 1"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"for obvious reasons."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> ==&gt; { </span><span class="constant-syntax">MAX_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1], - }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-nlpr.html#SP8">&#167;8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_3" class="paragraph-anchor"></a><b>&#167;8.3. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply digit count</span><span class="named-paragraph-number">8.3</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] &lt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the digit count in a named part has to be at least 1"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"for obvious reasons."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> ==&gt; { </span><span class="constant-syntax">MAX_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] + </span><span class="constant-syntax">MIN_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] + </span><span class="constant-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax">, - };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-nlpr.html#SP8">&#167;8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_4" class="paragraph-anchor"></a><b>&#167;8.4. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply based max digit count</span><span class="named-paragraph-number">8.4</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] &lt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the digit count in a named part has to be at least 1"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"for obvious reasons."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> ==&gt; { </span><span class="constant-syntax">MAX_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] + </span><span class="constant-syntax">BASE_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[2], - }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-nlpr.html#SP8">&#167;8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_5" class="paragraph-anchor"></a><b>&#167;8.5. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Apply based digit count</span><span class="named-paragraph-number">8.5</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] &lt; </span><span class="constant-syntax">1</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the digit count in a named part has to be at least 1"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"for obvious reasons."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> ==&gt; { </span><span class="constant-syntax">MAX_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] + </span><span class="constant-syntax">MIN_DIGITS_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[1] + </span><span class="constant-syntax">BASE_LSO</span><span class="plain-syntax">*</span><span class="identifier-syntax">R</span><span class="plain-syntax">[2] + </span><span class="constant-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax">, - };</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-nlpr.html#SP8">&#167;8</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP8_6" class="paragraph-anchor"></a><b>&#167;8.6. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Issue PM_BadLPPartOption problem</span><span class="named-paragraph-number">8.6</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -463,13 +522,17 @@ by a bracketed list of up to three options in any order.
<p class="commentary firstcommentary"><a id="SP10" class="paragraph-anchor"></a><b>&#167;10. </b>Nodes used as "parts" of a notation are annotated with a bitmap of these:
</p>
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">OPTIONAL_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">1</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">PREAMBLE_OPTIONAL_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">2</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">4</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">WITHOUT_LEADING_ZEROS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">8</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MAXIMUM_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">16</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">BASE_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x10000</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">BASE_MASK_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0xff0000</span>
<pre class="definitions code-font"><span class="definition-keyword">define</span> <span class="constant-syntax">OPTIONAL_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000001</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">PREAMBLE_OPTIONAL_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000002</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000004</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">WITHOUT_LEADING_ZEROS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000008</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MAXIMUM_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000010</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">BASE_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00000100</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">BASE_MASK_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x0000ff00</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MIN_DIGITS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x00010000</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MIN_DIGITS_MASK_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x007f0000</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MAX_DIGITS_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x01000000</span>
<span class="definition-keyword">define</span> <span class="constant-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax"> </span><span class="constant-syntax">0x7f000000</span>
</pre>
<pre class="displayed-code all-displayed-code code-font">
<span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="function-syntax">LPRequests::mark</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">LPRequests::mark</span></span>:<br/><a href="3-nlpr.html#SP8">&#167;8</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">A</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">N</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">M</span><span class="plain-syntax">) {</span>

2
docs/lexicon-module/P-wtmd.html
View file

@ -182,7 +182,7 @@ number of successes.
</li></ul>
<pre class="undisplayed-code all-displayed-code code-font">
<span class="plain-syntax">Size of lexicon: 3143 excerpt meanings</span>
<span class="plain-syntax"> Stored among 850 words out of total vocabulary of 10766</span>
<span class="plain-syntax"> Stored among 850 words out of total vocabulary of 10769</span>
<span class="plain-syntax"> 720 words have a start list: longest belongs to report (with 293 meanings)</span>
<span class="plain-syntax"> 15 words have an end list: longest belongs to case (with 6 meanings)</span>
<span class="plain-syntax"> 29 words have a middle list: longest belongs to to (with 4 meanings)</span>

78
docs/runtime-module/5-lp.html
View file

@ -315,9 +315,7 @@ the first function appears.)
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">with_leading_zeros</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax"> ((</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">lp_tokens</span><span class="plain-syntax">[</span><span class="identifier-syntax">tc</span><span class="plain-syntax">].</span><span class="identifier-syntax">new_word_at</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">without_leading_zeros</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">print_with_leading_zeros</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">pow</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">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">element_range</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">pow</span><span class="plain-syntax">) </span><span class="identifier-syntax">pow</span><span class="plain-syntax"> = </span><span class="identifier-syntax">pow</span><span class="plain-syntax"> * </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">pow</span><span class="plain-syntax">&gt;1; </span><span class="identifier-syntax">pow</span><span class="plain-syntax"> = </span><span class="identifier-syntax">pow</span><span class="plain-syntax">/</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax">)</span>
@ -1181,29 +1179,47 @@ sets the <span class="extract"><span class="extract-syntax">parsed_number</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_false</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">STORE_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP13" class="function-link"><span class="function-syntax">EmitCode::ref_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">rv_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">(0);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">WHILE_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">AND_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">LT_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">wpos_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">cur_len_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">GE_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::call</span></a><span class="plain-syntax">(</span><a href="2-hrr.html#SP11" class="function-link"><span class="function-syntax">Hierarchy::find</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DIGITTOVALUE_HL</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">max_digits</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">1000000</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">LT_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">bufferbip</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">cur_addr_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">wpos_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax"> != </span><span class="constant-syntax">10</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">((</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">rv_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">((</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">max_digits</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">(0);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">AND_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">LT_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">wpos_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">cur_len_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">GE_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::call</span></a><span class="plain-syntax">(</span><a href="2-hrr.html#SP11" class="function-link"><span class="function-syntax">Hierarchy::find</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">DIGITTOVALUE_HL</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">bufferbip</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">cur_addr_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">wpos_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax"> != </span><span class="constant-syntax">10</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">((</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">number_base</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">(0);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">max_digits</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">1000000</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP5" class="function-link"><span class="function-syntax">EmitCode::code</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
@ -1232,6 +1248,10 @@ sets the <span class="extract"><span class="extract-syntax">parsed_number</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP13" class="function-link"><span class="function-syntax">EmitCode::ref_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">wpos_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">POSTINCREMENT_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP13" class="function-link"><span class="function-syntax">EmitCode::ref_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">rv_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
@ -1251,6 +1271,24 @@ sets the <span class="extract"><span class="extract-syntax">parsed_number</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><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">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">min_digits</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">IF_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">LT_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_symbol</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">K_value</span><span class="plain-syntax">, </span><span class="identifier-syntax">gprk</span><span class="plain-syntax">.</span><span class="element-syntax">rv_s</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP8" class="function-link"><span class="function-syntax">EmitCode::val_number</span></a><span class="plain-syntax">((</span><span class="identifier-syntax">inter_ti</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">min_digits</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP5" class="function-link"><span class="function-syntax">EmitCode::code</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">JUMP_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP17" class="function-link"><span class="function-syntax">EmitCode::lab</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">failed_label</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::up</span></a><span class="plain-syntax">();</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">element_index</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP14" class="function-link"><span class="function-syntax">EmitCode::inv</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">IF_BIP</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="2-ec.html#SP3" class="function-link"><span class="function-syntax">EmitCode::down</span></a><span class="plain-syntax">();</span>

4
docs/values-module/1-vm.html
View file

@ -61,7 +61,8 @@ which use this module:
<p class="commentary firstcommentary"><a id="SP2" class="paragraph-anchor"></a><b>&#167;2. </b>Like all modules, this one must define a <span class="extract"><span class="extract-syntax">start</span></span> and <span class="extract"><span class="extract-syntax">end</span></span> function:
</p>
<pre class="definitions code-font"><span class="definition-keyword">enum</span> <span class="constant-syntax">OBJECT_CREATIONS_DA</span>
<pre class="definitions code-font"><span class="definition-keyword">enum</span> <span class="constant-syntax">LITERAL_NOTATIONS_DA</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">OBJECT_CREATIONS_DA</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">PHRASE_USAGE_DA</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">SPECIFICITIES_DA</span>
<span class="definition-keyword">enum</span> <span class="constant-syntax">TEXT_SUBSTITUTIONS_DA</span>
@ -77,6 +78,7 @@ which use this module:
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">ValuesModule::start</span><span class="plain-syntax">(</span><span class="reserved-syntax">void</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Tables::Relations::start</span><span class="plain-syntax">();</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Writers::register_writer</span><span class="plain-syntax">(</span><span class="character-syntax">'I'</span><span class="plain-syntax">, &amp;</span><span class="identifier-syntax">Instances::writer</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">LITERAL_NOTATIONS_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"literal notations"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">OBJECT_CREATIONS_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"object creations"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">PHRASE_USAGE_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"phrase usage"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Log::declare_aspect</span><span class="plain-syntax">(</span><span class="constant-syntax">SPECIFICITIES_DA</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"specificities"</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">);</span>

385
docs/values-module/3-lp.html
View file

@ -208,8 +208,9 @@ The rightmost element \(e_{n-1}\) is the least significant numerically.
<span class="plain-syntax"> </span><span class="reserved-syntax">struct</span><span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">element_name</span><span class="plain-syntax">; </span><span class="comment-syntax"> if we define a name for the element</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">is_real</span><span class="plain-syntax">; </span><span class="comment-syntax"> store as a real number, not an integer?</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">with_leading_zeros</span><span class="plain-syntax">; </span><span class="comment-syntax"> override default to say yes</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">without_leading_zeros</span><span class="plain-syntax">; </span><span class="comment-syntax"> override default to say no</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">print_with_leading_zeros</span><span class="plain-syntax">; </span><span class="comment-syntax"> print with leading zeros</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">min_digits</span><span class="plain-syntax">; </span><span class="comment-syntax"> when writing this</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">max_digits</span><span class="plain-syntax">; </span><span class="comment-syntax"> when writing this</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">number_base</span><span class="plain-syntax">; </span><span class="comment-syntax"> e.g., 10 for decimal</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">element_optional</span><span class="plain-syntax">; </span><span class="comment-syntax"> can we truncate the LP here?</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">preamble_optional</span><span class="plain-syntax">; </span><span class="comment-syntax"> if so, can we lose the preamble as well?</span>
@ -274,7 +275,7 @@ mass might also support "in kilograms" and "in grams", for instance.
<p class="commentary firstcommentary"><a id="SP8" class="paragraph-anchor"></a><b>&#167;8. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::lpt_new</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::lpt_new</span></span>:<br/><a href="3-lp.html#SP25_7">&#167;25.7</a>, <a href="3-lp.html#SP25_7_1">&#167;25.7.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">nw</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::lpt_new</span><button class="popup" onclick="togglePopup('usagePopup2')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup2">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::lpt_new</span></span>:<br/><a href="3-lp.html#SP25_7_2_1">&#167;25.7.2.1</a>, <a href="3-lp.html#SP25_7_2_2">&#167;25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">&#167;25.7.2.2.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">t</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">nw</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">lpt</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpt</span><span class="plain-syntax">.</span><span class="element-syntax">new_word_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">nw</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpt</span><span class="plain-syntax">.</span><span class="element-syntax">lpt_type</span><span class="plain-syntax"> = </span><span class="identifier-syntax">t</span><span class="plain-syntax">;</span>
@ -286,7 +287,9 @@ mass might also support "in kilograms" and "in grams", for instance.
<p class="commentary firstcommentary"><a id="SP9" class="paragraph-anchor"></a><b>&#167;9. </b></p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::lpe_new</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::lpe_new</span></span>:<br/><a href="3-lp.html#SP25_7_1">&#167;25.7.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">r</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">sgn</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> *</span><span class="identifier-syntax">parsing_new_element</span><span class="plain-syntax"> = </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::lpe_new</span><button class="popup" onclick="togglePopup('usagePopup3')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup3">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::lpe_new</span></span>:<br/><a href="3-lp.html#SP25_7_2_1_1">&#167;25.7.2.1.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">r</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">sgn</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> </span><span class="identifier-syntax">lpe</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">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">element_range</span><span class="plain-syntax"> = -1; </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">element_range</span><span class="plain-syntax"> = </span><span class="identifier-syntax">r</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">element_multiplier</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
@ -295,8 +298,9 @@ mass might also support "in kilograms" and "in grams", for instance.
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">preamble_optional</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">element_optional</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">number_base</span><span class="plain-syntax"> = </span><span class="constant-syntax">10</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">with_leading_zeros</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">without_leading_zeros</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">print_with_leading_zeros</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">min_digits</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">lpe</span><span class="plain-syntax">.</span><span class="element-syntax">max_digits</span><span class="plain-syntax"> = </span><span class="constant-syntax">1000000</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">lpe</span><span class="plain-syntax">;</span>
<span class="plain-syntax">}</span>
</pre>
@ -639,18 +643,20 @@ on unusual platforms.
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">digits_found</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> = -1;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">max_16_bit</span><span class="plain-syntax"> = </span><span class="constant-syntax">32767</span><span class="identifier-syntax">LL</span><span class="plain-syntax">; </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">sign_used_at</span><span class="plain-syntax">) </span><span class="identifier-syntax">max_16_bit</span><span class="plain-syntax"> = </span><span class="constant-syntax">32768</span><span class="identifier-syntax">LL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">max_32_bit</span><span class="plain-syntax"> = </span><span class="constant-syntax">2147483647</span><span class="identifier-syntax">LL</span><span class="plain-syntax">; </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">sign_used_at</span><span class="plain-syntax">) </span><span class="identifier-syntax">max_32_bit</span><span class="plain-syntax"> = </span><span class="constant-syntax">2147483648</span><span class="identifier-syntax">LL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">], </span><span class="identifier-syntax">lpe</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">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">] == </span><span class="character-syntax">'.'</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::Scalings::get_integer_multiplier</span><span class="plain-syntax">(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">scaling</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> == -1))) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">digits_found</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> ((</span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">], </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">] == </span><span class="character-syntax">'.'</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">Kinds::Scalings::get_integer_multiplier</span><span class="plain-syntax">(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">scaling</span><span class="plain-syntax">) &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> == -1)))) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">] == </span><span class="character-syntax">'.'</span><span class="plain-syntax">) { </span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">digits_found</span><span class="plain-syntax">; </span><span class="identifier-syntax">wpos</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</span><span class="plain-syntax">; }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">tot</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">*</span><span class="identifier-syntax">tot</span><span class="plain-syntax"> + </span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">++], </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">tot</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">*</span><span class="identifier-syntax">tot</span><span class="plain-syntax"> + </span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">wd</span><span class="plain-syntax">[</span><span class="identifier-syntax">wpos</span><span class="plain-syntax">++], </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">tot</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">max_16_bit</span><span class="plain-syntax">) </span><span class="identifier-syntax">overflow_16_bit_flag</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">tot</span><span class="plain-syntax"> &gt; </span><span class="identifier-syntax">max_32_bit</span><span class="plain-syntax">) </span><span class="identifier-syntax">overflow_32_bit_flag</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">digits_found</span><span class="plain-syntax">++;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> == </span><span class="identifier-syntax">digits_found</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">digits_found</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">digits_found</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">point_at</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">digits_found</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">matched_scaledown</span><span class="plain-syntax"> *= </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">; </span><span class="identifier-syntax">point_at</span><span class="plain-syntax">++;</span>
<span class="plain-syntax"> }</span>
@ -830,7 +836,7 @@ which is annoying. So we have a mechanism to suppress duplicates:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::digit_value</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::digit_value</span></span>:<br/><a href="3-lp.html#SP16_1_3_1">&#167;16.1.3.1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> *</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">) {</span>
<span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::digit_value</span><button class="popup" onclick="togglePopup('usagePopup10')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup10">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::digit_value</span></span>:<br/><a href="3-lp.html#SP16_1_3_1">&#167;16.1.3.1</a>, <a href="3-lp.html#SP25_7_2_2">&#167;25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">&#167;25.7.2.2.1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">base</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">r</span><span class="plain-syntax"> = -1;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = ((</span><span class="reserved-syntax">int</span><span class="plain-syntax">) </span><span class="identifier-syntax">c</span><span class="plain-syntax"> - (</span><span class="reserved-syntax">int</span><span class="plain-syntax">) </span><span class="character-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">d</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">10</span><span class="plain-syntax">)) </span><span class="identifier-syntax">r</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">;</span>
@ -842,7 +848,7 @@ which is annoying. So we have a mechanism to suppress duplicates:
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">26</span><span class="plain-syntax">)) </span><span class="identifier-syntax">r</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax"> + </span><span class="constant-syntax">10</span><span class="plain-syntax">; </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> -1;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">r</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">r</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">r</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">r</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">r</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">base</span><span class="plain-syntax">)) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">r</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> -1;</span>
<span class="plain-syntax">}</span>
</pre>
@ -1092,14 +1098,9 @@ note that the following uses the raw text of the word.
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">remainder</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Kinds::Scalings::value_to_quanta</span><span class="plain-syntax">(</span><span class="identifier-syntax">v</span><span class="plain-syntax">, </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">scaling</span><span class="plain-syntax">, &amp;</span><span class="identifier-syntax">v</span><span class="plain-syntax">, &amp;</span><span class="identifier-syntax">remainder</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> *</span><span class="identifier-syntax">lpe</span><span class="plain-syntax"> = &amp;(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</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">ec</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"%d"</span><span class="plain-syntax">, </span><span class="identifier-syntax">v</span><span class="plain-syntax">/(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_multiplier</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">char</span><span class="plain-syntax"> *</span><span class="identifier-syntax">prototype</span><span class="plain-syntax"> = </span><span class="string-syntax">"%d"</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">with_leading_zeros</span><span class="plain-syntax">) ||</span>
<span class="plain-syntax"> ((</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_tokens</span><span class="plain-syntax">[</span><span class="identifier-syntax">tc</span><span class="plain-syntax">].</span><span class="element-syntax">new_word_at</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">without_leading_zeros</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">)))</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">prototype</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP24" class="function-link"><span class="function-syntax">LiteralPatterns::leading_zero_prototype</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="identifier-syntax">prototype</span><span class="plain-syntax">, (</span><span class="identifier-syntax">v</span><span class="plain-syntax">/(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_multiplier</span><span class="plain-syntax">)) % (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax">));</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">m</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><a href="3-lp.html#SP24" class="function-link"><span class="function-syntax">LiteralPatterns::write_val</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">m</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">v</span><span class="plain-syntax">/(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_multiplier</span><span class="plain-syntax">)) % </span><span class="identifier-syntax">m</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">print_with_leading_zeros</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">ec</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP23_3_1" class="named-paragraph-link"><span class="named-paragraph">Index the fractional part of the value</span><span class="named-paragraph-number">23.3.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">ec</span><span class="plain-syntax">++;</span>
@ -1117,25 +1118,31 @@ note that the following uses the raw text of the word.
<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">remainder</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">WRITE</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">WRITE</span><span class="plain-syntax">(</span><a href="3-lp.html#SP24" class="function-link"><span class="function-syntax">LiteralPatterns::leading_zero_prototype</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ranger</span><span class="plain-syntax">), </span><span class="identifier-syntax">remainder</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><a href="3-lp.html#SP24" class="function-link"><span class="function-syntax">LiteralPatterns::write_val</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</span><span class="plain-syntax">, </span><span class="identifier-syntax">ranger</span><span class="plain-syntax">, </span><span class="identifier-syntax">remainder</span><span class="plain-syntax">, </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">, </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP23_3">&#167;23.3</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24. </b>Please don't mention the words "logarithm" or "shift". It works fine.
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>&#167;24. </b>Please don't ask pointed questions about the running time here. It works fine.
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">char</span><span class="plain-syntax"> *</span><span class="function-syntax">LiteralPatterns::leading_zero_prototype</span><button class="popup" onclick="togglePopup('usagePopup15')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup15">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::leading_zero_prototype</span></span>:<br/><a href="3-lp.html#SP23_3">&#167;23.3</a>, <a href="3-lp.html#SP23_3_1">&#167;23.3.1</a></span></button><span class="plain-syntax">(</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">range</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1000000000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%010d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">100000000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%09d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">10000000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%08d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1000000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%07d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">100000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%06d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">10000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%05d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1000</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%04d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">100</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%03d"</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">range</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">10</span><span class="plain-syntax">) </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%02d"</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="string-syntax">"%d"</span><span class="plain-syntax">;</span>
<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">LiteralPatterns::write_val</span><button class="popup" onclick="togglePopup('usagePopup15')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup15">Usage of <span class="code-font"><span class="function-syntax">LiteralPatterns::write_val</span></span>:<br/><a href="3-lp.html#SP23_3">&#167;23.3</a>, <a href="3-lp.html#SP23_3_1">&#167;23.3.1</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">OUTPUT_STREAM</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">range</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">val</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">base</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">lz</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">val</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"negative val"</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">base</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">2</span><span class="plain-syntax">) </span><span class="identifier-syntax">internal_error</span><span class="plain-syntax">(</span><span class="string-syntax">"impossible number base"</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">d</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">vc</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">val</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">vc</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">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">val</span><span class="plain-syntax">) </span><span class="identifier-syntax">vc</span><span class="plain-syntax">++, </span><span class="identifier-syntax">d</span><span class="plain-syntax"> *= </span><span class="identifier-syntax">base</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">lz</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">range</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="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">range</span><span class="plain-syntax">) </span><span class="identifier-syntax">c</span><span class="plain-syntax">++, </span><span class="identifier-syntax">d</span><span class="plain-syntax"> *= </span><span class="identifier-syntax">base</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=</span><span class="identifier-syntax">vc</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">c</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"0"</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=</span><span class="identifier-syntax">vc</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&gt;=1; </span><span class="identifier-syntax">i</span><span class="plain-syntax">--) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">=1; </span><span class="identifier-syntax">j</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">i</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) </span><span class="identifier-syntax">d</span><span class="plain-syntax"> = </span><span class="identifier-syntax">d</span><span class="plain-syntax">*</span><span class="identifier-syntax">base</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">dval</span><span class="plain-syntax"> = (</span><span class="identifier-syntax">val</span><span class="plain-syntax">/</span><span class="identifier-syntax">d</span><span class="plain-syntax">)%</span><span class="identifier-syntax">base</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">dval</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">10</span><span class="plain-syntax">) </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"%d"</span><span class="plain-syntax">, </span><span class="identifier-syntax">dval</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">WRITE</span><span class="plain-syntax">(</span><span class="string-syntax">"%c"</span><span class="plain-syntax">, </span><span class="character-syntax">'A'</span><span class="plain-syntax"> + </span><span class="identifier-syntax">dval</span><span class="plain-syntax"> - </span><span class="constant-syntax">10</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax">}</span>
</pre>
<p class="commentary firstcommentary"><a id="SP25" class="paragraph-anchor"></a><b>&#167;25. </b>The grammars for the specify sentence are quite complicated, but aren't used
@ -1175,6 +1182,8 @@ set.
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_9" class="named-paragraph-link"><span class="named-paragraph">Calculate the multipliers for packing the elements into a single integer</span><span class="named-paragraph-number">25.9</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Log::aspect_switched_on</span><span class="plain-syntax">(</span><span class="constant-syntax">LITERAL_NOTATIONS_DA</span><span class="plain-syntax">)) </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_12" class="named-paragraph-link"><span class="named-paragraph">Log this literal pattern in full</span><span class="named-paragraph-number">25.12</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">owner</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) </span><span class="identifier-syntax">owner</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lp</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_1" class="named-paragraph-link"><span class="named-paragraph">Add this new alternative to the list belonging to our owner</span><span class="named-paragraph-number">25.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">owner</span><span class="plain-syntax">;</span>
@ -1337,20 +1346,9 @@ alphabetic vs numeric pieces of a word:
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">tc</span><span class="plain-syntax">, </span><span class="identifier-syntax">ec</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=0, </span><span class="identifier-syntax">tc</span><span class="plain-syntax">=0, </span><span class="identifier-syntax">ec</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="function-syntax">&lt;Wordings::length(lps-&gt;</span><span class="identifier-syntax">notation_wording</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</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">digit_found</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> *</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">notation_wording</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">]; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">])) </span><span class="identifier-syntax">digit_found</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">digit_found</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_1" class="named-paragraph-link"><span class="named-paragraph">Break up the word into at least one element token, and perhaps also character tokens</span><span class="named-paragraph-number">25.7.1</span></a></span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">WORD_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax">.</span><span class="element-syntax">token_wn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">notation_wording</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tc</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">ec</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">angle_escaped_parts_exist</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">NW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">notation_wording</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2" class="named-paragraph-link"><span class="named-paragraph">Subdivide the wording around angle-bracket escapes</span><span class="named-paragraph-number">25.7.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">no_lp_tokens</span><span class="plain-syntax"> = </span><span class="identifier-syntax">tc</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax"> = </span><span class="identifier-syntax">ec</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">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
@ -1360,24 +1358,174 @@ alphabetic vs numeric pieces of a word:
<span class="plain-syntax"> </span><span class="string-syntax">"specifies a weight'."</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">owner</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">part_np_list</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">angle_escaped_parts_exist</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"since the specification involves parts named in angle brackets "</span>
<span class="plain-syntax"> </span><span class="string-syntax">"it must go on to give details such as 'with parts...'"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"and it appears that it doesn't."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">return</span><span class="plain-syntax"> </span><span class="identifier-syntax">owner</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25">&#167;25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_1" class="paragraph-anchor"></a><b>&#167;25.7.1. </b>Bounds checking is easier here since we know that a LP specification will
<p class="commentary firstcommentary"><a id="SP25_7_1" class="paragraph-anchor"></a><b>&#167;25.7.1. </b>We will use this throwaway little structure to hold inclusive endpoints for
ranges we are scanning: <span class="extract"><span class="extract-syntax">(143, 2)</span></span> means "character 2 (counting from 0) in
word number 143".
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="reserved-syntax">typedef</span><span class="plain-syntax"> </span><span class="reserved-syntax">struct</span><span class="plain-syntax"> </span><span class="reserved-syntax">lpe_notation_pos</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">wn</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">char_pos</span><span class="plain-syntax">;</span>
<span class="plain-syntax">} </span><span class="reserved-syntax">lpe_notation_pos</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>The structure lpe_notation_pos is private to this section.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2" class="paragraph-anchor"></a><b>&#167;25.7.2. </b>This enables us to express how we want to divide up text such as
<span class="extract"><span class="extract-syntax">#&lt;red level&gt;_&lt;green level&gt;_&lt;blue level&gt;</span></span>, which may have word breaks in the
middle of either angle-escapes or the material in between.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Subdivide the wording around angle-bracket escapes</span><span class="named-paragraph-number">25.7.2</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">lpe_notation_pos</span><span class="plain-syntax"> </span><span class="identifier-syntax">from</span><span class="plain-syntax"> = { </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">), </span><span class="constant-syntax">0</span><span class="plain-syntax"> };</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">Wordings::length</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> *</span><span class="identifier-syntax">text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">]; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++)</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="character-syntax">'\"'</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> = </span><span class="identifier-syntax">quoted</span><span class="plain-syntax">?</span><span class="identifier-syntax">FALSE:TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="character-syntax">'&lt;'</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">j</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</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="reserved-syntax">lpe_notation_pos</span><span class="plain-syntax"> </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = { </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">-1,</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Wide::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">-1)) - </span><span class="constant-syntax">1</span><span class="plain-syntax"> };</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_2" class="named-paragraph-link"><span class="named-paragraph">Compile unescaped notation between from and to</span><span class="named-paragraph-number">25.7.2.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">lpe_notation_pos</span><span class="plain-syntax"> </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = { </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">, </span><span class="identifier-syntax">j</span><span class="plain-syntax">-1 };</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_2" class="named-paragraph-link"><span class="named-paragraph">Compile unescaped notation between from and to</span><span class="named-paragraph-number">25.7.2.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</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">next_token_begins_word</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">j</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">k</span><span class="plain-syntax"> = </span><span class="identifier-syntax">j</span><span class="plain-syntax">+1, </span><span class="identifier-syntax">found</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">found_open</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">for</span><span class="plain-syntax"> (; ((</span><span class="identifier-syntax">found</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">Wordings::length</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">))); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++, </span><span class="identifier-syntax">k</span><span class="plain-syntax">=0) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (; </span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">k</span><span class="plain-syntax">]; </span><span class="identifier-syntax">k</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">k</span><span class="plain-syntax">] == </span><span class="character-syntax">'\"'</span><span class="plain-syntax">) </span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> = </span><span class="identifier-syntax">quoted</span><span class="plain-syntax">?</span><span class="identifier-syntax">FALSE:TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">k</span><span class="plain-syntax">] == </span><span class="character-syntax">'&gt;'</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">found</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="identifier-syntax">k</span><span class="plain-syntax">++;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">quoted</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">k</span><span class="plain-syntax">] == </span><span class="character-syntax">'&lt;'</span><span class="plain-syntax">)) </span><span class="identifier-syntax">found_open</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">PUT_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</span><span class="plain-syntax">, </span><span class="identifier-syntax">text</span><span class="plain-syntax">[</span><span class="identifier-syntax">k</span><span class="plain-syntax">]);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">found</span><span class="plain-syntax">) </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">quoted</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">i</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">Wordings::length</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)) </span><span class="identifier-syntax">PUT_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</span><span class="plain-syntax">, </span><span class="character-syntax">' '</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">found</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">found_open</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"'&lt;' without '&gt;' in a literal specification"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"which must mean that the angle brackets do not match."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">wn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">char_pos</span><span class="plain-syntax"> = </span><span class="identifier-syntax">k</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1" class="named-paragraph-link"><span class="named-paragraph">Act on angle-bracketed escape</span><span class="named-paragraph-number">25.7.2.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">DISCARD_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax"> = </span><span class="identifier-syntax">k</span><span class="plain-syntax"> - </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">lpe_notation_pos</span><span class="plain-syntax"> </span><span class="identifier-syntax">to</span><span class="plain-syntax"> = { </span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">Wide::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::last_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">))) - </span><span class="constant-syntax">1</span><span class="plain-syntax"> };</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_2" class="named-paragraph-link"><span class="named-paragraph">Compile unescaped notation between from and to</span><span class="named-paragraph-number">25.7.2.2</span></a></span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7">&#167;25.7</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2_1" class="paragraph-anchor"></a><b>&#167;25.7.2.1. </b>Angle-escapes are easy, and must consist of either double-quoted literal
material or else names for parts about which nothing else is said.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Act on angle-bracketed escape</span><span class="named-paragraph-number">25.7.2.1</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="identifier-syntax">Str::trim_white_space</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">AW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Feeds::feed_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">angles</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="function-syntax">&lt;quoted-text&gt;</span><span class="plain-syntax">(</span><span class="identifier-syntax">AW</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> *</span><span class="identifier-syntax">literal_text</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">AW</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">x</span><span class="plain-syntax">=1; </span><span class="identifier-syntax">x</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">Wide::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">literal_text</span><span class="plain-syntax">) - </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="identifier-syntax">x</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> =</span>
<span class="plain-syntax"> </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CHARACTER_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax">.</span><span class="element-syntax">token_char</span><span class="plain-syntax"> = </span><span class="identifier-syntax">literal_text</span><span class="plain-syntax">[</span><span class="identifier-syntax">x</span><span class="plain-syntax">];</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</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">tot</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="identifier-syntax">sgn</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_1" class="named-paragraph-link"><span class="named-paragraph">Make a new element</span><span class="named-paragraph-number">25.7.2.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">parsing_new_element</span><span class="plain-syntax"> = &amp;(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</span><span class="plain-syntax">-1]);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">parsing_new_element</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax"> = </span><span class="identifier-syntax">AW</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> =</span>
<span class="plain-syntax"> </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">ELEMENT_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">angle_escaped_parts_exist</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7_2">&#167;25.7.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2_2" class="paragraph-anchor"></a><b>&#167;25.7.2.2. </b>Now we are looking for digits. <span class="extract"><span class="extract-syntax">x45yyz</span></span> would be split into the character
literal <span class="extract"><span class="extract-syntax">x</span></span>, then a numerical element with range <span class="extract"><span class="extract-syntax">45</span></span> in the current number base,
then three more character literals. If there are no digits, and we have an entire
word to play with, we optimise by making a word token instead of a run of
character ones.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Compile unescaped notation between from and to</span><span class="named-paragraph-number">25.7.2.2</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">wn</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">to</span><span class="plain-syntax">.</span><span class="element-syntax">wn</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">char_pos</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">to</span><span class="plain-syntax">.</span><span class="element-syntax">char_pos</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wording</span><span class="plain-syntax"> </span><span class="identifier-syntax">NW</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::new</span><span class="plain-syntax">(</span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">wn</span><span class="plain-syntax">, </span><span class="identifier-syntax">to</span><span class="plain-syntax">.</span><span class="element-syntax">wn</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">Wordings::length</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> *</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Lexer::word_raw_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">start_from</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">finish_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wide::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">)-1;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">start_from</span><span class="plain-syntax"> = </span><span class="identifier-syntax">from</span><span class="plain-syntax">.</span><span class="element-syntax">char_pos</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="identifier-syntax">Wordings::length</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)-1) </span><span class="identifier-syntax">finish_at</span><span class="plain-syntax"> = </span><span class="identifier-syntax">to</span><span class="plain-syntax">.</span><span class="element-syntax">char_pos</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">digit_found</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">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">=</span><span class="identifier-syntax">start_from</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">&lt;=</span><span class="identifier-syntax">finish_at</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++)</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">], </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">digit_found</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">digit_found</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">start_from</span><span class="plain-syntax"> != </span><span class="constant-syntax">0</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">finish_at</span><span class="plain-syntax"> != </span><span class="identifier-syntax">Wide::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">)-1))</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_2_1" class="named-paragraph-link"><span class="named-paragraph">Break up the word into at least one element token, and perhaps also character tokens</span><span class="named-paragraph-number">25.7.2.2.1</span></a></span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">WORD_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax">.</span><span class="element-syntax">token_wn</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Wordings::first_wn</span><span class="plain-syntax">(</span><span class="identifier-syntax">NW</span><span class="plain-syntax">)+</span><span class="identifier-syntax">i</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7_2">&#167;25.7.2</a> (three times).</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2_2_1" class="paragraph-anchor"></a><b>&#167;25.7.2.2.1. </b>Bounds checking is easier here since we know that a LP specification will
not ever need to create the maximum conceivable value which a C integer can
hold &mdash; so we need not fool around with long long ints.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Break up the word into at least one element token, and perhaps also character tokens</span><span class="named-paragraph-number">25.7.1</span></span><span class="comment-syntax"> =</span>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Break up the word into at least one element token, and perhaps also character tokens</span><span class="named-paragraph-number">25.7.2.2.1</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">, </span><span class="identifier-syntax">sgn</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">j</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">]; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">sgn</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">, </span><span class="identifier-syntax">base</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">start_from</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">next_token_begins_word</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">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">=</span><span class="identifier-syntax">start_from</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">&lt;=</span><span class="identifier-syntax">finish_at</span><span class="plain-syntax">; </span><span class="identifier-syntax">j</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">tot</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">digit_found</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">, </span><span class="identifier-syntax">point_found</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">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="character-syntax">'-'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">+1])) &amp;&amp; (</span><span class="identifier-syntax">ec</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">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="character-syntax">'-'</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">+1], </span><span class="identifier-syntax">base</span><span class="plain-syntax">) &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) &amp;&amp;</span>
<span class="plain-syntax"> (</span><span class="identifier-syntax">ec</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">sgn</span><span class="plain-syntax"> = -1; </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">while</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">++])) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">while</span><span class="plain-syntax"> (</span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">++], </span><span class="identifier-syntax">base</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">digit_found</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">tot</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">999999999</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_LPElementTooLarge</span><span class="plain-syntax">),</span>
@ -1386,44 +1534,53 @@ hold &mdash; so we need not fool around with long long ints.
<span class="plain-syntax"> </span><span class="string-syntax">"be stored at run-time."</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">owner</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">tot</span><span class="plain-syntax"> = </span><span class="constant-syntax">10</span><span class="plain-syntax">*</span><span class="identifier-syntax">tot</span><span class="plain-syntax"> + (</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">-1]-</span><span class="character-syntax">'0'</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">tot</span><span class="plain-syntax"> = </span><span class="identifier-syntax">base</span><span class="plain-syntax">*</span><span class="identifier-syntax">tot</span><span class="plain-syntax"> + </span><a href="3-lp.html#SP17" class="function-link"><span class="function-syntax">LiteralPatterns::digit_value</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">-1], </span><span class="identifier-syntax">base</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">--;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">] == </span><span class="character-syntax">'.'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">+1] == </span><span class="character-syntax">'0'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">ec</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">j</span><span class="plain-syntax"> += </span><span class="constant-syntax">2</span><span class="plain-syntax">; </span><span class="identifier-syntax">point_found</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">digit_found</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_element</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP9" class="function-link"><span class="function-syntax">LiteralPatterns::lpe_new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ec</span><span class="plain-syntax">, </span><span class="identifier-syntax">tot</span><span class="plain-syntax">+1, </span><span class="identifier-syntax">sgn</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">ec</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">MAX_ELEMENTS_PER_LITERAL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_LPTooManyElements</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"that specification contains too many numerical elements"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"and is too complicated for Inform to handle."</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">owner</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_element</span><span class="plain-syntax">.</span><span class="element-syntax">is_real</span><span class="plain-syntax"> = </span><span class="identifier-syntax">point_found</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_1" class="named-paragraph-link"><span class="named-paragraph">Make a new element</span><span class="named-paragraph-number">25.7.2.1.1</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</span><span class="plain-syntax">-1].</span><span class="element-syntax">is_real</span><span class="plain-syntax"> = </span><span class="identifier-syntax">point_found</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">point_found</span><span class="plain-syntax">) </span><span class="identifier-syntax">integer_scaling</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</span><span class="plain-syntax">++] = </span><span class="identifier-syntax">new_element</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">sgn</span><span class="plain-syntax"> == -1) </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_signed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">ELEMENT_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">ELEMENT_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">j</span><span class="plain-syntax">--;</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CHARACTER_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP8" class="function-link"><span class="function-syntax">LiteralPatterns::lpt_new</span></a><span class="plain-syntax">(</span><span class="constant-syntax">CHARACTER_LPT</span><span class="plain-syntax">, </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">new_token</span><span class="plain-syntax">.</span><span class="element-syntax">token_char</span><span class="plain-syntax"> = </span><span class="identifier-syntax">text_of_word</span><span class="plain-syntax">[</span><span class="identifier-syntax">j</span><span class="plain-syntax">];</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="named-paragraph-container code-font"><a href="3-lp.html#SP25_7_2_1_2" class="named-paragraph-link"><span class="named-paragraph">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></a></span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">sgn</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">; </span><span class="identifier-syntax">next_token_begins_word</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7">&#167;25.7</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2" class="paragraph-anchor"></a><b>&#167;25.7.2. </b>In fact counting tokens is not necessarily a good way to measure the
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7_2_2">&#167;25.7.2.2</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2_1_1" class="paragraph-anchor"></a><b>&#167;25.7.2.1.1. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Make a new element</span><span class="named-paragraph-number">25.7.2.1.1</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> </span><span class="identifier-syntax">new_element</span><span class="plain-syntax"> = </span><a href="3-lp.html#SP9" class="function-link"><span class="function-syntax">LiteralPatterns::lpe_new</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">ec</span><span class="plain-syntax">, </span><span class="identifier-syntax">tot</span><span class="plain-syntax">+1, </span><span class="identifier-syntax">sgn</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">next_token_begins_word</span><span class="plain-syntax"> == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">ec</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">new_element</span><span class="plain-syntax">.</span><span class="element-syntax">print_with_leading_zeros</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">ec</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">MAX_ELEMENTS_PER_LITERAL</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_LPTooManyElements</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"that specification contains too many numerical elements"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"and is too complicated for Inform to handle."</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">owner</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</span><span class="plain-syntax">++] = </span><span class="identifier-syntax">new_element</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7_2_1">&#167;25.7.2.1</a>, <a href="3-lp.html#SP25_7_2_2_1">&#167;25.7.2.2.1</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_7_2_1_2" class="paragraph-anchor"></a><b>&#167;25.7.2.1.2. </b>In fact counting tokens is not necessarily a good way to measure the
complexity of an LP, since any long run of characters in a word which
also contains a number will splurge the number of tokens. So
<span class="extract"><span class="extract-syntax">MAX_TOKENS_PER_LITERAL</span></span> is set to a high enough value that this will
not really distort matters.
</p>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Add new token to LP</span><span class="named-paragraph-number">25.7.2</span></span><span class="comment-syntax"> =</span>
<p class="commentary"><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Add new token to LP</span><span class="named-paragraph-number">25.7.2.1.2</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
@ -1435,7 +1592,7 @@ not really distort matters.
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_tokens</span><span class="plain-syntax">[</span><span class="identifier-syntax">tc</span><span class="plain-syntax">++] = </span><span class="identifier-syntax">new_token</span><span class="plain-syntax">;</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7">&#167;25.7</a>, <a href="3-lp.html#SP25_7_1">&#167;25.7.1</a> (twice).</li></ul>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25_7_2_1">&#167;25.7.2.1</a> (twice), <a href="3-lp.html#SP25_7_2_2">&#167;25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">&#167;25.7.2.2.1</a> (twice).</li></ul>
<p class="commentary firstcommentary"><a id="SP25_8" class="paragraph-anchor"></a><b>&#167;25.8. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Adopt real arithmetic if this is called for</span><span class="named-paragraph-number">25.8</span></span><span class="comment-syntax"> =</span>
</p>
@ -1473,18 +1630,57 @@ this is deferred until all elements exist, at which point we &mdash;
<span class="plain-syntax"> </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">i</span><span class="plain-syntax">=0, </span><span class="identifier-syntax">p</span><span class="plain-syntax">=</span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">part_np_list</span><span class="plain-syntax">; (</span><span class="identifier-syntax">i</span><span class="function-syntax">&lt;lp-&gt;</span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">p</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++, </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> *</span><span class="identifier-syntax">lpe</span><span class="plain-syntax"> = &amp;(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">size_needed</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">Wordings::empty</span><span class="plain-syntax">(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">element_name</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::match</span><span class="plain-syntax">(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">)) == </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Want %W have %W\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the part names after 'with' do not exactly match those named "</span>
<span class="plain-syntax"> </span><span class="string-syntax">"in the specification itself"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"as they must."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">size_needed</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">O</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe_options_ANNOT</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">OPTIONAL_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_optional</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">PREAMBLE_OPTIONAL_LSO</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_optional</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">; </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">preamble_optional</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">with_leading_zeros</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">WITHOUT_LEADING_ZEROS_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">without_leading_zeros</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">WITH_LEADING_ZEROS_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">print_with_leading_zeros</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">WITHOUT_LEADING_ZEROS_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">print_with_leading_zeros</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">BASE_MASK_LSO</span><span class="plain-syntax">) </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">BASE_MASK_LSO</span><span class="plain-syntax">) / </span><span class="identifier-syntax">BASE_LSO</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAXIMUM_LSO</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MIN_DIGITS_MASK_LSO</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MIN_DIGITS_MASK_LSO</span><span class="plain-syntax">) / </span><span class="identifier-syntax">MIN_DIGITS_LSO</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax">) / </span><span class="identifier-syntax">MAX_DIGITS_LSO</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAXIMUM_LSO</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe_max_ANNOT</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">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</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">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=1; </span><span class="identifier-syntax">i</span><span class="function-syntax">&lt;=lpe-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">/</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</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">n</span><span class="plain-syntax"> != </span><span class="constant-syntax">0</span><span class="plain-syntax">)</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"the maximum value here is greater than would fit in the number of digits"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"so that it could not be written down."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> } </span><span class="reserved-syntax">else</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; </span><span class="identifier-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="constant-syntax">1</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=1; </span><span class="identifier-syntax">i</span><span class="function-syntax">&lt;=lpe-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) </span><span class="identifier-syntax">n</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">*</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax"> = </span><span class="identifier-syntax">n</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">size_needed</span><span class="plain-syntax">) &amp;&amp; ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> &amp; (</span><span class="identifier-syntax">MAX_DIGITS_MASK_LSO</span><span class="plain-syntax"> + </span><span class="identifier-syntax">MAXIMUM_LSO</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax"> = -1;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(...),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"this has a part with no indication of its possible range"</span><span class="plain-syntax">,</span>
<span class="plain-syntax"> </span><span class="string-syntax">"that is, by saying '0 to N' or 'N digits'."</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">i</span><span class="plain-syntax"> == </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax"> - </span><span class="constant-syntax">1</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">)) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">StandardProblems::sentence_problem</span><span class="plain-syntax">(</span><span class="identifier-syntax">Task::syntax_tree</span><span class="plain-syntax">(), </span><span class="identifier-syntax">_p_</span><span class="plain-syntax">(</span><span class="identifier-syntax">PM_LPTooManyPartNames</span><span class="plain-syntax">),</span>
<span class="plain-syntax"> </span><span class="string-syntax">"this gives names for too many parts"</span><span class="plain-syntax">,</span>
@ -1532,6 +1728,43 @@ optional, and it must not be the first.
<span class="plain-syntax"> }</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25">&#167;25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP25_12" class="paragraph-anchor"></a><b>&#167;25.12. </b><span class="named-paragraph-container code-font"><span class="named-paragraph-defn">Log this literal pattern in full</span><span class="named-paragraph-number">25.12</span></span><span class="comment-syntax"> =</span>
</p>
<pre class="displayed-code all-displayed-code code-font">
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Notation for kind %u\nSpecification: %W\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">K</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lps</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">part_np_list</span><span class="plain-syntax">; </span><span class="identifier-syntax">p</span><span class="plain-syntax">; </span><span class="identifier-syntax">p</span><span class="plain-syntax"> = </span><span class="identifier-syntax">p</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">next</span><span class="plain-syntax">) {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"part: %W (%08x)\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">Node::get_text</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">), </span><span class="identifier-syntax">Annotations::read_int</span><span class="plain-syntax">(</span><span class="identifier-syntax">p</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe_options_ANNOT</span><span class="plain-syntax">));</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0, </span><span class="identifier-syntax">ec</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="function-syntax">&lt;lp-&gt;</span><span class="element-syntax">no_lp_tokens</span><span class="plain-syntax">; </span><span class="identifier-syntax">i</span><span class="plain-syntax">++) {</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_token</span><span class="plain-syntax"> *</span><span class="identifier-syntax">lpt</span><span class="plain-syntax"> = &amp;(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_tokens</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">]);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"Token %d "</span><span class="plain-syntax">, </span><span class="identifier-syntax">i</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">lpt</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">new_word_at</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"(starts word) "</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">switch</span><span class="plain-syntax"> (</span><span class="identifier-syntax">lpt</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lpt_type</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">WORD_LPT:</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"word %+W\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">Wordings::one_word</span><span class="plain-syntax">(</span><span class="identifier-syntax">lpt</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">token_wn</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">CHARACTER_LPT:</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"char %c\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpt</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">token_char</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">ELEMENT_LPT:</span><span class="plain-syntax"> {</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"element "</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">literal_pattern_element</span><span class="plain-syntax"> *</span><span class="identifier-syntax">lpe</span><span class="plain-syntax"> = &amp;(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">lp_elements</span><span class="plain-syntax">[</span><span class="identifier-syntax">ec</span><span class="plain-syntax">]);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"(%d) "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_index</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Wordings::empty</span><span class="plain-syntax">(</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_name</span><span class="plain-syntax">)) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"(nameless) "</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"%W "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_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">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax"> == </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"%d digit(s) "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">1</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">max_digits</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">1000000</span><span class="plain-syntax">))</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"%d to %d digits "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">min_digits</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">max_digits</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">print_with_leading_zeros</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"printed with leading zeros "</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">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax"> &gt;= </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"range 0 to %d "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_range</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">else</span><span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"range unlimited "</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"(base %d) "</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">number_base</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"- multiplier %d\n"</span><span class="plain-syntax">, </span><span class="identifier-syntax">lpe</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">element_multiplier</span><span class="plain-syntax">);</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">ec</span><span class="plain-syntax">++;</span>
<span class="plain-syntax"> </span><span class="reserved-syntax">break</span><span class="plain-syntax">;</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> }</span>
<span class="plain-syntax"> </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"\n"</span><span class="plain-syntax">);</span>
</pre>
<ul class="endnotetexts"><li>This code is used in <a href="3-lp.html#SP25">&#167;25</a>.</li></ul>
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>&#167;26. </b>Group names are created when first seen; the following recognises one which
has been seen before.
</p>

2
inform7/Downloads/excerpts-diagnostics.txt
View file

@ -1,5 +1,5 @@
Size of lexicon: 3143 excerpt meanings
Stored among 850 words out of total vocabulary of 10766
Stored among 850 words out of total vocabulary of 10769
720 words have a start list: longest belongs to report (with 293 meanings)
15 words have an end list: longest belongs to case (with 6 meanings)
29 words have a middle list: longest belongs to to (with 4 meanings)

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

@ -5740,9 +5740,9 @@
<other-significant-phrase> hits 785/14942 nti 13 constraint DS = {13} extremes [2, infinity)
English:
say {...}
(hits 604/2971) (matched long text) constraint DS = {13} extremes [2, infinity)
(hits 604/2970) (matched long text) constraint DS = {13} extremes [2, infinity)
now {...}
(hits 181/2367) (matched long text) constraint DS = {13} extremes [2, infinity)
(hits 181/2366) (matched long text) constraint DS = {13} extremes [2, infinity)
<phrase-with-comma-notation> hits 2324/7612 nti 14 constraint DS = {14} extremes [3, infinity)
English:
@ -6478,7 +6478,15 @@
constraint CS = {13} extremes [3, 3]
in <number-base>
constraint DS = {11, 13} extremes [2, 3]
maximum <cardinal-number>
<cardinal-number> to <cardinal-number>
constraint DS = {13} extremes [3, 3]
up to <cardinal-number> <number-base> digit/digits
constraint DS = {11, 13} extremes [5, 6]
up to <cardinal-number> digit/digits
constraint DS = {13} extremes [4, 4]
<cardinal-number> <number-base> digit/digits
constraint DS = {11, 13} extremes [3, 4]
<cardinal-number> digit/digits
constraint DS = {13} extremes [2, 2]
{......}
constraint (none) extremes [1, infinity)
@ -8867,23 +8875,23 @@
<spatial-specifying-nouns> hits 288/63652 nti 13 constraint DS = {13} extremes [1, infinity)
English:
_something/anything {***}
(hits 207/17164) (matched long text) constraint DS = {13} extremes [1, infinity)
(hits 207/17156) (matched long text) constraint DS = {13} extremes [1, infinity)
_somewhere/anywhere {***}
(hits 0/16957) constraint DS = {13} extremes [1, infinity)
(hits 0/16949) constraint DS = {13} extremes [1, infinity)
_someone/anyone/somebody/anybody {***}
(hits 57/16957) (matched: 'someone') constraint DS = {13} extremes [1, infinity)
(hits 57/16949) (matched: 'someone') constraint DS = {13} extremes [1, infinity)
_everything {***}
(hits 0/16900) constraint DS = {13} extremes [1, infinity)
(hits 0/16892) constraint DS = {13} extremes [1, infinity)
_everywhere {***}
(hits 0/16900) constraint DS = {13} extremes [1, infinity)
(hits 0/16892) constraint DS = {13} extremes [1, infinity)
_everyone/everybody {***}
(hits 0/16900) constraint DS = {13} extremes [1, infinity)
(hits 0/16892) constraint DS = {13} extremes [1, infinity)
_nowhere {***}
(hits 24/16900) (matched: 'nowhere') constraint DS = {13} extremes [1, infinity)
(hits 24/16892) (matched: 'nowhere') constraint DS = {13} extremes [1, infinity)
_nobody/no-one {***}
(hits 0/16876) constraint DS = {13} extremes [1, infinity)
(hits 0/16868) constraint DS = {13} extremes [1, infinity)
_no _one {***}
(hits 0/16482) constraint DS = {13} extremes [2, infinity)
(hits 0/16474) constraint DS = {13} extremes [2, infinity)
<notable-spatial-noun-phrases> hits 0/2186 nti 14 constraint CS = {14} extremes [1, 1]
English:

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

@ -1,6 +1,6 @@
Total memory consumption was 135940K = 133 MB
---- was used for 2113710 objects, in 374110 frames in 0 x 800K = 0K = 0 MB:
---- was used for 2113736 objects, in 374136 frames in 0 x 800K = 0K = 0 MB:
31.0% inter_tree_node_array 60 x 8192 = 491520 objects, 43255680 bytes
19.4% text_stream_array 4812 x 100 = 481200 objects, 27101184 bytes
@ -16,20 +16,20 @@ Total memory consumption was 135940K = 133 MB
1.9% kind_array 68 x 1000 = 68000 objects, 2722176 bytes
1.5% inter_schema_token 14185 objects, 2156120 bytes
1.4% inter_name_generator_array 51 x 1000 = 51000 objects, 2041632 bytes
1.3% package_request 21314 objects, 1875632 bytes
1.3% package_request 21315 objects, 1875720 bytes
1.3% vocabulary_entry_array 165 x 100 = 16500 objects, 1853280 bytes
1.1% dict_entry_array 483 x 100 = 48300 objects, 1561056 bytes
1.0% inter_symbols_table 26896 objects, 1506176 bytes
1.0% inter_symbols_table 26897 objects, 1506232 bytes
1.0% match_trie_array 11 x 1000 = 11000 objects, 1496352 bytes
1.0% i6_schema_array 24 x 100 = 2400 objects, 1440768 bytes
0.9% inter_package 26896 objects, 1291008 bytes
0.9% inter_package 26897 objects, 1291056 bytes
0.8% map_data 677 objects, 1137360 bytes
0.7% id_body 964 objects, 1102816 bytes
0.7% adjective_meaning 208 objects, 1030016 bytes
0.7% inter_schema_node 9070 objects, 1015840 bytes
0.7% excerpt_meaning 3143 objects, 980616 bytes
0.6% production 3991 objects, 925912 bytes
0.6% ptoken 8668 objects, 901472 bytes
0.6% production 3995 objects, 926840 bytes
0.6% ptoken 8687 objects, 903448 bytes
0.6% grammatical_usage 3649 objects, 875760 bytes
0.6% individual_form 2582 objects, 867552 bytes
0.4% unary_predicate_array 17 x 1000 = 17000 objects, 680544 bytes
@ -251,7 +251,7 @@ Total memory consumption was 135940K = 133 MB
100.0% was used for memory not allocated for objects:
61.3% text stream storage 85445032 bytes in 501036 claims
61.3% text stream storage 85446132 bytes in 501046 claims
3.8% dictionary storage 5377536 bytes in 7751 claims
---- sorting 2616 bytes in 531 claims
5.1% source text 7200000 bytes in 3 claims
@ -259,8 +259,8 @@ Total memory consumption was 135940K = 133 MB
0.1% documentation fragments 262144 bytes in 1 claim
---- linguistic stock array 81920 bytes in 2 claims
---- small word set array 105600 bytes in 22 claims
3.3% inter symbols storage 4701536 bytes in 28273 claims
12.0% inter bytecode storage 16757544 bytes in 15 claims
3.3% inter symbols storage 4701664 bytes in 28274 claims
12.0% inter bytecode storage 16757296 bytes in 15 claims
4.4% inter links storage 6222976 bytes in 11 claims
0.1% inter tree location list storage 191232 bytes in 32 claims
1.2% instance-of-kind counting 1731856 bytes in 1 claim
@ -269,5 +269,5 @@ Total memory consumption was 135940K = 133 MB
---- code generation workspace for objects 3488 bytes in 19 claims
0.2% emitter array storage 281184 bytes in 2006 claims
-139.-6% was overhead - -194380360 bytes = -189824K = -185 MB
-139.-6% was overhead - -194383456 bytes = -189827K = -185 MB

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

@ -1,11 +1,11 @@
100.0% in inform7 run
67.4% in compilation to Inter
45.0% in //Sequence::undertake_queued_tasks//
67.5% in compilation to Inter
46.0% in //Sequence::undertake_queued_tasks//
4.9% in //MajorNodes::pre_pass//
3.7% in //MajorNodes::pass_1//
1.8% in //ImperativeDefinitions::assess_all//
3.3% in //MajorNodes::pass_1//
1.5% in //ImperativeDefinitions::assess_all//
1.5% in //RTKindConstructors::compile//
1.5% in //RTPhrasebook::compile_entries//
1.1% in //RTPhrasebook::compile_entries//
1.1% in //Sequence::lint_inter//
0.7% in //Sequence::undertake_queued_tasks//
0.3% in //CompletionModule::compile//
@ -14,16 +14,16 @@
0.3% in //MajorNodes::pass_2//
0.3% in //Sequence::undertake_queued_tasks//
0.3% in //World::stage_V//
4.6% not specifically accounted for
28.4% in running Inter pipeline
4.9% not specifically accounted for
28.3% in running Inter pipeline
9.8% in step 14/15: generate inform6 -> auto.inf
7.1% in step 5/15: load-binary-kits
6.7% in step 5/15: load-binary-kits
6.0% in step 6/15: make-synoptic-module
1.8% in step 9/15: make-identifiers-unique
0.3% in step 12/15: eliminate-redundant-operations
0.3% in step 4/15: compile-splats
0.3% in step 7/15: shorten-wiring
0.3% in step 8/15: detect-indirect-calls
1.9% not specifically accounted for
3.4% in supervisor
2.3% not specifically accounted for
3.3% in supervisor
0.8% not specifically accounted for

2
inform7/Internal/Inter/Architecture16Kit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "Architecture16Kit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"compatibility": "16-bit",
"kit-details": {

2
inform7/Internal/Inter/Architecture32Kit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "Architecture32Kit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"compatibility": "32-bit",
"kit-details": {

2
inform7/Internal/Inter/BasicInformKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "BasicInformKit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"needs": [ {
"need": {

2
inform7/Internal/Inter/CommandParserKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "CommandParserKit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"needs": [ {
"need": {

2
inform7/Internal/Inter/EnglishLanguageKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "EnglishLanguageKit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"needs": [ {
"need": {

2
inform7/Internal/Inter/WorldModelKit/kit_metadata.json
View file

@ -2,7 +2,7 @@
"is": {
"type": "kit",
"title": "WorldModelKit",
"version": "10.2.0-beta+6W76"
"version": "10.2.0-beta+6W77"
},
"needs": [ {
"need": {

1
inform7/Tests/Test Internals/_Results_Ideal/Index-Innards.txt
View file

@ -51,6 +51,7 @@
<a href="javascript:pasteCode('Include noun resolution in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include noun resolution in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include pronouns in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include pronouns in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include relation definitions in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include relation definitions in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include literal notations in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include literal notations in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include object creations in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include object creations in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include phrase usage in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include phrase usage in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>
<a href="javascript:pasteCode('Include specificities in the debugging log.')"><img border=0 src=inform:/doc_images/paste.png></a>&nbsp;Include specificities in the debugging log.&nbsp;<img border=0 src=inform:/doc_images/cross.png><br>

59
inform7/assertions-module/Chapter 3/New Literal Pattern Requests.w
View file

@ -301,9 +301,48 @@ by a bracketed list of up to three options in any order.
with leading zeros | ==> { WITH_LEADING_ZEROS_LSO, - }
without leading zeros | ==> { WITHOUT_LEADING_ZEROS_LSO, - }
in <number-base> | ==> { BASE_LSO*R[1], - }
maximum <cardinal-number> | ==> { MAXIMUM_LSO, - }; <<max_part_val>> = R[1];
<cardinal-number> to <cardinal-number> | ==> <<max_part_val>> = R[2]; @<Apply range@>;
up to <cardinal-number> <number-base> digit/digits | ==> @<Apply based max digit count@>;
up to <cardinal-number> digit/digits | ==> @<Apply max digit count@>;
<cardinal-number> <number-base> digit/digits | ==> @<Apply based digit count@>;
<cardinal-number> digit/digits | ==> @<Apply digit count@>;
...... ==> @<Issue PM_BadLPPartOption problem@>
@<Apply range@> =
if (R[1] != 0)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the range in a named part has to begin at 0",
"for the moment at least.");
==> { MAXIMUM_LSO, - };
@<Apply max digit count@> =
if (R[1] < 1)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the digit count in a named part has to be at least 1",
"for obvious reasons.");
==> { MAX_DIGITS_LSO*R[1], - }
@<Apply digit count@> =
if (R[1] < 1)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the digit count in a named part has to be at least 1",
"for obvious reasons.");
==> { MAX_DIGITS_LSO*R[1] + MIN_DIGITS_LSO*R[1] + WITH_LEADING_ZEROS_LSO, - };
@<Apply based max digit count@> =
if (R[1] < 1)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the digit count in a named part has to be at least 1",
"for obvious reasons.");
==> { MAX_DIGITS_LSO*R[1] + BASE_LSO*R[2], - }
@<Apply based digit count@> =
if (R[1] < 1)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the digit count in a named part has to be at least 1",
"for obvious reasons.");
==> { MAX_DIGITS_LSO*R[1] + MIN_DIGITS_LSO*R[1] + BASE_LSO*R[2] + WITH_LEADING_ZEROS_LSO, - };
@<Issue PM_BadLPPartOption problem@> =
if (preform_lookahead_mode == FALSE) {
Problems::quote_source(1, current_sentence);
@ -326,13 +365,17 @@ literal_pattern_name *LPRequests::compose(literal_pattern_name *A, literal_patte
@ Nodes used as "parts" of a notation are annotated with a bitmap of these:
@d OPTIONAL_LSO 1
@d PREAMBLE_OPTIONAL_LSO 2
@d WITH_LEADING_ZEROS_LSO 4
@d WITHOUT_LEADING_ZEROS_LSO 8
@d MAXIMUM_LSO 16
@d BASE_LSO 0x10000
@d BASE_MASK_LSO 0xff0000
@d OPTIONAL_LSO 0x00000001
@d PREAMBLE_OPTIONAL_LSO 0x00000002
@d WITH_LEADING_ZEROS_LSO 0x00000004
@d WITHOUT_LEADING_ZEROS_LSO 0x00000008
@d MAXIMUM_LSO 0x00000010
@d BASE_LSO 0x00000100
@d BASE_MASK_LSO 0x0000ff00
@d MIN_DIGITS_LSO 0x00010000
@d MIN_DIGITS_MASK_LSO 0x007f0000
@d MAX_DIGITS_LSO 0x01000000
@d MAX_DIGITS_MASK_LSO 0x7f000000
=
parse_node *LPRequests::mark(parse_node *A, int N, int M) {

78
inform7/runtime-module/Chapter 5/Literal Patterns.w
View file

@ -230,9 +230,7 @@ void RTLiteralPatterns::compilation_agent(compilation_subtask *t) {
ec++;
@<Print leading zeros@> =
if ((lpe->with_leading_zeros) ||
((lp->lp_tokens[tc].new_word_at == FALSE) &&
(lpe->without_leading_zeros == FALSE))) {
if (lpe->print_with_leading_zeros) {
int pow = 1;
while (lpe->element_range > pow) pow = pow * lpe->number_base;
for (; pow>1; pow = pow/lpe->number_base)
@ -1060,29 +1058,47 @@ sets the |parsed_number| global to the value matched.
EmitCode::val_false();
EmitCode::up();
EmitCode::inv(STORE_BIP);
EmitCode::down();
EmitCode::ref_symbol(K_value, gprk.rv_s);
EmitCode::val_number(0);
EmitCode::up();
EmitCode::inv(WHILE_BIP);
EmitCode::down();
EmitCode::inv(AND_BIP);
EmitCode::down();
EmitCode::inv(LT_BIP);
EmitCode::down();
EmitCode::val_symbol(K_value, gprk.wpos_s);
EmitCode::val_symbol(K_value, gprk.cur_len_s);
EmitCode::up();
EmitCode::inv(GE_BIP);
EmitCode::down();
EmitCode::call(Hierarchy::find(DIGITTOVALUE_HL));
if (lpe->max_digits < 1000000) {
EmitCode::inv(LT_BIP);
EmitCode::down();
EmitCode::inv(bufferbip);
EmitCode::down();
EmitCode::val_symbol(K_value, gprk.cur_addr_s);
EmitCode::val_symbol(K_value, gprk.wpos_s);
EmitCode::up();
if (lpe->number_base != 10)
EmitCode::val_number((inter_ti) lpe->number_base);
EmitCode::val_symbol(K_value, gprk.rv_s);
EmitCode::val_number((inter_ti) lpe->max_digits);
EmitCode::up();
EmitCode::val_number(0);
EmitCode::up();
EmitCode::inv(AND_BIP);
EmitCode::down();
}
EmitCode::inv(LT_BIP);
EmitCode::down();
EmitCode::val_symbol(K_value, gprk.wpos_s);
EmitCode::val_symbol(K_value, gprk.cur_len_s);
EmitCode::up();
EmitCode::inv(GE_BIP);
EmitCode::down();
EmitCode::call(Hierarchy::find(DIGITTOVALUE_HL));
EmitCode::down();
EmitCode::inv(bufferbip);
EmitCode::down();
EmitCode::val_symbol(K_value, gprk.cur_addr_s);
EmitCode::val_symbol(K_value, gprk.wpos_s);
EmitCode::up();
if (lpe->number_base != 10)
EmitCode::val_number((inter_ti) lpe->number_base);
EmitCode::up();
EmitCode::val_number(0);
EmitCode::up();
if (lpe->max_digits < 1000000) {
EmitCode::up();
}
EmitCode::up();
EmitCode::code();
EmitCode::down();
@ -1111,6 +1127,10 @@ sets the |parsed_number| global to the value matched.
EmitCode::down();
EmitCode::ref_symbol(K_value, gprk.wpos_s);
EmitCode::up();
EmitCode::inv(POSTINCREMENT_BIP);
EmitCode::down();
EmitCode::ref_symbol(K_value, gprk.rv_s);
EmitCode::up();
EmitCode::up();
EmitCode::up();
@ -1130,6 +1150,24 @@ sets the |parsed_number| global to the value matched.
EmitCode::up();
EmitCode::up();
if (lpe->min_digits > 1) {
EmitCode::inv(IF_BIP);
EmitCode::down();
EmitCode::inv(LT_BIP);
EmitCode::down();
EmitCode::val_symbol(K_value, gprk.rv_s);
EmitCode::val_number((inter_ti) lpe->min_digits);
EmitCode::up();
EmitCode::code();
EmitCode::down();
EmitCode::inv(JUMP_BIP);
EmitCode::down();
EmitCode::lab(failed_label);
EmitCode::up();
EmitCode::up();
EmitCode::up();
}
if (lpe->element_index > 0) {
EmitCode::inv(IF_BIP);
EmitCode::down();

2
inform7/values-module/Chapter 1/Values Module.w
View file

@ -10,6 +10,7 @@ which use this module:
@ Like all modules, this one must define a |start| and |end| function:
@e LITERAL_NOTATIONS_DA
@e OBJECT_CREATIONS_DA
@e PHRASE_USAGE_DA
@e SPECIFICITIES_DA
@ -26,6 +27,7 @@ COMPILE_WRITER(nonlocal_variable *, NonlocalVariables::log)
void ValuesModule::start(void) {
Tables::Relations::start();
Writers::register_writer('I', &Instances::writer);
Log::declare_aspect(LITERAL_NOTATIONS_DA, L"literal notations", FALSE, FALSE);
Log::declare_aspect(OBJECT_CREATIONS_DA, L"object creations", FALSE, FALSE);
Log::declare_aspect(PHRASE_USAGE_DA, L"phrase usage", FALSE, FALSE);
Log::declare_aspect(SPECIFICITIES_DA, L"specificities", FALSE, FALSE);

340
inform7/values-module/Chapter 3/Literal Patterns.w
View file

@ -118,8 +118,9 @@ typedef struct literal_pattern_element {
struct wording element_name; /* if we define a name for the element */
int is_real; /* store as a real number, not an integer? */
int with_leading_zeros; /* override default to say yes */
int without_leading_zeros; /* override default to say no */
int print_with_leading_zeros; /* print with leading zeros */
int min_digits; /* when writing this */
int max_digits; /* when writing this */
int number_base; /* e.g., 10 for decimal */
int element_optional; /* can we truncate the LP here? */
int preamble_optional; /* if so, can we lose the preamble as well? */
@ -183,6 +184,8 @@ literal_pattern_token LiteralPatterns::lpt_new(int t, int nw) {
}
@ =
literal_pattern_element *parsing_new_element = NULL;
literal_pattern_element LiteralPatterns::lpe_new(int i, int r, int sgn) {
literal_pattern_element lpe;
if (i == 0) lpe.element_range = -1; else lpe.element_range = r;
@ -192,8 +195,9 @@ literal_pattern_element LiteralPatterns::lpe_new(int i, int r, int sgn) {
lpe.preamble_optional = FALSE;
lpe.element_optional = FALSE;
lpe.number_base = 10;
lpe.with_leading_zeros = FALSE;
lpe.without_leading_zeros = FALSE;
lpe.print_with_leading_zeros = FALSE;
lpe.min_digits = 1;
lpe.max_digits = 1000000;
return lpe;
}
@ -487,18 +491,20 @@ on unusual platforms.
int digits_found = 0, point_at = -1;
max_16_bit = 32767LL; if (sign_used_at) max_16_bit = 32768LL;
max_32_bit = 2147483647LL; if (sign_used_at) max_32_bit = 2147483648LL;
while ((LiteralPatterns::digit_value(wd[wpos], lpe) >= 0) ||
((wd[wpos] == '.') &&
(Kinds::Scalings::get_integer_multiplier(lp->scaling) > 1) &&
(point_at == -1))) {
while ((digits_found < lpe->max_digits) &&
((LiteralPatterns::digit_value(wd[wpos], lpe->number_base) >= 0) ||
((wd[wpos] == '.') &&
(Kinds::Scalings::get_integer_multiplier(lp->scaling) > 1) &&
(point_at == -1)))) {
if (wd[wpos] == '.') { point_at = digits_found; wpos++; continue; }
tot = lpe->number_base*tot + LiteralPatterns::digit_value(wd[wpos++], lpe);
tot = lpe->number_base*tot + LiteralPatterns::digit_value(wd[wpos++], lpe->number_base);
if (tot > max_16_bit) overflow_16_bit_flag = TRUE;
if (tot > max_32_bit) overflow_32_bit_flag = TRUE;
digits_found++;
}
if ((point_at == 0) || (point_at == digits_found)) return NULL;
if (digits_found == 0) return NULL;
if (digits_found < lpe->min_digits) return NULL;
while ((point_at > 0) && (point_at < digits_found)) {
matched_scaledown *= lpe->number_base; point_at++;
}
@ -652,7 +658,7 @@ which is annoying. So we have a mechanism to suppress duplicates:
@ A digit value in a given LPE:
=
int LiteralPatterns::digit_value(wchar_t c, literal_pattern_element *lpe) {
int LiteralPatterns::digit_value(wchar_t c, int base) {
int r = -1;
int d = ((int) c - (int) '0');
if ((d >= 0) && (d < 10)) r = d;
@ -664,7 +670,7 @@ int LiteralPatterns::digit_value(wchar_t c, literal_pattern_element *lpe) {
if ((d >= 0) && (d < 26)) r = d + 10; else return -1;
}
}
if ((r >= 0) && (r < lpe->number_base)) return r;
if ((r >= 0) && (r < base)) return r;
return -1;
}
@ -885,14 +891,9 @@ note that the following uses the raw text of the word.
int remainder;
Kinds::Scalings::value_to_quanta(v, lp->scaling, &v, &remainder);
literal_pattern_element *lpe = &(lp->lp_elements[ec]);
if (ec == 0) WRITE("%d", v/(lpe->element_multiplier));
else {
char *prototype = "%d";
if ((lpe->with_leading_zeros) ||
((lp->lp_tokens[tc].new_word_at == FALSE) && (lpe->without_leading_zeros == FALSE)))
prototype = LiteralPatterns::leading_zero_prototype(lpe->element_range);
WRITE(prototype, (v/(lpe->element_multiplier)) % (lpe->element_range));
}
int m = lpe->element_range;
LiteralPatterns::write_val(OUT, m,
(v/(lpe->element_multiplier)) % m, lpe->number_base, lpe->print_with_leading_zeros);
if (ec == 0) @<Index the fractional part of the value@>;
}
ec++;
@ -906,23 +907,29 @@ note that the following uses the raw text of the word.
}
if (remainder > 0) {
WRITE(".");
WRITE(LiteralPatterns::leading_zero_prototype(ranger), remainder);
LiteralPatterns::write_val(OUT, ranger, remainder, lp->number_base, TRUE);
}
@ Please don't mention the words "logarithm" or "shift". It works fine.
@ Please don't ask pointed questions about the running time here. It works fine.
=
char *LiteralPatterns::leading_zero_prototype(int range) {
if (range > 1000000000) return "%010d";
if (range > 100000000) return "%09d";
if (range > 10000000) return "%08d";
if (range > 1000000) return "%07d";
if (range > 100000) return "%06d";
if (range > 10000) return "%05d";
if (range > 1000) return "%04d";
if (range > 100) return "%03d";
if (range > 10) return "%02d";
return "%d";
void LiteralPatterns::write_val(OUTPUT_STREAM, int range, int val, int base, int lz) {
if (val < 0) internal_error("negative val");
if (base < 2) internal_error("impossible number base");
int d = 1; int vc = 0;
if (val == 0) vc = 1;
while (d < val) vc++, d *= base;
if ((lz) && (range >= 0)) {
int d = 1, c = 0;
while (d < range) c++, d *= base;
for (int i=vc; i<c; i++) WRITE("0");
}
for (int i=vc; i>=1; i--) {
int d = 1; for (int j=1; j<i; j++) d = d*base;
int dval = (val/d)%base;
if (dval < 10) WRITE("%d", dval);
else WRITE("%c", 'A' + dval - 10);
}
}
@ The grammars for the specify sentence are quite complicated, but aren't used
@ -961,6 +968,8 @@ literal_pattern *LiteralPatterns::new_literal_specification_inner(lp_specificati
@<Calculate the multipliers for packing the elements into a single integer@>;
}
if (Log::aspect_switched_on(LITERAL_NOTATIONS_DA)) @<Log this literal pattern in full@>;
if (owner == NULL) owner = lp;
else @<Add this new alternative to the list belonging to our owner@>;
return owner;
@ -1090,20 +1099,9 @@ does not throw a problem message as being a bar which is out of range
alphabetic vs numeric pieces of a word:
@<Break down the specification text into tokens and elements@> =
int i, j, tc, ec;
for (i=0, tc=0, ec=0; i<Wordings::length(lps->notation_wording); i++) {
literal_pattern_token new_token;
int digit_found = FALSE;
wchar_t *text_of_word = Lexer::word_raw_text(Wordings::first_wn(lps->notation_wording)+i);
for (j=0; text_of_word[j]; j++) if (Characters::isdigit(text_of_word[j])) digit_found = TRUE;
if (digit_found)
@<Break up the word into at least one element token, and perhaps also character tokens@>
else {
new_token = LiteralPatterns::lpt_new(WORD_LPT, TRUE);
new_token.token_wn = Wordings::first_wn(lps->notation_wording)+i;
@<Add new token to LP@>;
}
}
int tc = 0, ec = 0, angle_escaped_parts_exist = FALSE;
wording NW = lps->notation_wording;
@<Subdivide the wording around angle-bracket escapes@>;
lp->no_lp_tokens = tc;
lp->no_lp_elements = ec;
if (lp->no_lp_elements == 0) {
@ -1113,19 +1111,152 @@ alphabetic vs numeric pieces of a word:
"specifies a weight'.");
return owner;
}
if ((lps->part_np_list == NULL) && (angle_escaped_parts_exist)) {
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"since the specification involves parts named in angle brackets "
"it must go on to give details such as 'with parts...'",
"and it appears that it doesn't.");
return owner;
}
@ We will use this throwaway little structure to hold inclusive endpoints for
ranges we are scanning: |(143, 2)| means "character 2 (counting from 0) in
word number 143".
=
typedef struct lpe_notation_pos {
int wn;
int char_pos;
} lpe_notation_pos;
@ This enables us to express how we want to divide up text such as
|#<red level>_<green level>_<blue level>|, which may have word breaks in the
middle of either angle-escapes or the material in between.
@<Subdivide the wording around angle-bracket escapes@> =
lpe_notation_pos from = { Wordings::first_wn(NW), 0 };
for (int i=0; i<Wordings::length(NW); i++) {
int quoted = FALSE;
wchar_t *text = Lexer::word_raw_text(Wordings::first_wn(NW)+i);
for (int j=0; text[j]; j++)
if (text[j] == '\"') {
quoted = quoted?FALSE:TRUE;
} else if ((quoted == FALSE) && (text[j] == '<')) {
if (j == 0) {
if (i > 0) {
lpe_notation_pos to = { Wordings::first_wn(NW)+i-1,
Wide::len(Lexer::word_raw_text(Wordings::last_wn(NW)+i-1)) - 1 };
@<Compile unescaped notation between from and to@>;
}
} else {
lpe_notation_pos to = { Wordings::first_wn(NW)+i, j-1 };
@<Compile unescaped notation between from and to@>;
}
TEMPORARY_TEXT(angles)
int next_token_begins_word = TRUE;
if (j > 0) next_token_begins_word = FALSE;
int k = j+1, found = FALSE, found_open = FALSE;
for (; ((found == FALSE) && (i<Wordings::length(NW))); i++, k=0) {
text = Lexer::word_raw_text(Wordings::first_wn(NW)+i);
for (; text[k]; k++) {
if (text[k] == '\"') quoted = quoted?FALSE:TRUE;
if ((quoted == FALSE) && (text[k] == '>')) {
found = TRUE; k++;
break;
} else {
if ((quoted == FALSE) && (text[k] == '<')) found_open = TRUE;
PUT_TO(angles, text[k]);
}
}
if (found) break;
quoted = FALSE;
if (i < Wordings::length(NW)) PUT_TO(angles, ' ');
}
if ((found == FALSE) || (found_open))
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"'<' without '>' in a literal specification",
"which must mean that the angle brackets do not match.");
from.wn = Wordings::first_wn(NW)+i;
from.char_pos = k;
@<Act on angle-bracketed escape@>;
DISCARD_TEXT(angles)
j = k - 1;
}
}
lpe_notation_pos to = { Wordings::last_wn(NW),
Wide::len(Lexer::word_raw_text(Wordings::last_wn(NW))) - 1 };
@<Compile unescaped notation between from and to@>;
@ Angle-escapes are easy, and must consist of either double-quoted literal
material or else names for parts about which nothing else is said.
@<Act on angle-bracketed escape@> =
Str::trim_white_space(angles);
wording AW = Feeds::feed_text(angles);
if (<quoted-text>(AW)) {
wchar_t *literal_text = Lexer::word_raw_text(Wordings::first_wn(AW));
for (int x=1; x < Wide::len(literal_text) - 1; x++) {
literal_pattern_token new_token =
LiteralPatterns::lpt_new(CHARACTER_LPT, next_token_begins_word);
new_token.token_char = literal_text[x];
@<Add new token to LP@>;
next_token_begins_word = FALSE;
}
} else {
int tot = 1, sgn = 1;
@<Make a new element@>;
parsing_new_element = &(lp->lp_elements[ec-1]);
parsing_new_element->element_name = AW;
literal_pattern_token new_token =
LiteralPatterns::lpt_new(ELEMENT_LPT, next_token_begins_word);
@<Add new token to LP@>;
next_token_begins_word = FALSE;
angle_escaped_parts_exist = TRUE;
}
@ Now we are looking for digits. |x45yyz| would be split into the character
literal |x|, then a numerical element with range |45| in the current number base,
then three more character literals. If there are no digits, and we have an entire
word to play with, we optimise by making a word token instead of a run of
character ones.
@<Compile unescaped notation between from and to@> =
if ((from.wn < to.wn) || (from.char_pos < to.char_pos)) {
wording NW = Wordings::new(from.wn, to.wn);
for (int i=0; i<Wordings::length(NW); i++) {
wchar_t *text_of_word = Lexer::word_raw_text(Wordings::first_wn(NW)+i);
int start_from = 0, finish_at = Wide::len(text_of_word)-1;
if (i == 0) start_from = from.char_pos;
if (i == Wordings::length(NW)-1) finish_at = to.char_pos;
int digit_found = FALSE;
for (int j=start_from; j<=finish_at; j++)
if (LiteralPatterns::digit_value(text_of_word[j], lp->number_base) >= 0)
digit_found = TRUE;
if ((digit_found) || (start_from != 0) || (finish_at != Wide::len(text_of_word)-1))
@<Break up the word into at least one element token, and perhaps also character tokens@>
else {
literal_pattern_token new_token = LiteralPatterns::lpt_new(WORD_LPT, TRUE);
new_token.token_wn = Wordings::first_wn(NW)+i;
@<Add new token to LP@>;
}
}
}
@ Bounds checking is easier here since we know that a LP specification will
not ever need to create the maximum conceivable value which a C integer can
hold -- so we need not fool around with long long ints.
@<Break up the word into at least one element token, and perhaps also character tokens@> =
int j, sgn = 1, next_token_begins_word = TRUE;
for (j=0; text_of_word[j]; j++) {
int sgn = 1, next_token_begins_word = TRUE, base = lp->number_base;
if (start_from > 0) next_token_begins_word = FALSE;
for (int j=start_from; j<=finish_at; j++) {
int tot = 0, digit_found = FALSE, point_found = FALSE;
if ((text_of_word[j] == '-') && (Characters::isdigit(text_of_word[j+1])) && (ec == 0)) {
if ((text_of_word[j] == '-') &&
(LiteralPatterns::digit_value(text_of_word[j+1], base) >= 0) &&
(ec == 0)) {
sgn = -1; continue;
}
while (Characters::isdigit(text_of_word[j++])) {
while (LiteralPatterns::digit_value(text_of_word[j++], base) >= 0) {
digit_found = TRUE;
if (tot > 999999999) {
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_LPElementTooLarge),
@ -1134,35 +1265,40 @@ hold -- so we need not fool around with long long ints.
"be stored at run-time.");
return owner;
}
tot = 10*tot + (text_of_word[j-1]-'0');
tot = base*tot + LiteralPatterns::digit_value(text_of_word[j-1], base);
}
j--;
if ((text_of_word[j] == '.') && (text_of_word[j+1] == '0') && (ec == 0)) {
j += 2; point_found = TRUE;
}
if (digit_found) {
literal_pattern_element new_element = LiteralPatterns::lpe_new(ec, tot+1, sgn);
if (ec >= MAX_ELEMENTS_PER_LITERAL) {
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_LPTooManyElements),
"that specification contains too many numerical elements",
"and is too complicated for Inform to handle.");
return owner;
}
new_element.is_real = point_found;
@<Make a new element@>;
lp->lp_elements[ec-1].is_real = point_found;
if (point_found) integer_scaling = FALSE;
lp->lp_elements[ec++] = new_element;
if (sgn == -1) lp->number_signed = TRUE;
new_token = LiteralPatterns::lpt_new(ELEMENT_LPT, next_token_begins_word);
literal_pattern_token new_token = LiteralPatterns::lpt_new(ELEMENT_LPT, next_token_begins_word);
@<Add new token to LP@>;
j--;
} else {
new_token = LiteralPatterns::lpt_new(CHARACTER_LPT, next_token_begins_word);
literal_pattern_token new_token = LiteralPatterns::lpt_new(CHARACTER_LPT, next_token_begins_word);
new_token.token_char = text_of_word[j];
@<Add new token to LP@>;
}
sgn = 1; next_token_begins_word = FALSE;
}
@<Make a new element@> =
literal_pattern_element new_element = LiteralPatterns::lpe_new(ec, tot+1, sgn);
if ((next_token_begins_word == FALSE) && (ec > 0))
new_element.print_with_leading_zeros = TRUE;
if (ec >= MAX_ELEMENTS_PER_LITERAL) {
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_LPTooManyElements),
"that specification contains too many numerical elements",
"and is too complicated for Inform to handle.");
return owner;
}
lp->lp_elements[ec++] = new_element;
@ In fact counting tokens is not necessarily a good way to measure the
complexity of an LP, since any long run of characters in a word which
also contains a number will splurge the number of tokens. So
@ -1202,18 +1338,57 @@ this is deferred until all elements exist, at which point we --
parse_node *p;
for (i=0, p=lps->part_np_list; (i<lp->no_lp_elements) && (p); i++, p = p->next) {
literal_pattern_element *lpe = &(lp->lp_elements[i]);
lpe->element_name = Node::get_text(p);
int size_needed = FALSE;
if (Wordings::empty(lpe->element_name)) {
lpe->element_name = Node::get_text(p);
} else if (Wordings::match(lpe->element_name, Node::get_text(p)) == FALSE) {
LOG("Want %W have %W\n", lpe->element_name, Node::get_text(p));
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the part names after 'with' do not exactly match those named "
"in the specification itself",
"as they must.");
} else {
size_needed = TRUE;
}
int O = Annotations::read_int(p, lpe_options_ANNOT);
if (O & OPTIONAL_LSO) lpe->element_optional = TRUE;
if (O & PREAMBLE_OPTIONAL_LSO) {
lpe->element_optional = TRUE; lpe->preamble_optional = TRUE;
}
if (O & WITH_LEADING_ZEROS_LSO) lpe->with_leading_zeros = TRUE;
else if (O & WITHOUT_LEADING_ZEROS_LSO) lpe->without_leading_zeros = TRUE;
if (O & WITH_LEADING_ZEROS_LSO) lpe->print_with_leading_zeros = TRUE;
else if (O & WITHOUT_LEADING_ZEROS_LSO) lpe->print_with_leading_zeros = FALSE;
if (O & BASE_MASK_LSO) lpe->number_base = ((O & BASE_MASK_LSO) / BASE_LSO);
else lpe->number_base = lp->number_base;
if (O & MAXIMUM_LSO)
if (O & MIN_DIGITS_MASK_LSO)
lpe->min_digits = ((O & MIN_DIGITS_MASK_LSO) / MIN_DIGITS_LSO);
if (O & MAX_DIGITS_MASK_LSO)
lpe->max_digits = ((O & MAX_DIGITS_MASK_LSO) / MAX_DIGITS_LSO);
if (O & MAXIMUM_LSO) {
lpe->element_range = Annotations::read_int(p, lpe_max_ANNOT) + 1;
if (O & MAX_DIGITS_MASK_LSO) {
int n = lpe->element_range - 1;
for (int i=1; i<=lpe->max_digits; i++) n = n/lpe->number_base;
if (n != 0)
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"the maximum value here is greater than would fit in the number of digits",
"so that it could not be written down.");
}
} else {
if (O & MAX_DIGITS_MASK_LSO) {
int n = 1;
for (int i=1; i<=lpe->max_digits; i++) n = n*lpe->number_base;
lpe->element_range = n;
}
}
if ((size_needed) && ((O & (MAX_DIGITS_MASK_LSO + MAXIMUM_LSO)) == 0)) {
if (i == 0) lpe->element_range = -1;
else
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(...),
"this has a part with no indication of its possible range",
"that is, by saying '0 to N' or 'N digits'.");
}
if ((i == lp->no_lp_elements - 1) && (p->next)) {
StandardProblems::sentence_problem(Task::syntax_tree(), _p_(PM_LPTooManyPartNames),
"this gives names for too many parts",
@ -1255,6 +1430,39 @@ optional, and it must not be the first.
return owner;
}
@<Log this literal pattern in full@> =
LOG("Notation for kind %u\nSpecification: %W\n", K, Node::get_text(p));
for (parse_node *p = lps->part_np_list; p; p = p->next) {
LOG("part: %W (%08x)\n", Node::get_text(p), Annotations::read_int(p, lpe_options_ANNOT));
}
for (int i=0, ec=0; i<lp->no_lp_tokens; i++) {
literal_pattern_token *lpt = &(lp->lp_tokens[i]);
LOG("Token %d ", i);
if (lpt->new_word_at) LOG("(starts word) ");
switch (lpt->lpt_type) {
case WORD_LPT: LOG("word %+W\n", Wordings::one_word(lpt->token_wn)); break;
case CHARACTER_LPT: LOG("char %c\n", lpt->token_char); break;
case ELEMENT_LPT: {
LOG("element ");
literal_pattern_element *lpe = &(lp->lp_elements[ec]);
LOG("(%d) ", lpe->element_index);
if (Wordings::empty(lpe->element_name)) LOG("(nameless) ");
else LOG("%W ", lpe->element_name);
if (lpe->min_digits == lpe->max_digits) LOG("%d digit(s) ", lpe->min_digits);
else if ((lpe->min_digits > 1) || (lpe->max_digits < 1000000))
LOG("%d to %d digits ", lpe->min_digits, lpe->max_digits);
if (lpe->print_with_leading_zeros) LOG("printed with leading zeros ");
if (lpe->element_range >= 0) LOG("range 0 to %d ", lpe->element_range);
else LOG("range unlimited ");
LOG("(base %d) ", lpe->number_base);
LOG("- multiplier %d\n", lpe->element_multiplier);
ec++;
break;
}
}
}
LOG("\n");
@ Group names are created when first seen; the following recognises one which
has been seen before.

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

@ -1,5 +1,5 @@
Size of lexicon: 3143 excerpt meanings
Stored among 850 words out of total vocabulary of 10766
Stored among 850 words out of total vocabulary of 10769
720 words have a start list: longest belongs to report (with 293 meanings)
15 words have an end list: longest belongs to case (with 6 meanings)
29 words have a middle list: longest belongs to to (with 4 meanings)