|
|
|
@ -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>§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">§25.7</a>, <a href="3-lp.html#SP25_7_1">§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">§25.7.2.1</a>, <a href="3-lp.html#SP25_7_2_2">§25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">§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>§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">§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">§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">) >= </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">) &&</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">-></span><span class="element-syntax">scaling</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">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"> < </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="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="element-syntax">number_base</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">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="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">-></span><span class="element-syntax">scaling</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">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">-></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">-></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="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"> > </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"> > </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"> < </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="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"> > </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="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">-></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">§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">§16.1.3.1</a>, <a href="3-lp.html#SP25_7_2_2">§25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">§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"> >= </span><span class="constant-syntax">0</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="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"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">d</span><span class="plain-syntax"> < </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"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">r</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="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"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">r</span><span class="plain-syntax"> < </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">-></span><span class="element-syntax">scaling</span><span class="plain-syntax">, &</span><span class="identifier-syntax">v</span><span class="plain-syntax">, &</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"> = &(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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">-></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">-></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">-></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">) && (</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">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">-></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">-></span><span class="element-syntax">element_multiplier</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="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">-></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">-></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">-></span><span class="element-syntax">number_base</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="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"> > </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">-></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">§23.3</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP24" class="paragraph-anchor"></a><b>§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>§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">§23.3</a>, <a href="3-lp.html#SP23_3_1">§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"> > </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"> > </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"> > </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"> > </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"> > </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"> > </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"> > </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"> > </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"> > </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">§23.3</a>, <a href="3-lp.html#SP23_3_1">§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"> < </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"> < </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"> < </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">) && (</span><span class="identifier-syntax">range</span><span class="plain-syntax"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">)) {</span>
|
|
|
|
|
<span class="plain-syntax"> </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="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"> < </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"><</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">>=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"><</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"> < </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>§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"><Wordings::length(lps-></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">-></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">-></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">-></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">-></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">-></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">-></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">-></span><span class="identifier-syntax">part_np_list</span><span class="plain-syntax"> == </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">) && (</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">§25</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_1" class="paragraph-anchor"></a><b>§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>§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>§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">#<red level>_<green level>_<blue level></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"><</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">) && (</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="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"> > </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"> > </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">) && (</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">))); </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">) && (</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="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">) && (</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">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"> < </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">"'<' without '>' 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">§25.7</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2_1" class="paragraph-anchor"></a><b>§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"><quoted-text></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"> < </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"> = &(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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">-></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">§25.7.2</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2_2" class="paragraph-anchor"></a><b>§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"> < </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"> < </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"><</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"><=</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">-></span><span class="element-syntax">number_base</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">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">§25.7.2</a> (three times).</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2_2_1" class="paragraph-anchor"></a><b>§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 — 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">-></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"> > </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"><=</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">) && (</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])) && (</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">) &&</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="constant-syntax">0</span><span class="plain-syntax">) &&</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">) >= </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"> > </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 — 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">) && (</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="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"> >= </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">-></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">-></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">-></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">§25.7</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2" class="paragraph-anchor"></a><b>§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">§25.7.2.2</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2_1_1" class="paragraph-anchor"></a><b>§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">) && (</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">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"> >= </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">-></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">§25.7.2.1</a>, <a href="3-lp.html#SP25_7_2_2_1">§25.7.2.2.1</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_7_2_1_2" class="paragraph-anchor"></a><b>§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">-></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">§25.7</a>, <a href="3-lp.html#SP25_7_1">§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">§25.7.2.1</a> (twice), <a href="3-lp.html#SP25_7_2_2">§25.7.2.2</a>, <a href="3-lp.html#SP25_7_2_2_1">§25.7.2.2.1</a> (twice).</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_8" class="paragraph-anchor"></a><b>§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 —
|
|
|
|
|
<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">-></span><span class="identifier-syntax">part_np_list</span><span class="plain-syntax">; (</span><span class="identifier-syntax">i</span><span class="function-syntax"><lp-></span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax">) && (</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">-></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"> = &(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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">-></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">-></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">-></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">-></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">-></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"> & </span><span class="identifier-syntax">OPTIONAL_LSO</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">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"> & </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">-></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">-></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"> & </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">-></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"> & </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">-></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"> & </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">-></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"> & </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">-></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"> & </span><span class="identifier-syntax">BASE_MASK_LSO</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="identifier-syntax">O</span><span class="plain-syntax"> & </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">-></span><span class="element-syntax">number_base</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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"> & </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"> & </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">-></span><span class="element-syntax">min_digits</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> & </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"> & </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">-></span><span class="element-syntax">max_digits</span><span class="plain-syntax"> = ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> & </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"> & </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">-></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"> & </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">-></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"><=lpe-></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">-></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"> & </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"><=lpe-></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">-></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">-></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">) && ((</span><span class="identifier-syntax">O</span><span class="plain-syntax"> & (</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">-></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">-></span><span class="element-syntax">no_lp_elements</span><span class="plain-syntax"> - </span><span class="constant-syntax">1</span><span class="plain-syntax">) && (</span><span class="identifier-syntax">p</span><span class="plain-syntax">-></span><span class="element-syntax">next</span><span class="plain-syntax">)) {</span>
|
|
|
|
|
<span class="plain-syntax"> </span><span class="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">§25</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP25_12" class="paragraph-anchor"></a><b>§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">-></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">-></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"><lp-></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"> = &(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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">-></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">-></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">-></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">-></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"> = &(</span><span class="identifier-syntax">lp</span><span class="plain-syntax">-></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">-></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">-></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">-></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">-></span><span class="element-syntax">min_digits</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="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">-></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">-></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="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="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">-></span><span class="element-syntax">min_digits</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="plain-syntax"> </span><span class="reserved-syntax">if</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">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">-></span><span class="element-syntax">element_range</span><span class="plain-syntax"> >= </span><span class="constant-syntax">0</span><span class="plain-syntax">) </span><span class="identifier-syntax">LOG</span><span class="plain-syntax">(</span><span class="string-syntax">"range 0 to %d "</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="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">-></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">-></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">§25</a>.</li></ul>
|
|
|
|
|
<p class="commentary firstcommentary"><a id="SP26" class="paragraph-anchor"></a><b>§26. </b>Group names are created when first seen; the following recognises one which
|
|
|
|
|
has been seen before.
|
|
|
|
|
</p>
|
|
|
|
|