(selection_data_to_lisp_data): Convert Fmake_vector

[gnu-emacs] / src / casefiddle.c

diff --git a/src/casefiddle.c b/src/casefiddle.c
index b0cc0b94991e1a3212ea9f757e2a0c0532ba3263..dfa2981eb04c9790600313c75ebbe15fce02f671 100644 (file)
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -22,10 +22,13 @@ Boston, MA 02111-1307, USA.  */
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
+#include "charset.h"
 #include "commands.h"
 #include "syntax.h"
 
 enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP};
+
+Lisp_Object Qidentity;
 \f
 Lisp_Object
 casify_object (flag, obj)
@@ -34,6 +37,7 @@ casify_object (flag, obj)
 {
   register int i, c, len;
   register int inword = flag == CASE_DOWN;
+  Lisp_Object tem;
 
   /* If the case table is flagged as modified, rescan it.  */
   if (NILP (XCHAR_TABLE (current_buffer->downcase_table)->extras[1]))
@@ -43,23 +47,29 @@ casify_object (flag, obj)
     {
       if (INTEGERP (obj))
        {
-         c = XINT (obj);
-         if (c >= 0 && c <= 0400)
+         c = DOWNCASE (XFASTINT (obj));
+         if (inword)
+           XSETFASTINT (obj, c);
+         else if (c == XFASTINT (obj))
            {
-             if (inword)
-               XSETFASTINT (obj, DOWNCASE (c));
-             else if (!UPPERCASEP (c))
-               XSETFASTINT (obj, UPCASE1 (c));
+             c = UPCASE1 (XFASTINT (obj));
+             XSETFASTINT (obj, c);
            }
          return obj;
        }
       if (STRINGP (obj))
        {
+         int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+
          obj = Fcopy_sequence (obj);
          len = XSTRING (obj)->size;
          for (i = 0; i < len; i++)
            {
              c = XSTRING (obj)->data[i];
+             if (multibyte && c >= 0x80)
+               /* A multibyte character can't be handled in this
+                   simple loop.  */
+               break;
              if (inword && flag != CASE_CAPITALIZE_UP)
                c = DOWNCASE (c);
              else if (!UPPERCASEP (c)
@@ -69,6 +79,37 @@ casify_object (flag, obj)
              if ((int) flag >= (int) CASE_CAPITALIZE)
                inword = SYNTAX (c) == Sword;
            }
+         if (i < len)
+           {
+             /* The work is not yet finished because of a multibyte
+                character just encountered.  */
+             int fromlen, tolen, j = i;
+             char *buf
+               = (char *) alloca ((len - i) * MAX_LENGTH_OF_MULTI_BYTE_FORM
+                                  + i);
+             char *str, workbuf[4];
+
+             /* Copy data already handled.  */
+             bcopy (XSTRING (obj)->data, buf, i);
+
+             while (i < len)
+               {
+                 c = STRING_CHAR_AND_LENGTH (XSTRING (obj)->data + 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);
+                 tolen = CHAR_STRING (c, workbuf, str);
+                 bcopy (str, buf + j, tolen);
+                 i += fromlen;
+                 j += tolen;
+                 if ((int) flag >= (int) CASE_CAPITALIZE)
+                   inword = SYNTAX (c) == Sword;
+               }
+             obj = make_string (buf, j);
+           }
          return obj;
        }
       obj = wrong_type_argument (Qchar_or_string_p, obj);
@@ -131,7 +172,9 @@ casify_region (flag, 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;
+  Lisp_Object ch, downch, val;
 
   if (EQ (b, e))
     /* Not modifying because nothing marked */
@@ -150,6 +193,9 @@ casify_region (flag, b, e)
   for (i = start; i < end; i++)
     {
       c = FETCH_BYTE (i);
+      if (multibyte && c >= 0x80)
+       /* A multibyte character can't be handled in this simple loop.  */
+       break;
       if (inword && flag != CASE_CAPITALIZE_UP)
        c = DOWNCASE (c);
       else if (!UPPERCASEP (c)
@@ -159,6 +205,57 @@ casify_region (flag, b, e)
       if ((int) flag >= (int) CASE_CAPITALIZE)
        inword = SYNTAX (c) == Sword;
     }
+  if (i < end)
+    {
+      /* The work is not yet finished because of a multibyte character
+        just encountered.  */
+      int opoint = PT, c2;
+
+      while (i < end)
+       {
+         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)
+           {
+             int fromlen, tolen, j;
+             char workbuf[4], *str;
+
+             /* Handle the most likely case */
+             if (c < 0400 && c2 < 0400)
+               FETCH_BYTE (i) = c2;
+             else if (fromlen = CHAR_STRING (c, workbuf, str),
+                      tolen = CHAR_STRING (c2, workbuf, str),
+                      fromlen == tolen)
+               {
+                 for (j = 0; j < tolen; ++j)
+                   FETCH_BYTE (i + j) = str[j];
+               }
+             else
+               {
+                 error ("Can't casify letters that change length");
+#if 0 /* This is approximately what we'd like to be able to do here */
+                 if (tolen < fromlen)
+                   del_range_1 (i + tolen, i + fromlen, 0);
+                 else if (tolen > fromlen)
+                   {
+                     TEMP_SET_PT (i + fromlen);
+                     insert_1 (str + fromlen, tolen - fromlen, 1, 0);
+                   }
+#endif
+               }
+           }
+         if ((int) flag >= (int) CASE_CAPITALIZE)
+           inword = SYNTAX (c2) == Sword;
+         INC_POS (i);
+       }
+      TEMP_SET_PT (opoint);
+    }
 
   signal_after_change (start, end - start, end - start);
 }
@@ -287,6 +384,8 @@ With negative argument, capitalize previous words but do not move.")
 \f
 syms_of_casefiddle ()
 {
+  Qidentity = intern ("identity");
+  staticpro (&Qidentity);
   defsubr (&Supcase);
   defsubr (&Sdowncase);
   defsubr (&Scapitalize);