casing: don’t assume letters are *either* upper- or lower-case (bug#24603)

A compatibility digraph characters, such as Dž, are neither upper- nor
lower-case.  At the moment however, those are reported as upper-case¹
despite the fact that they change when upper-cased.

Stop checking if a character is upper-case before trying to up-case it
so that title-case characters are handled correctly.  This fixes one of
the issues mentioned in bug#24603.

¹ Because they change when converted to lower-case.  Notice an asymmetry
  in that for a character to be considered lower-case it must not be
  upper-case (plus the usual condition of changing when upper-cased).

* src/buffer.h (upcase1): Delete.
(upcase): Change to upcase character unconditionally just like downcase
does it.  This is what upcase1 was.

* src/casefiddle.c (casify_object, casify_region): Use upcase instead
of upcase1 and don’t check !uppercasep(x) before calling upcase.

* src/keyboard.c (read_key_sequence): Don’t check if uppercase(x), just
downcase(x) and see if it changed.

* test/src/casefiddle-tests.el (casefiddle-tests--characters,
casefiddle-tests-casing): Update test cases which are now passing.

1 files changed, 15 insertions, 10 deletions

diff --git a/src/keyboard.c b/src/keyboard.c
index ed8e71fd0a7..0fad633581d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -9642,22 +9642,26 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          use the corresponding lower-case letter instead.  */
       if (NILP (current_binding)
           && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
-          && INTEGERP (key)
-          && ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
-               && uppercasep (XINT (key) & ~CHAR_MODIFIER_MASK))
-              || (XINT (key) & shift_modifier)))
+          && INTEGERP (key))
         {
           Lisp_Object new_key;
+          int k = XINT (key);
+
+          if (k & shift_modifier)
+            XSETINT (new_key, k & ~shift_modifier);
+          else if (CHARACTERP (make_number (k & ~CHAR_MODIFIER_MASK)))
+            {
+              int dc = downcase(k & ~CHAR_MODIFIER_MASK);
+              if (dc == (k & ~CHAR_MODIFIER_MASK))
+                goto not_upcase;
+              XSETINT (new_key, dc | (k & CHAR_MODIFIER_MASK));
+            }
+          else
+            goto not_upcase;
 
           original_uppercase = key;
           original_uppercase_position = t - 1;
 
-          if (XINT (key) & shift_modifier)
-            XSETINT (new_key, XINT (key) & ~shift_modifier);
-          else
-            XSETINT (new_key, (downcase (XINT (key) & ~CHAR_MODIFIER_MASK)
-                               | (XINT (key) & CHAR_MODIFIER_MASK)));
-
           /* We have to do this unconditionally, regardless of whether
              the lower-case char is defined in the keymaps, because they
              might get translated through function-key-map.  */
@@ -9668,6 +9672,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           goto replay_sequence;
         }
 
+    not_upcase:
       if (NILP (current_binding)
           && help_char_p (EVENT_HEAD (key)) && t > 1)
             {