Merge from trunk

1 files changed, 53 insertions, 91 deletions

diff --git a/src/cmds.c b/src/cmds.c
index 4cb6ca199e7..f12e759b7a6 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -32,17 +32,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "dispextern.h"
 #include "frame.h"
 
-Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
+Lisp_Object Qkill_forward_chars, Qkill_backward_chars;
 
 /* A possible value for a buffer's overwrite-mode variable.  */
 Lisp_Object Qoverwrite_mode_binary;
 
-/* Non-nil means put this face on the next self-inserting character.  */
-Lisp_Object Vself_insert_face;
-
-/* This is the command that set up Vself_insert_face.  */
-Lisp_Object Vself_insert_face_command;
-
 static int internal_self_insert (int, int);
 
 DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
@@ -310,50 +304,31 @@ After insertion, the value of `auto-fill-function' is called if the
   {
     int character = translate_char (Vtranslation_table_for_input,
                                     XINT (last_command_event));
-    if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
-      {
-        XSETFASTINT (n, XFASTINT (n) - 2);
-        /* The first one might want to expand an abbrev.  */
-        internal_self_insert (character, 1);
-        /* The bulk of the copies of this char can be inserted simply.
-           We don't have to handle a user-specified face specially
-           because it will get inherited from the first char inserted.  */
-        Finsert_char (make_number (character), n, Qt);
-        /* The last one might want to auto-fill.  */
-        internal_self_insert (character, 0);
-      }
-    else
-      while (XINT (n) > 0)
-        {
-          int val;
-          /* Ok since old and new vals both nonneg */
-          XSETFASTINT (n, XFASTINT (n) - 1);
-          val = internal_self_insert (character, XFASTINT (n) != 0);
-          if (val == 2)
-            nonundocount = 0;
-          frame_make_pointer_invisible ();
-        }
+    int val = internal_self_insert (character, XFASTINT (n));
+    if (val == 2)
+      nonundocount = 0;
+    frame_make_pointer_invisible ();
   }
 
   return Qnil;
 }
 
-/* Insert character C.  If NOAUTOFILL is nonzero, don't do autofill
-   even if it is enabled.
+/* Insert N times character C
 
    If this insertion is suitable for direct output (completely simple),
    return 0.  A value of 1 indicates this *might* not have been simple.
    A value of 2 means this did things that call for an undo boundary.  */
 
 static Lisp_Object Qexpand_abbrev;
+static Lisp_Object Qpost_self_insert_hook, Vpost_self_insert_hook;
 
 static int
-internal_self_insert (int c, int noautofill)
+internal_self_insert (int c, int n)
 {
   int hairy = 0;
   Lisp_Object tem;
   register enum syntaxcode synt;
-  Lisp_Object overwrite, string;
+  Lisp_Object overwrite;
   /* Length of multi-byte form of C.  */
   int len;
   /* Working buffer and pointer for multi-byte form of C.  */
@@ -396,32 +371,22 @@ internal_self_insert (int c, int noautofill)
       /* This is the character after point.  */
       int c2 = FETCH_CHAR (PT_BYTE);
 
-      /* Column the cursor should be placed at after this insertion.
-         The correct value should be calculated only when necessary.  */
-      int target_clm = 0;
-
       /* Overwriting in binary-mode always replaces C2 by C.
          Overwriting in textual-mode doesn't always do that.
          It inserts newlines in the usual way,
          and inserts any character at end of line
          or before a tab if it doesn't use the whole width of the tab.  */
-      if (EQ (overwrite, Qoverwrite_mode_binary)
-          || (c != '\n'
-              && c2 != '\n'
-              && ! (c2 == '\t'
-                    && XINT (current_buffer->tab_width) > 0
-                    && XFASTINT (current_buffer->tab_width) < 20
-                    && (target_clm = ((int) current_column () /* iftc */
-                                      + XINT (Fchar_width (make_number (c)))),
-                        target_clm % XFASTINT (current_buffer->tab_width)))))
+      if (EQ (overwrite, Qoverwrite_mode_binary))
+        chars_to_delete = n;
+      else if (c != '\n' && c2 != '\n')
         {
           int pos = PT;
           int pos_byte = PT_BYTE;
+          /* Column the cursor should be placed at after this insertion.
+             The correct value should be calculated only when necessary.  */
+          int target_clm = ((int) current_column () /* iftc */
+                            + n * XINT (Fchar_width (make_number (c))));
 
-          if (target_clm == 0)
-            chars_to_delete = 1;
-          else
-            {
               /* The actual cursor position after the trial of moving
                  to column TARGET_CLM.  It is greater than TARGET_CLM
                  if the TARGET_CLM is middle of multi-column
@@ -433,14 +398,18 @@ internal_self_insert (int c, int noautofill)
               chars_to_delete = PT - pos;
 
               if (actual_clm > target_clm)
-                {
-                  /* We will delete too many columns.  Let's fill columns
+            { /* We will delete too many columns.  Let's fill columns
                      by spaces so that the remaining text won't move.  */
+              EMACS_INT actual = PT_BYTE;
+              DEC_POS (actual);
+              if (FETCH_CHAR (actual) == '\t')
+                /* Rather than add spaces, let's just keep the tab. */
+                chars_to_delete--;
+              else
                   spaces_to_insert = actual_clm - target_clm;
                 }
-            }
+
           SET_PT_BOTH (pos, pos_byte);
-          hairy = 2;
         }
       hairy = 2;
     }
@@ -451,10 +420,10 @@ internal_self_insert (int c, int noautofill)
       && synt != Sword
       && NILP (current_buffer->read_only)
       && PT > BEGV
-      && (!NILP (current_buffer->enable_multibyte_characters)
-          ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
-          : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
-             == Sword)))
+      && (SYNTAX (!NILP (current_buffer->enable_multibyte_characters)
+                  ? XFASTINT (Fprevious_char ())
+                  : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
+          == Sword))
     {
       int modiff = MODIFF;
       Lisp_Object sym;
@@ -479,16 +448,30 @@ internal_self_insert (int c, int noautofill)
 
   if (chars_to_delete)
     {
-      string = make_string_from_bytes (str, 1, len);
+      int mc = ((NILP (current_buffer->enable_multibyte_characters)
+                 && SINGLE_BYTE_CHAR_P (c))
+                ? UNIBYTE_TO_CHAR (c) : c);
+      Lisp_Object string = Fmake_string (make_number (n), make_number (mc));
+                                          
       if (spaces_to_insert)
         {
           tem = Fmake_string (make_number (spaces_to_insert),
                               make_number (' '));
-          string = concat2 (tem, string);
+          string = concat2 (string, tem);
         }
 
       replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
-      Fforward_char (make_number (1 + spaces_to_insert));
+      Fforward_char (make_number (n + spaces_to_insert));
+    }
+  else if (n > 1)
+    {
+      USE_SAFE_ALLOCA;
+      unsigned char *strn, *p;
+      SAFE_ALLOCA (strn, unsigned char*, n * len);
+      for (p = strn; n > 0; n--, p += len)
+        memcpy (p, str, len);
+      insert_and_inherit (strn, p - strn);
+      SAFE_FREE ();
     }
   else
     insert_and_inherit (str, len);
@@ -496,7 +479,6 @@ internal_self_insert (int c, int noautofill)
   if ((CHAR_TABLE_P (Vauto_fill_chars)
        ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
        : (c == ' ' || c == '\n'))
-      && !noautofill
       && !NILP (current_buffer->auto_fill_function))
     {
       Lisp_Object tem;
@@ -514,22 +496,9 @@ internal_self_insert (int c, int noautofill)
         hairy = 2;
     }
 
-  /* If previous command specified a face to use, use it.  */
-  if (!NILP (Vself_insert_face)
-      && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
-    {
-      Fput_text_property (make_number (PT - 1), make_number (PT),
-                          Qface, Vself_insert_face, Qnil);
-      Vself_insert_face = Qnil;
-    }
+  /* Run hooks for electric keys.  */
+  call1 (Vrun_hooks, Qpost_self_insert_hook);
 
-  if ((synt == Sclose || synt == Smath)
-      && !NILP (Vblink_paren_function) && INTERACTIVE
-      && !noautofill)
-    {
-      call0 (Vblink_paren_function);
-      hairy = 2;
-    }
   return hairy;
 }
 
@@ -550,20 +519,13 @@ syms_of_cmds (void)
   Qexpand_abbrev = intern_c_string ("expand-abbrev");
   staticpro (&Qexpand_abbrev);
 
-  DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
-               doc: /* If non-nil, set the face of the next self-inserting character to this.
-See also `self-insert-face-command'.  */);
-  Vself_insert_face = Qnil;
-
-  DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
-               doc: /* This is the command that set up `self-insert-face'.
-If `last-command' does not equal this value, we ignore `self-insert-face'.  */);
-  Vself_insert_face_command = Qnil;
+  Qpost_self_insert_hook = intern_c_string ("post-self-insert-hook");
+  staticpro (&Qpost_self_insert_hook);
 
-  DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
-               doc: /* Function called, if non-nil, whenever a close parenthesis is inserted.
-More precisely, a char with closeparen syntax is self-inserted.  */);
-  Vblink_paren_function = Qnil;
+  DEFVAR_LISP ("post-self-insert-hook", &Vpost_self_insert_hook,
+               doc: /* Hook run at the end of `self-insert-command'.
+This run is run after inserting the charater.  */);
+  Vpost_self_insert_hook = Qnil;
 
   defsubr (&Sforward_point);
   defsubr (&Sforward_char);