1 files changed, 87 insertions, 114 deletions

diff --git a/src/casefiddle.c b/src/casefiddle.c
index ae4888088bd..297eb82c15b 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -23,7 +23,7 @@ Boston, MA 02111-1307, USA.  */
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
-#include "charset.h"
+#include "character.h"
 #include "commands.h"
 #include "syntax.h"
 #include "composite.h"
@@ -38,7 +38,7 @@ casify_object (flag, obj)
      enum case_action flag;
      Lisp_Object obj;
 {
-  register int i, c, len;
+  register int c, c1;
   register int inword = flag == CASE_DOWN;
 
   /* If the case table is flagged as modified, rescan it.  */
@@ -52,6 +52,7 @@ casify_object (flag, obj)
 	  int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
 			  | CHAR_SHIFT | CHAR_CTL | CHAR_META);
 	  int flags = XINT (obj) & flagbits;
+	  int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
 
 	  /* If the character has higher bits set
 	     above the flags, return it unchanged.
@@ -59,12 +60,18 @@ casify_object (flag, obj)
 	  if ((unsigned) XFASTINT (obj) > (unsigned) flagbits)
 	    return obj;
 
-	  c = DOWNCASE (XFASTINT (obj) & ~flagbits);
+	  c1 = XFASTINT (obj) & ~flagbits;
+	  if (! multibyte)
+	    MAKE_CHAR_MULTIBYTE (c1);
+	  c = DOWNCASE (c1);
 	  if (inword)
 	    XSETFASTINT (obj, c | flags);
 	  else if (c == (XFASTINT (obj) & ~flagbits))
 	    {
-	      c = UPCASE1 ((XFASTINT (obj) & ~flagbits));
+	      if (! inword)
+		c = UPCASE1 (c1);
+	      if (! multibyte)
+		MAKE_CHAR_UNIBYTE (c);
 	      XSETFASTINT (obj, c | flags);
 	    }
 	  return obj;
@@ -73,71 +80,43 @@ casify_object (flag, obj)
       if (STRINGP (obj))
 	{
 	  int multibyte = STRING_MULTIBYTE (obj);
+	  int i, i_byte, len;
+	  int size = SCHARS (obj);
 
 	  obj = Fcopy_sequence (obj);
-	  len = SBYTES (obj);
-
-	  /* Scan all single-byte characters from start of string.  */
-	  for (i = 0; i < len;)
+	  for (i = i_byte = 0; i < size; i++, i_byte += len)
 	    {
-	      c = SREF (obj, i);
-
-	      if (multibyte && c >= 0x80)
-		/* A multibyte character can't be handled in this
-                   simple loop.  */
-		break;
+	      if (multibyte)
+		c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, 0, len);
+	      else
+		{
+		  c = SREF (obj, i_byte);
+		  len = 1;
+		  MAKE_CHAR_MULTIBYTE (c);
+		}
+	      c1 = c;
 	      if (inword && flag != CASE_CAPITALIZE_UP)
 		c = DOWNCASE (c);
 	      else if (!UPPERCASEP (c)
 		       && (!inword || flag != CASE_CAPITALIZE_UP))
-		c = UPCASE1 (c);
-	      /* If this char won't fit in a single-byte string.
-		 fall out to the multibyte case.  */
-	      if (multibyte ? ! ASCII_BYTE_P (c)
-		  : ! SINGLE_BYTE_CHAR_P (c))
-		break;
-
-	      SSET (obj, i, c);
+		c = UPCASE1 (c1);
 	      if ((int) flag >= (int) CASE_CAPITALIZE)
-		inword = SYNTAX (c) == Sword;
-	      i++;
-	    }
-
-	  /* If we didn't do the whole string as single-byte,
-	     scan the rest in a more complex way.  */
-	  if (i < len)
-	    {
-	      /* The work is not yet finished because of a multibyte
-		 character just encountered.  */
-	      int fromlen, j_byte = i;
-	      char *buf;
-	      int bufsize;
-	      USE_SAFE_ALLOCA;
-
-	      bufsize = (len - i) * MAX_MULTIBYTE_LENGTH + i;
-	      SAFE_ALLOCA (buf, char *, bufsize);
-
-	      /* Copy data already handled.  */
-	      bcopy (SDATA (obj), buf, i);
-
-	      /* From now on, I counts bytes.  */
-	      while (i < len)
+		inword = (SYNTAX (c) == Sword);
+	      if (c != c1)
 		{
-		  c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i,
-					      len - i, fromlen);
-		  if (inword && flag != CASE_CAPITALIZE_UP)
-		    c = DOWNCASE (c);
-		  else if (!UPPERCASEP (c)
-			   && (!inword || flag != CASE_CAPITALIZE_UP))
-		    c = UPCASE1 (c);
-		  i += fromlen;
-		  j_byte += CHAR_STRING (c, buf + j_byte);
-		  if ((int) flag >= (int) CASE_CAPITALIZE)
-		    inword = SYNTAX (c) == Sword;
+		  if (! multibyte)
+		    {
+		      MAKE_CHAR_UNIBYTE (c);
+		      SSET (obj, i_byte, c);
+		    }
+		  else if (ASCII_CHAR_P (c1) && ASCII_CHAR_P (c))
+		    SSET (obj, i_byte,  c);
+		  else
+		    {
+		      Faset (obj, make_number (i), make_number (c));
+		      i_byte += CHAR_BYTES (c) - len;
+		    }
 		}
-	      obj = make_multibyte_string (buf, SCHARS (obj),
-					   j_byte);
-	      SAFE_FREE ();
 	    }
 	  return obj;
 	}
@@ -199,13 +178,14 @@ casify_region (flag, b, e)
      enum case_action flag;
      Lisp_Object b, e;
 {
-  register int i;
   register int c;
   register int inword = flag == CASE_DOWN;
   register int multibyte = !NILP (current_buffer->enable_multibyte_characters);
   int start, end;
   int start_byte, end_byte;
   int changed = 0;
+  int opoint = PT;
+  int opoint_byte = PT_BYTE;
 
   if (EQ (b, e))
     /* Not modifying because nothing marked */
@@ -223,81 +203,74 @@ casify_region (flag, b, e)
   start_byte = CHAR_TO_BYTE (start);
   end_byte = CHAR_TO_BYTE (end);
 
-  for (i = start_byte; i < end_byte; i++, start++)
+  while (start < end)
     {
-      int c2;
-      c = c2 = FETCH_BYTE (i);
-      if (multibyte && c >= 0x80)
-	/* A multibyte character can't be handled in this simple loop.  */
-	break;
+      int c2, len;
+
+      if (multibyte)
+	{
+	  c = FETCH_MULTIBYTE_CHAR (start_byte);
+	  len = CHAR_BYTES (c);
+	}
+      else
+	{
+	  c = FETCH_BYTE (start_byte);
+	  MAKE_CHAR_MULTIBYTE (c);
+	  len = 1;
+	}
+      c2 = c;
       if (inword && flag != CASE_CAPITALIZE_UP)
 	c = DOWNCASE (c);
       else if (!UPPERCASEP (c)
 	       && (!inword || flag != CASE_CAPITALIZE_UP))
 	c = UPCASE1 (c);
-      if (multibyte && c >= 0x80)
-	/* A multibyte result character can't be handled in this
-	   simple loop.  */
-	break;
-      FETCH_BYTE (i) = c;
-      if (c != c2)
-	changed = 1;
       if ((int) flag >= (int) CASE_CAPITALIZE)
-	inword = SYNTAX (c) == Sword && (inword || !SYNTAX_PREFIX (c));
-    }
-  if (i < end_byte)
-    {
-      /* The work is not yet finished because of a multibyte character
-	 just encountered.  */
-      int opoint = PT;
-      int opoint_byte = PT_BYTE;
-      int c2;
-
-      while (i < end_byte)
+	inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c)));
+      if (c != c2)
 	{
-	  if ((c = FETCH_BYTE (i)) >= 0x80)
-	    c = FETCH_MULTIBYTE_CHAR (i);
-	  c2 = c;
-	  if (inword && flag != CASE_CAPITALIZE_UP)
-	    c2 = DOWNCASE (c);
-	  else if (!UPPERCASEP (c)
-		   && (!inword || flag != CASE_CAPITALIZE_UP))
-	    c2 = UPCASE1 (c);
-	  if (c != c2)
+	  changed = 1;
+	  if (! multibyte)
 	    {
-	      int fromlen, tolen, j;
+	      MAKE_CHAR_UNIBYTE (c);
+	      FETCH_BYTE (start_byte) = c;
+	    }
+	  else if (ASCII_CHAR_P (c2) && ASCII_CHAR_P (c))
+	    FETCH_BYTE (start_byte) = c;
+	  else
+	    {
+	      int tolen = CHAR_BYTES (c);
+	      int j;
 	      unsigned char str[MAX_MULTIBYTE_LENGTH];
 
-	      changed = 1;
-	      /* Handle the most likely case */
-	      if (c < 0400 && c2 < 0400)
-		FETCH_BYTE (i) = c2;
-	      else if (fromlen = CHAR_STRING (c, str),
-		       tolen = CHAR_STRING (c2, str),
-		       fromlen == tolen)
+	      CHAR_STRING (c, str);
+	      if (len == tolen)
 		{
 		  /* Length is unchanged.  */
-		  for (j = 0; j < tolen; ++j)
-		    FETCH_BYTE (i + j) = str[j];
+		  for (j = 0; j < len; ++j)
+		    FETCH_BYTE (start_byte + j) = str[j];
 		}
 	      else
-		/* Replace one character with the other,
-		   keeping text properties the same.  */
-		replace_range_2 (start + 1, i + tolen,
-				 start + 2, i + tolen + fromlen,
-				 str, 1, tolen,
-				 0);
+		{
+		  /* Replace one character with the other,
+		     keeping text properties the same.  */
+		  replace_range_2 (start, start_byte,
+				   start + 1, start_byte + len,
+				   str, 1, tolen,
+				   0);
+		  len = tolen;
+		}
 	    }
-	  if ((int) flag >= (int) CASE_CAPITALIZE)
-	    inword = SYNTAX (c2) == Sword;
-	  INC_BOTH (start, i);
 	}
-      TEMP_SET_PT_BOTH (opoint, opoint_byte);
+      start++;
+      start_byte += len;
     }
 
-  start = XFASTINT (b);
+  if (PT != opoint)
+    TEMP_SET_PT_BOTH (opoint, opoint_byte);
+
   if (changed)
     {
+      start = XFASTINT (b);
       signal_after_change (start, end - start, end - start);
       update_compositions (start, end, CHECK_ALL);
     }