Further work on wchar_t portability

README.md

@@ -1,6 +1,6 @@
 # Inform 7
 
-v10.1.0-alpha.1+6Q69 'Krypton' (7 July 2020)
+v10.1.0-alpha.1+6Q70 'Krypton' (8 July 2020)
 
 ## About Inform 7
 

build.txt

@@ -1,3 +1,3 @@
 Prerelease: alpha.1
-Build Date: 7 July 2020
+Build Date: 8 July 2020
-Build Number: 6Q69
+Build Number: 6Q70

docs/building-module/2-is.html

@@ -1260,7 +1260,7 @@ scanned through since the last time.
 <span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">L</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::len</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_raw</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">c_start</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">escaped</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">p</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">; </span><span class="identifier-syntax">p</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">L</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">c1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_raw</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">), </span><span class="identifier-syntax">c2</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">c3</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c1</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_raw</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">), </span><span class="identifier-syntax">c2</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">c3</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">p</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">L</span><span class="plain-syntax">-1) </span><span class="identifier-syntax">c2</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_raw</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</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">p</span><span class="plain-syntax"> &lt; </span><span class="identifier-syntax">L</span><span class="plain-syntax">-2) </span><span class="identifier-syntax">c3</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">current_raw</span><span class="plain-syntax">, </span><span class="identifier-syntax">p</span><span class="plain-syntax">+2);</span>
 
@@ -1472,7 +1472,7 @@ inclusive; we ignore an empty token.
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">) == </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">1</span><span class="plain-syntax">) == </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Characters::isalpha</span><span class="plain-syntax">(</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">2</span><span class="plain-syntax">)))) {</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'_'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (!</span><span class="identifier-syntax">Characters::isalnum</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">)))</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">RAW_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
@@ -1480,7 +1480,7 @@ inclusive; we ignore an empty token.
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">) == </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Characters::isalpha</span><span class="plain-syntax">(</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</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">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'_'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'$'</span><span class="plain-syntax">) &amp;&amp; (!</span><span class="identifier-syntax">Characters::isalnum</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">)))</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">RAW_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
@@ -1488,7 +1488,7 @@ inclusive; we ignore an empty token.
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">) == </span><span class="character-syntax">'_'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">Characters::isalpha</span><span class="plain-syntax">(</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</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">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'_'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'#'</span><span class="plain-syntax">) &amp;&amp; (!</span><span class="identifier-syntax">Characters::isalnum</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">)))</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">RAW_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
@@ -1496,7 +1496,7 @@ inclusive; we ignore an empty token.
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Characters::isalpha</span><span class="plain-syntax">(</span><span class="identifier-syntax">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</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">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">IDENTIFIER_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">c</span><span class="plain-syntax"> != </span><span class="character-syntax">'_'</span><span class="plain-syntax">) &amp;&amp; (!</span><span class="identifier-syntax">Characters::isalnum</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">)))</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">RAW_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
@@ -1508,7 +1508,7 @@ inclusive; we ignore an empty token.
 <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">Str::get_at</span><span class="plain-syntax">(</span><span class="identifier-syntax">T</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">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">NUMBER_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">, </span><span class="identifier-syntax">T</span><span class="plain-syntax">) {</span>
-<span class="plain-syntax">            </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">P</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (!</span><span class="identifier-syntax">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">))</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">is</span><span class="plain-syntax"> = </span><span class="constant-syntax">RAW_ISTT</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>

docs/core-module/26-ct.html

@@ -387,7 +387,7 @@ exceptional case.
 
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="function-syntax">CompiledText::alphabetic</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">CompiledText::alphabetic</span></span>:<br/><a href="26-ct.html#SP1_1">&#167;1.1</a>, <a href="26-ct.html#SP1_2">&#167;1.2</a>, <a href="26-ct.html#SP2_1">&#167;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">letter</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">isalpha</span><span class="plain-syntax">(</span><span class="identifier-syntax">Characters::remove_accent</span><span class="plain-syntax">(</span><span class="identifier-syntax">letter</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">Characters::isalpha</span><span class="plain-syntax">((</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax">) </span><span class="identifier-syntax">Characters::remove_accent</span><span class="plain-syntax">(</span><span class="identifier-syntax">letter</span><span class="plain-syntax">));</span>
 <span class="plain-syntax">}</span>
 </pre>
 <p class="commentary firstcommentary"><a id="SP4"></a><b>&#167;4.  </b>This looks for "[unicode 8212]" and turns it into an em-dash, for example.

docs/indoc/3-ei.html

@@ -165,11 +165,11 @@ degree of alphabetisation.
 <span class="plain-syntax">        </span><a href="3-ei.html#SP4" class="function-link"><span class="function-syntax">ExamplesIndex::sort_comparison</span></a><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">current_subtitle</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">current_letter</span><span class="plain-syntax"> = -1;</span>
+<span class="plain-syntax">    </span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">current_letter</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">first_letter_block</span><span class="plain-syntax"> = </span><span class="constant-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="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">NUMBER_CREATED</span><span class="plain-syntax">(</span><span class="reserved-syntax">example_index_data</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">example_index_data</span><span class="plain-syntax"> *</span><span class="identifier-syntax">eid</span><span class="plain-syntax"> = </span><span class="identifier-syntax">eid_list</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">initial</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get_first_char</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">eid</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">sort_key</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">initial</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get_first_char</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">eid</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">sort_key</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::isdigit</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">initial</span><span class="plain-syntax">)) </span><span class="identifier-syntax">initial</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">initial</span><span class="plain-syntax"> != </span><span class="identifier-syntax">current_letter</span><span class="plain-syntax">) </span><span class="named-paragraph-container code-font"><a href="3-ei.html#SP3_3" class="named-paragraph-link"><span class="named-paragraph">Start a new letter block</span><span class="named-paragraph-number">3.3</span></a></span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">TEMPORARY_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">url</span><span class="plain-syntax">)</span>
@@ -212,7 +212,7 @@ degree of alphabetisation.
 <pre class="displayed-code all-displayed-code code-font">
 <span class="plain-syntax">    </span><span class="identifier-syntax">current_letter</span><span class="plain-syntax"> = </span><span class="identifier-syntax">initial</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">first_letter_block</span><span class="plain-syntax"> == </span><span class="constant-syntax">FALSE</span><span class="plain-syntax">) { </span><span class="identifier-syntax">HTML_TAG</span><span class="plain-syntax">(</span><span class="string-syntax">"br"</span><span class="plain-syntax">); </span><span class="named-paragraph-container code-font"><a href="3-ei.html#SP3_4" class="named-paragraph-link"><span class="named-paragraph">End a letter block</span><span class="named-paragraph-number">3.4</span></a></span><span class="plain-syntax">; }</span>
-<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">uc_current_letter</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::toupper</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">current_letter</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">uc_current_letter</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::toupper</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">current_letter</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">HTML_OPEN</span><span class="plain-syntax">(</span><span class="string-syntax">"tr"</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">HTML_OPEN_WITH</span><span class="plain-syntax">(</span><span class="string-syntax">"td"</span><span class="plain-syntax">, </span><span class="string-syntax">"class=\"letterblock\""</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">inc</span><span class="plain-syntax">)</span>

docs/indoc/3-gi.html

@@ -614,10 +614,10 @@ as it will be seen by the reader.
 <pre class="displayed-code all-displayed-code code-font">
 <span class="plain-syntax">    </span><a href="3-iu.html#SP4" class="function-link"><span class="function-syntax">IndexUtilities::alphabet_row</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">OUT</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">HTML_OPEN_WITH</span><span class="plain-syntax">(</span><span class="string-syntax">"table"</span><span class="plain-syntax">, </span><span class="string-syntax">"class=\"indextable\""</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">current_incipit</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">wchar_t</span><span class="plain-syntax"> </span><span class="identifier-syntax">current_incipit</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">for</span><span class="plain-syntax"> (</span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax">=0; </span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;</span><span class="identifier-syntax">NUMBER_CREATED</span><span class="plain-syntax">(</span><span class="reserved-syntax">index_lemma</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">index_lemma</span><span class="plain-syntax"> *</span><span class="identifier-syntax">il</span><span class="plain-syntax"> = </span><span class="identifier-syntax">lemma_list</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">incipit</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get_first_char</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">il</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">sorting_key</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">incipit</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get_first_char</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">il</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">sorting_key</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::isalpha</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">incipit</span><span class="plain-syntax">)) </span><span class="identifier-syntax">incipit</span><span class="plain-syntax"> = </span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::toupper</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">incipit</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">incipit</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">incipit</span><span class="plain-syntax"> != </span><span class="identifier-syntax">current_incipit</span><span class="plain-syntax">) {</span>

docs/indoc/3-iu.html

@@ -127,7 +127,7 @@ alphabetical sorting will agree with numerical.
 <span class="plain-syntax">        </span><a href="../../../inweb/docs/foundation-module/4-pm.html#SP14" class="function-link"><span class="function-syntax">Regexp::replace</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"an "</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">REP_ATSTART</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><a href="../../../inweb/docs/foundation-module/4-pm.html#SP14" class="function-link"><span class="function-syntax">Regexp::replace</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"the "</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">REP_ATSTART</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">)</span>
-<span class="plain-syntax">            </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP14" class="function-link"><span class="function-syntax">Str::put</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::tolower</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP6" class="function-link"><span class="function-syntax">Characters::remove_accent</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">))));</span>
+<span class="plain-syntax">            </span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP14" class="function-link"><span class="function-syntax">Str::put</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP1" class="function-link"><span class="function-syntax">Characters::tolower</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/4-chr.html#SP6" class="function-link"><span class="function-syntax">Characters::remove_wchar_t_accent</span></a><span class="plain-syntax">(</span><a href="../../../inweb/docs/foundation-module/4-sm.html#SP13" class="function-link"><span class="function-syntax">Str::get</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">))));</span>
 <span class="plain-syntax">        </span><a href="../../../inweb/docs/foundation-module/4-pm.html#SP14" class="function-link"><span class="function-syntax">Regexp::replace</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"%[ *%]"</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"____SQUARES____"</span><span class="plain-syntax">, </span><span class="constant-syntax">REP_REPEATING</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><a href="../../../inweb/docs/foundation-module/4-pm.html#SP14" class="function-link"><span class="function-syntax">Regexp::replace</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"%["</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">REP_REPEATING</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">        </span><a href="../../../inweb/docs/foundation-module/4-pm.html#SP14" class="function-link"><span class="function-syntax">Regexp::replace</span></a><span class="plain-syntax">(</span><span class="identifier-syntax">sort_key</span><span class="plain-syntax">, </span><span class="identifier-syntax">L</span><span class="string-syntax">"%]"</span><span class="plain-syntax">, </span><span class="identifier-syntax">NULL</span><span class="plain-syntax">, </span><span class="constant-syntax">REP_REPEATING</span><span class="plain-syntax">);</span>
@@ -164,8 +164,8 @@ alphabetical sorting will agree with numerical.
 
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">letters_taken</span><span class="plain-syntax">[26];</span>
-<span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">IndexUtilities::note_letter</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">IndexUtilities::note_letter</span></span>:<br/>Contents and Indexes - <a href="3-gi.html#SP9_2">&#167;9.2</a><br/>Examples Index - <a href="3-ei.html#SP3_3">&#167;3.3</a></span></button><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">void</span><span class="plain-syntax"> </span><span class="function-syntax">IndexUtilities::note_letter</span><button class="popup" onclick="togglePopup('usagePopup5')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup5">Usage of <span class="code-font"><span class="function-syntax">IndexUtilities::note_letter</span></span>:<br/>Contents and Indexes - <a href="3-gi.html#SP9_2">&#167;9.2</a><br/>Examples Index - <a href="3-ei.html#SP3_3">&#167;3.3</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="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">c</span><span class="plain-syntax"> - </span><span class="character-syntax">'A'</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">i</span><span class="plain-syntax"> = </span><span class="identifier-syntax">c</span><span class="plain-syntax"> - (</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax">) </span><span class="character-syntax">'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">i</span><span class="plain-syntax">&gt;=0) &amp;&amp; (</span><span class="identifier-syntax">i</span><span class="plain-syntax">&lt;26)) </span><span class="identifier-syntax">letters_taken</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">] = </span><span class="constant-syntax">TRUE</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">}</span>
 <span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">IndexUtilities::alphabet_row</span><button class="popup" onclick="togglePopup('usagePopup6')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup6">Usage of <span class="code-font"><span class="function-syntax">IndexUtilities::alphabet_row</span></span>:<br/>Contents and Indexes - <a href="3-gi.html#SP9_2">&#167;9.2</a><br/>Examples Index - <a href="3-ei.html#SP3">&#167;3</a></span></button><span class="plain-syntax">(</span><span class="constant-syntax">OUTPUT_STREAM</span><span class="plain-syntax">, </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">sequence</span><span class="plain-syntax">) {</span>

docs/inflections-module/3-vc.html

@@ -932,7 +932,7 @@ and we construe "y" (but not "h" or "w") as a vowel.
 
 <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">incipit</span><span class="plain-syntax"> = </span><span class="identifier-syntax">q</span><span class="plain-syntax">[0];</span>
-<span class="plain-syntax">    </span><span class="reserved-syntax">int</span><span class="plain-syntax"> </span><span class="identifier-syntax">first</span><span class="plain-syntax"> = </span><span class="identifier-syntax">tolower</span><span class="plain-syntax">(</span><span class="identifier-syntax">Characters::remove_accent</span><span class="plain-syntax">(</span><span class="identifier-syntax">incipit</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">first</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Characters::tolower</span><span class="plain-syntax">((</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax">) </span><span class="identifier-syntax">Characters::remove_accent</span><span class="plain-syntax">(</span><span class="identifier-syntax">incipit</span><span class="plain-syntax">));</span>
 <span class="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'a'</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'e'</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'i'</span><span class="plain-syntax">) ||</span>
 <span class="plain-syntax">        (</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'o'</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'u'</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">first</span><span class="plain-syntax"> == </span><span class="character-syntax">'y'</span><span class="plain-syntax">))</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">contract_this</span><span class="plain-syntax"> = </span><span class="identifier-syntax">TRUE</span><span class="plain-syntax">;</span>

docs/problems-module/2-pl2.html

@@ -92,7 +92,7 @@ the next because it is not true that problems are always issued in source
 code order.
 </p>
 
-<pre class="definitions code-font"><span class="plain-syntax">@</span><span class="reserved-syntax">default</span><span class="plain-syntax"> </span><span class="constant-syntax">NO_HEADING_LEVELS</span><span class="plain-syntax"> </span><span class="constant-syntax">10</span>
+<pre class="definitions code-font"><span class="definition-keyword">default</span> <span class="constant-syntax">NO_HEADING_LEVELS</span><span class="plain-syntax"> </span><span class="constant-syntax">10</span>
 </pre>
 <pre class="displayed-code all-displayed-code code-font">
 <span class="reserved-syntax">void</span><span class="plain-syntax"> </span><span class="function-syntax">Problems::find_headings_at</span><button class="popup" onclick="togglePopup('usagePopup1')"><span class="comment-syntax">?</span><span class="popuptext" id="usagePopup1">Usage of <span class="code-font"><span class="function-syntax">Problems::find_headings_at</span></span>:<br/><a href="2-pl2.html#SP3">&#167;3</a></span></button><span class="plain-syntax">(</span><span class="identifier-syntax">parse_node_tree</span><span class="plain-syntax"> *</span><span class="identifier-syntax">T</span><span class="plain-syntax">, </span><span class="identifier-syntax">parse_node</span><span class="plain-syntax"> *</span><span class="identifier-syntax">sentence</span><span class="plain-syntax">,</span>
@@ -460,7 +460,7 @@ on when the shortened form is the one being issued).
 <span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="character-syntax">'P'</span><span class="plain-syntax">: </span><span class="identifier-syntax">PUT_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">PBUFF</span><span class="plain-syntax">, </span><span class="identifier-syntax">FORCE_NEW_PARA_CHAR</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="character-syntax">'%'</span><span class="plain-syntax">: </span><span class="identifier-syntax">PUT_TO</span><span class="plain-syntax">(</span><span class="identifier-syntax">PBUFF</span><span class="plain-syntax">, </span><span class="character-syntax">'%'</span><span class="plain-syntax">); </span><span class="identifier-syntax">i</span><span class="plain-syntax">++; </span><span class="reserved-syntax">continue</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">        }</span>
-<span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">message</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="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">wchar_t</span><span class="plain-syntax">) </span><span class="identifier-syntax">message</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="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">message</span><span class="plain-syntax">[</span><span class="identifier-syntax">i</span><span class="plain-syntax">+1]))-((</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="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">t</span><span class="plain-syntax">&gt;=1) &amp;&amp; (</span><span class="identifier-syntax">t</span><span class="plain-syntax">&lt;=9)) {</span>
 <span class="plain-syntax">                </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">problem_quotations</span><span class="plain-syntax">[</span><span class="identifier-syntax">t</span><span class="plain-syntax">].</span><span class="element-syntax">wording_based</span><span class="plain-syntax">)</span>

docs/supervisor-module/4-lm.html

@@ -148,7 +148,7 @@ a valid metadata file. The name should be in English text, without accents.
 <span class="plain-syntax">    </span><span class="identifier-syntax">text_stream</span><span class="plain-syntax"> *</span><span class="identifier-syntax">name</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Pathnames::directory_name</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">acceptable</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">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><span class="identifier-syntax">name</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">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</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">c</span><span class="plain-syntax"> = </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">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">c</span><span class="plain-syntax"> &lt; </span><span class="constant-syntax">32</span><span class="plain-syntax">) || (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> &gt; </span><span class="constant-syntax">126</span><span class="plain-syntax">)) </span><span class="identifier-syntax">acceptable</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">; </span><span class="comment-syntax"> contains non-ASCII</span>
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">Platform::is_folder_separator</span><span class="plain-syntax">(</span><span class="identifier-syntax">c</span><span class="plain-syntax">)) { </span><span class="identifier-syntax">Str::put</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><span class="constant-syntax">0</span><span class="plain-syntax">); </span><span class="reserved-syntax">break</span><span class="plain-syntax">; }</span>
 <span class="plain-syntax">    }</span>

docs/supervisor-module/5-es.html

@@ -513,7 +513,8 @@ range, we flatten them from general ISO to plain ASCII.
 <span class="plain-syntax">        </span><span class="identifier-syntax">E</span><span class="plain-syntax">-&gt;</span><span class="identifier-syntax">as_copy</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">edition</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">work</span><span class="plain-syntax">-&gt;</span><span class="element-syntax">author_name</span><span class="plain-syntax">);</span>
 <span class="plain-syntax">    </span><span class="identifier-syntax">LOOP_THROUGH_TEXT</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">, </span><span class="identifier-syntax">synopsis</span><span class="plain-syntax">)</span>
 <span class="plain-syntax">        </span><span class="identifier-syntax">Str::put</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">,</span>
-<span class="plain-syntax">            </span><span class="identifier-syntax">Characters::make_filename_safe</span><span class="plain-syntax">(</span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">)));</span>
+<span class="plain-syntax">            </span><span class="identifier-syntax">Characters::make_wchar_t_filename_safe</span><span class="plain-syntax">(</span>
+<span class="plain-syntax">                </span><span class="identifier-syntax">Str::get</span><span class="plain-syntax">(</span><span class="identifier-syntax">pos</span><span class="plain-syntax">)));</span>
 </pre>
 <ul class="endnotetexts"><li>This code is used in <a href="5-es.html#SP7">&#167;7</a>.</li></ul>
 <p class="commentary firstcommentary"><a id="SP7_2"></a><b>&#167;7.2.  </b>Note that if there is an active project, then we are reading the extension

docs/words-module/3-lxr.html

@@ -800,9 +800,9 @@ most common URLs glue up as single words.)
 <span class="plain-syntax">        </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">space</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">next_cr</span><span class="plain-syntax"> == </span><span class="character-syntax">'/'</span><span class="plain-syntax">)) </span><span class="identifier-syntax">space</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">space</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">lc</span><span class="plain-syntax"> = </span><span class="constant-syntax">0</span><span class="plain-syntax">, </span><span class="identifier-syntax">nc</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">Characters::isdigit</span><span class="plain-syntax">(</span><span class="identifier-syntax">last_cr</span><span class="plain-syntax">)) </span><span class="identifier-syntax">lc</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">Characters::isdigit</span><span class="plain-syntax">((</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax">) </span><span class="identifier-syntax">last_cr</span><span class="plain-syntax">)) </span><span class="identifier-syntax">lc</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">last_cr</span><span class="plain-syntax"> &gt;= </span><span class="character-syntax">'a'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">last_cr</span><span class="plain-syntax"> &lt;= </span><span class="character-syntax">'z'</span><span class="plain-syntax">)) </span><span class="identifier-syntax">lc</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</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">next_cr</span><span class="plain-syntax">)) </span><span class="identifier-syntax">nc</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">Characters::isdigit</span><span class="plain-syntax">((</span><span class="identifier-syntax">wchar_t</span><span class="plain-syntax">) </span><span class="identifier-syntax">next_cr</span><span class="plain-syntax">)) </span><span class="identifier-syntax">nc</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">next_cr</span><span class="plain-syntax"> == </span><span class="character-syntax">'-'</span><span class="plain-syntax">) </span><span class="identifier-syntax">nc</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">next_cr</span><span class="plain-syntax"> &gt;= </span><span class="character-syntax">'a'</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">next_cr</span><span class="plain-syntax"> &lt;= </span><span class="character-syntax">'z'</span><span class="plain-syntax">)) </span><span class="identifier-syntax">nc</span><span class="plain-syntax"> = </span><span class="constant-syntax">2</span><span class="plain-syntax">;</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> ((</span><span class="identifier-syntax">lc</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">) &amp;&amp; (</span><span class="identifier-syntax">nc</span><span class="plain-syntax"> == </span><span class="constant-syntax">1</span><span class="plain-syntax">)) </span><span class="identifier-syntax">space</span><span class="plain-syntax"> = </span><span class="identifier-syntax">FALSE</span><span class="plain-syntax">;</span>
@@ -839,14 +839,13 @@ bucket.
 </p>
 
 <p class="commentary">The marbles are characters; transparent glass ones are whitespace, which
-will always now be <span class="extract"><span class="extract-syntax">' '</span></span>, <span class="extract"><span class="extract-syntax">'\t'</span></span> or <span class="extract"><span class="extract-syntax">'\n'</span></span>; the routine
+will always now be <span class="extract"><span class="extract-syntax">' '</span></span>, <span class="extract"><span class="extract-syntax">'\t'</span></span> or <span class="extract"><span class="extract-syntax">'\n'</span></span>; the routine <span class="extract"><span class="extract-syntax">Lexer::feed_triplet</span></span>
-<span class="extract"><span class="extract-syntax">Lexer::feed_triplet</span></span> above was the hopper; the routine
+above was the hopper; the routine <span class="extract"><span class="extract-syntax">Lexer::feed_char_into_lexer</span></span>, which occupies
-<span class="extract"><span class="extract-syntax">Lexer::feed_char_into_lexer</span></span>, which occupies the whole of the rest of this
+the whole of the rest of this section, is the mechanism which takes each marble
-section, is the mechanism which takes each marble in turn. (On occasion it
+in turn. (On occasion it calls itself recursively to cause extra characters of
-calls itself recursively to cause extra characters of its choice to drop
+its choice to drop in.) The batches are words, and the bucket receiving the
-in.) The batches are words, and the bucket receiving the surviving marbles
+surviving marbles is the sequence of characters starting at <span class="extract"><span class="extract-syntax">lexer_word</span></span> and
-is the sequence of characters starting at <span class="extract"><span class="extract-syntax">lexer_word</span></span> and extending to
+extending to <span class="extract"><span class="extract-syntax">lexer_hwm-1</span></span>.
-<span class="extract"><span class="extract-syntax">lexer_hwm-1</span></span>.
 </p>
 
 <pre class="displayed-code all-displayed-code code-font">
@@ -870,7 +869,7 @@ is the sequence of characters starting at <span class="extract"><span class="ext
 <span class="plain-syntax">    }</span>
 
 <span class="plain-syntax">    </span><span class="comment-syntax"> otherwise record the current character as part of the word being built</span>
-<span class="plain-syntax">    *(</span><span class="identifier-syntax">lexer_hwm</span><span class="plain-syntax">++) = </span><span class="identifier-syntax">c</span><span class="plain-syntax">;</span>
+<span class="plain-syntax">    *(</span><span class="identifier-syntax">lexer_hwm</span><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="plain-syntax">    </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">lxs_scanning_text_substitution</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">        </span><span class="named-paragraph-container code-font"><a href="3-lxr.html#SP28_9" class="named-paragraph-link"><span class="named-paragraph">Force string division at the end of a text substitution, if necessary</span><span class="named-paragraph-number">28.9</span></a></span><span class="plain-syntax">;</span>
@@ -1175,7 +1174,7 @@ finished.
 <span class="plain-syntax">        </span><span class="reserved-syntax">case</span><span class="plain-syntax"> </span><span class="identifier-syntax">STRING_KW:</span>
 <span class="plain-syntax">            </span><span class="reserved-syntax">if</span><span class="plain-syntax"> (</span><span class="identifier-syntax">c</span><span class="plain-syntax"> == </span><span class="constant-syntax">STRING_END</span><span class="plain-syntax">) {</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">lxs_string_soak_up_spaces_mode</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">lexer_hwm</span><span class="plain-syntax">++) = </span><span class="identifier-syntax">c</span><span class="plain-syntax">; </span><span class="comment-syntax"> record the </span><span class="extract"><span class="extract-syntax">STRING_END</span></span><span class="comment-syntax"> character as part of the word</span>
+<span class="plain-syntax">                *(</span><span class="identifier-syntax">lexer_hwm</span><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="comment-syntax"> record the </span><span class="extract"><span class="extract-syntax">STRING_END</span></span><span class="comment-syntax"> character as part of the word</span>
 <span class="plain-syntax">                </span><span class="identifier-syntax">lxs_literal_mode</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">break</span><span class="plain-syntax">;</span>

inbuild/supervisor-module/Chapter 4/Language Manager.w

@@ -80,7 +80,7 @@ void LanguageManager::claim_as_copy(inbuild_genre *gen, inbuild_copy **C,
 	text_stream *name = Pathnames::directory_name(P);
 	int acceptable = TRUE;
 	LOOP_THROUGH_TEXT(pos, name) {
-		int c = Str::get(pos);
+		wchar_t c = Str::get(pos);
 		if ((c < 32) || (c > 126)) acceptable = FALSE; /* contains non-ASCII */
 		if (Platform::is_folder_separator(c)) { Str::put(pos, 0); break; }
 	}

inbuild/supervisor-module/Chapter 5/Extension Services.w

@@ -389,7 +389,8 @@ range, we flatten them from general ISO to plain ASCII.
 		E->as_copy->edition->work->author_name);
 	LOOP_THROUGH_TEXT(pos, synopsis)
 		Str::put(pos,
-			Characters::make_filename_safe(Str::get(pos)));
+			Characters::make_wchar_t_filename_safe(
+				Str::get(pos)));
 
 @ Note that if there is an active project, then we are reading the extension
 in order to include it in that, and so we send it to the project's syntax tree,

indoc/Chapter 3/Examples Index.w

@@ -107,11 +107,11 @@ void ExamplesIndex::write_alphabetical_examples_index(void) {
 		ExamplesIndex::sort_comparison);
 
 	TEMPORARY_TEXT(current_subtitle)
-	int current_letter = -1;
+	wchar_t current_letter = 0;
 	int first_letter_block = TRUE;
 	for (int i=0; i<NUMBER_CREATED(example_index_data); i++) {
 		example_index_data *eid = eid_list[i];
-		int initial = Str::get_first_char(eid->sort_key);
+		wchar_t initial = Str::get_first_char(eid->sort_key);
 		if (Characters::isdigit(initial)) initial = '#';
 		if (initial != current_letter) @<Start a new letter block@>;
 		TEMPORARY_TEXT(url)
@@ -143,7 +143,7 @@ void ExamplesIndex::write_alphabetical_examples_index(void) {
 @<Start a new letter block@> =
 	current_letter = initial;
 	if (first_letter_block == FALSE) { HTML_TAG("br"); @<End a letter block@>; }
-	int uc_current_letter = Characters::toupper(current_letter);
+	wchar_t uc_current_letter = Characters::toupper(current_letter);
 	HTML_OPEN("tr");
 	HTML_OPEN_WITH("td", "class=\"letterblock\"");
 	TEMPORARY_TEXT(inc)

indoc/Chapter 3/General Index.w

@@ -508,10 +508,10 @@ int Indexes::sort_comparison(const void *ent1, const void *ent2) {
 @<Render the index in sorted order@> =
 	IndexUtilities::alphabet_row(OUT, 1);
 	HTML_OPEN_WITH("table", "class=\"indextable\"");
-	int current_incipit = 0;
+	wchar_t current_incipit = 0;
 	for (int i=0; i<NUMBER_CREATED(index_lemma); i++) {
 		index_lemma *il = lemma_list[i];
-		int incipit = Str::get_first_char(il->sorting_key);
+		wchar_t incipit = Str::get_first_char(il->sorting_key);
 		if (Characters::isalpha(incipit)) incipit = Characters::toupper(incipit);
 		else incipit = '#';
 		if (incipit != current_incipit) {

indoc/Chapter 3/Indexing Utilities.w

@@ -77,7 +77,7 @@ void IndexUtilities::improve_alphabetisation(text_stream *sort_key) {
 		Regexp::replace(sort_key, L"an ", NULL, REP_ATSTART);
 		Regexp::replace(sort_key, L"the ", NULL, REP_ATSTART);
 		LOOP_THROUGH_TEXT(pos, sort_key)
-			Str::put(pos, Characters::tolower(Characters::remove_accent(Str::get(pos))));
+			Str::put(pos, Characters::tolower(Characters::remove_wchar_t_accent(Str::get(pos))));
 		Regexp::replace(sort_key, L"%[ *%]", L"____SQUARES____", REP_REPEATING);
 		Regexp::replace(sort_key, L"%[", NULL, REP_REPEATING);
 		Regexp::replace(sort_key, L"%]", NULL, REP_REPEATING);
@@ -112,8 +112,8 @@ void IndexUtilities::improve_alphabetisation(text_stream *sort_key) {
 
 @ =
 int letters_taken[26];
-void IndexUtilities::note_letter(int c) {
+void IndexUtilities::note_letter(wchar_t c) {
-	int i = c - 'A';
+	int i = c - (wchar_t) 'A';
 	if ((i>=0) && (i<26)) letters_taken[i] = TRUE;
 }
 void IndexUtilities::alphabet_row(OUTPUT_STREAM, int sequence) {

inform7/Figures/timings-diagnostics.txt

@@ -1,36 +1,44 @@
 100.0% in inform7 run
-     68.6% in compilation to Inter
+     68.0% in compilation to Inter
-         28.1% in //Phrases::Manager::compile_first_block//
+         27.0% in //Phrases::Manager::compile_first_block//
-          9.3% in //Phrases::Manager::compile_as_needed//
+          8.8% in //Phrases::Manager::compile_as_needed//
-          6.8% in //Strings::compile_responses//
+          7.0% in //Strings::compile_responses//
-          5.7% in //World::Compile::compile//
+          6.3% in //World::Compile::compile//
-          3.5% in //Sentences::VPs::traverse//
+          3.6% in //Sentences::VPs::traverse//
-          3.2% in //Assertions::Traverse::traverse1//
+          3.3% in //Assertions::Traverse::traverse1//
-          1.9% in //Phrases::Manager::RulePrintingRule_routine//
+          2.0% in //Phrases::Manager::RulePrintingRule_routine//
-          1.7% in //Phrases::Manager::rulebooks_array//
+          1.9% in //Phrases::Manager::rulebooks_array//
-          1.0% in //NewVerbs::ConjugateVerb//
+          0.9% in //NewVerbs::ConjugateVerb//
-          0.7% in //Phrases::Manager::traverse//
+          0.8% in //Phrases::Manager::traverse//
           0.5% in //Phrases::Manager::parse_rule_parameters//
           0.3% in //Phrases::Manager::compile_rulebooks//
           0.3% in //Phrases::Manager::traverse_for_names//
           0.3% in //Relations::compile_defined_relations//
-          0.1% in //Assertions::Traverse::traverse2//
+          0.2% in //Assertions::Traverse::traverse2//
+          0.2% in //Task::load_types//
+          0.2% in //World::complete//
+          0.1% in //Emit::begin//
+          0.1% in //Index::DocReferences::read_xrefs//
+          0.1% in //Kinds::Knowledge::include_templates_for_kinds//
           0.1% in //PL::Parsing::Verbs::compile_all//
+          0.1% in //PL::Parsing::traverse//
+          0.1% in //Phrases::Manager::add_rules_to_rulebooks//
+          0.1% in //Sentences::Rearrangement::tidy_up_ofs_and_froms//
           0.1% in //Sentences::RuleSubtrees::register_recently_lexed_phrases//
-          0.1% in //Task::load_types//
+          0.1% in //World::complete_additions//
-          0.1% in //World::complete//
+          2.8% not specifically accounted for
-          3.8% not specifically accounted for
+     29.7% in running Inter pipeline
-     29.2% in running Inter pipeline
+         10.2% in step preparation
-          9.4% in inter step 2/12: link
+          9.8% in inter step 2/12: link
-          9.4% in step preparation
+          6.9% in inter step 12/12: generate inform6 -> auto.inf
-          6.8% in inter step 12/12: generate inform6 -> auto.inf
+          0.3% in inter step 10/12: reconcile-verbs
           0.3% in inter step 9/12: make-identifiers-unique
-          0.1% in inter step 10/12: reconcile-verbs
+          0.2% in inter step 11/12: eliminate-redundant-labels
-          0.1% in inter step 11/12: eliminate-redundant-labels
+          0.2% in inter step 6/12: assimilate
+          0.2% in inter step 7/12: resolve-external-symbols
+          0.1% in inter step 4/12: parse-linked-matter
           0.1% in inter step 5/12: resolve-conditional-compilation
-          0.1% in inter step 6/12: assimilate
-          0.1% in inter step 7/12: resolve-external-symbols
           0.1% in inter step 8/12: inspect-plugs
-          2.0% not specifically accounted for
+          1.1% not specifically accounted for
-      1.9% in supervisor
+      2.0% in supervisor
       0.2% not specifically accounted for

inform7/core-module/Chapter 26/Compiled Text.w

@@ -303,7 +303,7 @@ exceptional case.
 
 =
 int CompiledText::alphabetic(int letter) {
-	return isalpha(Characters::remove_accent(letter));
+	return Characters::isalpha((wchar_t) Characters::remove_accent(letter));
 }
 
 @ This looks for "[unicode 8212]" and turns it into an em-dash, for example.

inter/building-module/Chapter 2/Inter Schemas.w

@@ -1090,7 +1090,7 @@ scanned through since the last time.
 	int L = Str::len(current_raw);
 	int c_start = 0, escaped = FALSE;
 	for (int p = 0; p < L; p++) {
-		int c1 = Str::get_at(current_raw, p), c2 = 0, c3 = 0;
+		wchar_t c1 = Str::get_at(current_raw, p), c2 = 0, c3 = 0;
 		if (p < L-1) c2 = Str::get_at(current_raw, p+1);
 		if (p < L-2) c3 = Str::get_at(current_raw, p+2);
 
@@ -1272,7 +1272,7 @@ inclusive; we ignore an empty token.
 	if ((Str::get_at(T, 0) == '#') && (Str::get_at(T, 1) == '#') && (Characters::isalpha(Str::get_at(T, 2)))) {
 		is = IDENTIFIER_ISTT;
 		LOOP_THROUGH_TEXT(P, T) {
-			int c = Str::get(P);
+			wchar_t c = Str::get(P);
 			if ((c != '_') && (c != '#') && (!Characters::isalnum(c)))
 				is = RAW_ISTT;
 		}
@@ -1280,7 +1280,7 @@ inclusive; we ignore an empty token.
 	if ((Str::get_at(T, 0) == '#') && (Characters::isalpha(Str::get_at(T, 1)))) {
 		is = IDENTIFIER_ISTT;
 		LOOP_THROUGH_TEXT(P, T) {
-			int c = Str::get(P);
+			wchar_t c = Str::get(P);
 			if ((c != '_') && (c != '#') && (c != '$') && (!Characters::isalnum(c)))
 				is = RAW_ISTT;
 		}
@@ -1288,7 +1288,7 @@ inclusive; we ignore an empty token.
 	if ((Str::get_at(T, 0) == '_') && (Characters::isalpha(Str::get_at(T, 1)))) {
 		is = IDENTIFIER_ISTT;
 		LOOP_THROUGH_TEXT(P, T) {
-			int c = Str::get(P);
+			wchar_t c = Str::get(P);
 			if ((c != '_') && (c != '#') && (!Characters::isalnum(c)))
 				is = RAW_ISTT;
 		}
@@ -1296,7 +1296,7 @@ inclusive; we ignore an empty token.
 	if (Characters::isalpha(Str::get_at(T, 0))) {
 		is = IDENTIFIER_ISTT;
 		LOOP_THROUGH_TEXT(P, T) {
-			int c = Str::get(P);
+			wchar_t c = Str::get(P);
 			if ((c != '_') && (!Characters::isalnum(c)))
 				is = RAW_ISTT;
 		}
@@ -1308,7 +1308,7 @@ inclusive; we ignore an empty token.
 	if (Characters::isdigit(Str::get_at(T, 0))) {
 		is = NUMBER_ISTT;
 		LOOP_THROUGH_TEXT(P, T) {
-			int c = Str::get(P);
+			wchar_t c = Str::get(P);
 			if (!Characters::isdigit(c))
 				is = RAW_ISTT;
 		}

services/inflections-module/Chapter 3/Verb Conjugation.w

@@ -735,7 +735,7 @@ and we construe "y" (but not "h" or "w") as a vowel.
 
 @<Decide whether a contraction is needed here@> =
 	int incipit = q[0];
-	int first = tolower(Characters::remove_accent(incipit));
+	int first = Characters::tolower((wchar_t) Characters::remove_accent(incipit));
 	if ((first == 'a') || (first == 'e') || (first == 'i') ||
 		(first == 'o') || (first == 'u') || (first == 'y'))
 		contract_this = TRUE;

services/problems-module/Chapter 2/Problems, Level 2.w

@@ -369,7 +369,7 @@ on when the shortened form is the one being issued).
 			case 'P': PUT_TO(PBUFF, FORCE_NEW_PARA_CHAR); i++; continue;
 			case '%': PUT_TO(PBUFF, '%'); i++; continue;
 		}
-		if (Characters::isdigit(message[i+1])) {
+		if (Characters::isdigit((wchar_t) message[i+1])) {
 			int t = ((int) (message[i+1]))-((int) '0'); i++;
 			if ((t>=1) && (t<=9)) {
 				if (problem_quotations[t].wording_based)

services/words-module/Chapter 3/Lexer.w

@@ -688,9 +688,9 @@ void Lexer::feed_triplet(int last_cr, int cr, int next_cr) {
 		if ((space) && (next_cr == '/')) space = FALSE;
 		if (space) {
 			int lc = 0, nc = 0;
-			if (Characters::isdigit(last_cr)) lc = 1;
+			if (Characters::isdigit((wchar_t) last_cr)) lc = 1;
 			if ((last_cr >= 'a') && (last_cr <= 'z')) lc = 2;
-			if (Characters::isdigit(next_cr)) nc = 1;
+			if (Characters::isdigit((wchar_t) next_cr)) nc = 1;
 			if (next_cr == '-') nc = 1;
 			if ((next_cr >= 'a') && (next_cr <= 'z')) nc = 2;
 			if ((lc == 1) && (nc == 1)) space = FALSE;
@@ -726,14 +726,13 @@ has completed one batch, and moves on to dropping marbles into the next
 bucket.
 
 The marbles are characters; transparent glass ones are whitespace, which
-will always now be |' '|, |'\t'| or |'\n'|; the routine
+will always now be |' '|, |'\t'| or |'\n'|; the routine |Lexer::feed_triplet|
-|Lexer::feed_triplet| above was the hopper; the routine
+above was the hopper; the routine |Lexer::feed_char_into_lexer|, which occupies
-|Lexer::feed_char_into_lexer|, which occupies the whole of the rest of this
+the whole of the rest of this section, is the mechanism which takes each marble
-section, is the mechanism which takes each marble in turn. (On occasion it
+in turn. (On occasion it calls itself recursively to cause extra characters of
-calls itself recursively to cause extra characters of its choice to drop
+its choice to drop in.) The batches are words, and the bucket receiving the
-in.) The batches are words, and the bucket receiving the surviving marbles
+surviving marbles is the sequence of characters starting at |lexer_word| and
-is the sequence of characters starting at |lexer_word| and extending to
+extending to |lexer_hwm-1|.
-|lexer_hwm-1|.
 
 =
 void Lexer::feed_char_into_lexer(int c) {
@@ -756,7 +755,7 @@ void Lexer::feed_char_into_lexer(int c) {
 	}
 
     /* otherwise record the current character as part of the word being built */
-	*(lexer_hwm++) = c;
+	*(lexer_hwm++) = (wchar_t) c;
 
     if (lxs_scanning_text_substitution) {
         @<Force string division at the end of a text substitution, if necessary@>;
@@ -1009,7 +1008,7 @@ finished.
         case STRING_KW:
             if (c == STRING_END) {
                 lxs_string_soak_up_spaces_mode = FALSE;
-                *(lexer_hwm++) = c; /* record the |STRING_END| character as part of the word */
+                *(lexer_hwm++) = (wchar_t) c; /* record the |STRING_END| character as part of the word */
                 lxs_literal_mode = FALSE;
             }
             break;