3 files changed, 31 insertions, 32 deletions

diff --git a/src/buffer.h b/src/buffer.h
index 4a23e4fdd2e..f53212e3120 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1365,28 +1365,28 @@ downcase (int c)
   return NATNUMP (down) ? XFASTINT (down) : c;
 }
 
-/* True if C is upper case.  */
-INLINE bool uppercasep (int c) { return downcase (c) != c; }
-
-/* Upcase a character C known to be not upper case.  */
+/* Upcase a character C, or make no change if that cannot be done. */
 INLINE int
-upcase1 (int c)
+upcase (int c)
 {
   Lisp_Object upcase_table = BVAR (current_buffer, upcase_table);
   Lisp_Object up = CHAR_TABLE_REF (upcase_table, c);
   return NATNUMP (up) ? XFASTINT (up) : c;
 }
 
+/* True if C is upper case.  */
+INLINE bool uppercasep (int c)
+{
+  return downcase (c) != c;
+}
+
 /* True if C is lower case.  */
 INLINE bool
 lowercasep (int c)
 {
-  return !uppercasep (c) && upcase1 (c) != c;
+  return !uppercasep (c) && upcase (c) != c;
 }
 
-/* Upcase a character C, or make no change if that cannot be done.  */
-INLINE int upcase (int c) { return uppercasep (c) ? c : upcase1 (c); }
-
 INLINE_HEADER_END
 
 #endif /* EMACS_BUFFER_H */
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 28ffcb298ff..b2b87e7a858 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -64,13 +64,9 @@ casify_object (enum case_action flag, Lisp_Object obj)
         multibyte = 1;
       if (! multibyte)
         MAKE_CHAR_MULTIBYTE (c1);
-      c = downcase (c1);
-      if (inword)
-        XSETFASTINT (obj, c | flags);
-      else if (c == (XFASTINT (obj) & ~flagbits))
+      c = flag == CASE_DOWN ? downcase (c1) : upcase (c1);
+      if (c != c1)
         {
-          if (! inword)
-            c = upcase1 (c1);
           if (! multibyte)
             MAKE_CHAR_UNIBYTE (c);
           XSETFASTINT (obj, c | flags);
@@ -95,7 +91,7 @@ casify_object (enum case_action flag, Lisp_Object obj)
             c = downcase (c);
           else if (!uppercasep (c)
                    && (!inword || flag != CASE_CAPITALIZE_UP))
-            c = upcase1 (c1);
+            c = upcase (c1);
           if ((int) flag >= (int) CASE_CAPITALIZE)
             inword = (SYNTAX (c) == Sword);
           if (c != c1)
@@ -127,9 +123,8 @@ casify_object (enum case_action flag, Lisp_Object obj)
           c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len);
           if (inword && flag != CASE_CAPITALIZE_UP)
             c = downcase (c);
-          else if (!uppercasep (c)
-                   && (!inword || flag != CASE_CAPITALIZE_UP))
-            c = upcase1 (c);
+          else if (!inword || flag != CASE_CAPITALIZE_UP)
+            c = upcase (c);
           if ((int) flag >= (int) CASE_CAPITALIZE)
             inword = (SYNTAX (c) == Sword);
           o += CHAR_STRING (c, o);
@@ -236,9 +231,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
       c2 = c;
       if (inword && flag != CASE_CAPITALIZE_UP)
         c = downcase (c);
-      else if (!uppercasep (c)
-               && (!inword || flag != CASE_CAPITALIZE_UP))
-        c = upcase1 (c);
+      else if (!inword || flag != CASE_CAPITALIZE_UP)
+        c = upcase (c);
       if ((int) flag >= (int) CASE_CAPITALIZE)
         inword = ((SYNTAX (c) == Sword)
                   && (inword || !syntax_prefix_flag_p (c)));
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)
             {