(Fget_char_property): Update call to overlays_at.

[gnu-emacs] / src / cmds.c

diff --git a/src/cmds.c b/src/cmds.c
index 1e8ded46942c56003c4d01c0e7fe256669823527..a9d4890c5256d3750c1fe23ab1b4f9157be0cc25 100644 (file)
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -1,5 +1,5 @@
 /* Simple built-in editing commands.
 /* Simple built-in editing commands.

-   Copyright (C) 1985, 1993, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1985, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.

 
 This file is part of GNU Emacs.
 
 
 This file is part of GNU Emacs.
 


@@ -15,24 +15,45 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to

-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */

 
 
 #include <config.h>
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
 
 
 #include <config.h>
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"

+#include "charset.h"

 #include "syntax.h"
 #include "window.h"
 #include "syntax.h"
 #include "window.h"

+#include "keyboard.h"
+#include "dispextern.h"

 
 Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
 
 /* A possible value for a buffer's overwrite-mode variable.  */
 Lisp_Object Qoverwrite_mode_binary;
 
 
 Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
 
 /* 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;
+
+extern Lisp_Object Qface;

 \f
 \f

+DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
+  "Return buffer position N characters after (before if N negative) point.")
+  (n)
+     Lisp_Object n;
+{
+  CHECK_NUMBER (n, 0);
+
+  return make_number (PT + XINT (n));
+}
+

 DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
 DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",

-  "Move point right ARG characters (left if ARG negative).\n\
+  "Move point right N characters (left if N is negative).\n\

 On reaching end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;
 On reaching end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;


@@ -48,7 +69,7 @@ On reaching end of buffer, stop and signal error.")
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {

-    int new_point = point + XINT (n);
+    int new_point = PT + XINT (n);

 
     if (new_point < BEGV)
       {
 
     if (new_point < BEGV)
       {


@@ -68,7 +89,7 @@ On reaching end of buffer, stop and signal error.")
 }
 
 DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",
 }
 
 DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "p",

-  "Move point left ARG characters (right if ARG negative).\n\
+  "Move point left N characters (right if N is negative).\n\

 On attempt to pass beginning or end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;
 On attempt to pass beginning or end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;


@@ -83,19 +104,19 @@ On attempt to pass beginning or end of buffer, stop and signal error.")
 }
 
 DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",
 }
 
 DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "p",

-  "Move ARG lines forward (backward if ARG is negative).\n\
-Precisely, if point is on line I, move to the start of line I + ARG.\n\
+  "Move N lines forward (backward if N is negative).\n\
+Precisely, if point is on line I, move to the start of line I + N.\n\

 If there isn't room, go as far as possible (no error).\n\
 Returns the count of lines left to move.  If moving forward,\n\
 If there isn't room, go as far as possible (no error).\n\
 Returns the count of lines left to move.  If moving forward,\n\

-that is ARG - number of lines moved; if backward, ARG + number moved.\n\
-With positive ARG, a non-empty line at the end counts as one line\n\
+that is N - number of lines moved; if backward, N + number moved.\n\
+With positive N, a non-empty line at the end counts as one line\n\

   successfully moved (for the return value).")
   (n)
      Lisp_Object n;
 {
   successfully moved (for the return value).")
   (n)
      Lisp_Object n;
 {

-  int pos2 = point;
-  int pos;
-  int count, shortage, negp;
+  int opoint = PT, opoint_byte = PT_BYTE;
+  int pos, pos_byte;
+  int count, shortage;

 
   if (NILP (n))
     count = 1;
 
   if (NILP (n))
     count = 1;


@@ -105,23 +126,37 @@ With positive ARG, a non-empty line at the end counts as one line\n\
       count = XINT (n);
     }
 
       count = XINT (n);
     }
 

-  negp = count <= 0;
-  pos = scan_buffer ('\n', pos2, count - negp, &shortage, 1);
+  if (count <= 0)
+    shortage = scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, count - 1, 1);
+  else
+    shortage = scan_newline (PT, PT_BYTE, ZV, ZV_BYTE, count, 1);
+
+  /* Since scan_newline does TEMP_SET_PT_BOTH,
+     and we want to set PT "for real",
+     go back to the old point and then come back here.  */
+  pos = PT;
+  pos_byte = PT_BYTE;
+  TEMP_SET_PT_BOTH (opoint, opoint_byte);
+  SET_PT_BOTH (pos, pos_byte);
+

   if (shortage > 0
   if (shortage > 0

-      && (negp
+      && (count <= 0

          || (ZV > BEGV
          || (ZV > BEGV

-             && pos != pos2
-             && FETCH_CHAR (pos - 1) != '\n')))
+             && PT != opoint
+             && (FETCH_BYTE (PT_BYTE - 1) != '\n'))))

     shortage--;
     shortage--;

-  SET_PT (pos);
-  return make_number (negp ? - shortage : shortage);
+
+  return make_number (count <= 0 ? - shortage : shortage);

 }
 
 DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
   0, 1, "p",
   "Move point to beginning of current line.\n\
 }
 
 DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line,
   0, 1, "p",
   "Move point to beginning of current line.\n\

-With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
-If scan reaches end of buffer, stop there without error.")
+With argument N not nil or 1, move forward N - 1 lines first.\n\
+If point reaches the beginning or end of buffer, it stops there.\n\
+This command does not move point across a field boundary\n\
+unless it would move beyond there to a different line.\n\
+If N is nil or 1, and point starts at a field boundary, point does not move.")

   (n)
      Lisp_Object n;
 {
   (n)
      Lisp_Object n;
 {


@@ -130,62 +165,60 @@ If scan reaches end of buffer, stop there without error.")
   else
     CHECK_NUMBER (n, 0);
 
   else
     CHECK_NUMBER (n, 0);
 

-  Fforward_line (make_number (XINT (n) - 1));
+  SET_PT (XINT (Fline_beginning_position (n)));
+  

   return Qnil;
 }
 
 DEFUN ("end-of-line", Fend_of_line, Send_of_line,
   0, 1, "p",
   "Move point to end of current line.\n\
   return Qnil;
 }
 
 DEFUN ("end-of-line", Fend_of_line, Send_of_line,
   0, 1, "p",
   "Move point to end of current line.\n\

-With argument ARG not nil or 1, move forward ARG - 1 lines first.\n\
-If scan reaches end of buffer, stop there without error.")
+With argument N not nil or 1, move forward N - 1 lines first.\n\
+If point reaches the beginning or end of buffer, it stops there.\n\
+This command does not move point across a field boundary\n\
+unless it would move beyond there to a different line.\n\
+If N is nil or 1, and point starts at a field boundary, point does not move.")

   (n)
      Lisp_Object n;
 {
   (n)
      Lisp_Object n;
 {

-  register int pos;
-  register int stop;
-

   if (NILP (n))
     XSETFASTINT (n, 1);
   else
     CHECK_NUMBER (n, 0);
 
   if (NILP (n))
     XSETFASTINT (n, 1);
   else
     CHECK_NUMBER (n, 0);
 

-  if (XINT (n) != 1)
-    Fforward_line (make_number (XINT (n) - 1));
-
-  pos = point;
-  stop = ZV;
-  while (pos < stop && FETCH_CHAR (pos) != '\n') pos++;
-  SET_PT (pos);
+  SET_PT (XINT (Fline_end_position (n)));

 
   return Qnil;
 }
 
 DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
 
   return Qnil;
 }
 
 DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",

-  "Delete the following ARG characters (previous, with negative arg).\n\
+  "Delete the following N characters (previous if N is negative).\n\

 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\

-Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
-ARG was explicitly specified.")
+Interactively, N is the prefix arg, and KILLFLAG is set if\n\
+N was explicitly specified.")

   (n, killflag)
      Lisp_Object n, killflag;
 {
   (n, killflag)
      Lisp_Object n, killflag;
 {

+  int pos;
+

   CHECK_NUMBER (n, 0);
 
   CHECK_NUMBER (n, 0);
 

+  pos = PT + XINT (n);

   if (NILP (killflag))
     {
       if (XINT (n) < 0)
        {
   if (NILP (killflag))
     {
       if (XINT (n) < 0)
        {

-         if (point + XINT (n) < BEGV)
+         if (pos < BEGV)

            Fsignal (Qbeginning_of_buffer, Qnil);
          else
            Fsignal (Qbeginning_of_buffer, Qnil);
          else

-           del_range (point + XINT (n), point);
+           del_range (pos, PT);

        }
       else
        {
        }
       else
        {

-         if (point + XINT (n) > ZV)
+         if (pos > ZV)

            Fsignal (Qend_of_buffer, Qnil);
          else
            Fsignal (Qend_of_buffer, Qnil);
          else

-           del_range (point, point + XINT (n));
+           del_range (PT, pos);

        }
     }
   else
        }
     }
   else


@@ -197,163 +230,284 @@ ARG was explicitly specified.")
 
 DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
   1, 2, "p\nP",
 
 DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
   1, 2, "p\nP",

-  "Delete the previous ARG characters (following, with negative ARG).\n\
+  "Delete the previous N characters (following if N is negative).\n\

 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\
 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).\n\

-Interactively, ARG is the prefix arg, and KILLFLAG is set if\n\
-ARG was explicitly specified.")
+Interactively, N is the prefix arg, and KILLFLAG is set if\n\
+N was explicitly specified.")

   (n, killflag)
      Lisp_Object n, killflag;
 {
   (n, killflag)
      Lisp_Object n, killflag;
 {

+  Lisp_Object value;
+  int deleted_special = 0;
+  int pos, pos_byte, i;
+

   CHECK_NUMBER (n, 0);
   CHECK_NUMBER (n, 0);

-  return Fdelete_char (make_number (-XINT (n)), killflag);
+
+  /* See if we are about to delete a tab or newline backwards.  */
+  pos = PT;
+  pos_byte = PT_BYTE;
+  for (i = 0; i < XINT (n) && pos_byte > BEGV_BYTE; i++)
+    {
+      int c;
+
+      DEC_BOTH (pos, pos_byte);
+      c = FETCH_BYTE (pos_byte);
+      if (c == '\t' || c == '\n')
+       {
+         deleted_special = 1;
+         break;
+       }
+    }
+
+  /* In overwrite mode, back over columns while clearing them out,
+     unless at end of line.  */
+  if (XINT (n) > 0
+      && ! NILP (current_buffer->overwrite_mode)
+      && ! deleted_special
+      && ! (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n'))
+    {
+      int column = current_column ();
+
+      value = Fdelete_char (make_number (-XINT (n)), killflag);
+      i = column - current_column ();
+      Finsert_char (make_number (' '), make_number (i), Qnil);
+      /* Whitespace chars are ASCII chars, so we can simply subtract.  */
+      SET_PT_BOTH (PT - i, PT_BYTE - i);
+    }
+  else
+    value = Fdelete_char (make_number (-XINT (n)), killflag);
+
+  return value;

 }
 
 DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
   "Insert the character you type.\n\
 Whichever character you type to run this command is inserted.")
 }
 
 DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
   "Insert the character you type.\n\
 Whichever character you type to run this command is inserted.")

-  (arg)
-     Lisp_Object arg;
+  (n)
+     Lisp_Object n;

 {
 {

-  CHECK_NUMBER (arg, 0);
+  int character = XINT (last_command_char);
+
+  CHECK_NUMBER (n, 0);

 
   /* Barf if the key that invoked this was not a character.  */
   if (!INTEGERP (last_command_char))
     bitch_at_user ();
 
   /* Barf if the key that invoked this was not a character.  */
   if (!INTEGERP (last_command_char))
     bitch_at_user ();

+  else if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
+    {
+      int modified_char = character;
+      /* Add the offset to the character, for Finsert_char.
+        We pass internal_self_insert the unmodified character
+        because it itself does this offsetting.  */
+      if (! NILP (current_buffer->enable_multibyte_characters))
+       modified_char = unibyte_char_to_multibyte (modified_char);
+
+      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 (modified_char), n, Qt);
+      /* The last one might want to auto-fill.  */
+      internal_self_insert (character, 0);
+    }

   else
   else

-    while (XINT (arg) > 0)
+    while (XINT (n) > 0)

       {
        /* Ok since old and new vals both nonneg */
       {
        /* Ok since old and new vals both nonneg */

-       XSETFASTINT (arg, XFASTINT (arg) - 1);
-       internal_self_insert (XINT (last_command_char), XFASTINT (arg) != 0);
+       XSETFASTINT (n, XFASTINT (n) - 1);
+       internal_self_insert (character, XFASTINT (n) != 0);

       }
 
   return Qnil;
 }
 
       }
 
   return Qnil;
 }
 

-DEFUN ("newline", Fnewline, Snewline, 0, 1, "P",
-  "Insert a newline.  With arg, insert that many newlines.\n\
-In Auto Fill mode, if no numeric arg, break the preceding line if it's long.")
-  (arg1)
-     Lisp_Object arg1;
-{
-  int flag;
-  Lisp_Object arg;
-  char c1 = '\n';
-
-  arg = Fprefix_numeric_value (arg1);
-
-  if (!NILP (current_buffer->read_only))
-    Fbarf_if_buffer_read_only ();
-
-  /* Inserting a newline at the end of a line produces better
-     redisplay in try_window_id than inserting at the beginning of a
-     line, and the textual result is the same.  So, if we're at
-     beginning of line, pretend to be at the end of the previous line.  
-
-     We can't use internal_self_insert in that case since it won't do
-     the insertion correctly.  Luckily, internal_self_insert's special
-     features all do nothing in that case.  */
-
-  flag = point > BEGV && FETCH_CHAR (point - 1) == '\n';
-  /* Don't do this if at the beginning of the window.  */
-  if (XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer
-      && marker_position (XWINDOW (selected_window)->start) == PT)
-    flag = 0;
-
-#ifdef USE_TEXT_PROPERTIES
-  /* We cannot use this optimization if properties change
-     in the vicinity.
-     ??? We need to check for change hook properties, etc.  */
-  if (flag)
-    if (! (point - 1 > BEGV && ! property_change_between_p (point - 2, point)))
-      flag = 0;
-#endif
-
-  if (flag)
-    SET_PT (point - 1);
-
-  while (XINT (arg) > 0)
-    {
-      if (flag)
-       insert (&c1, 1);
-      else
-       internal_self_insert ('\n', !NILP (arg1));
-      /* Ok since old and new vals both nonneg */
-      XSETFASTINT (arg, XFASTINT (arg) - 1);
-    }
-
-  if (flag)
-    SET_PT (point + 1);
-
-  return Qnil;
-}
-
-/* Insert character C1.  If NOAUTOFILL is nonzero, don't do autofill
+/* Insert character C.  If NOAUTOFILL is nonzero, don't do autofill

    even if it is enabled.
 
    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.  */
 
    even if it is enabled.
 
    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.  */
 

-internal_self_insert (c1, noautofill)
-     char c1;
+int
+internal_self_insert (c, noautofill)
+     int c;

      int noautofill;
 {
   extern Lisp_Object Fexpand_abbrev ();
   int hairy = 0;
   Lisp_Object tem;
   register enum syntaxcode synt;
      int noautofill;
 {
   extern Lisp_Object Fexpand_abbrev ();
   int hairy = 0;
   Lisp_Object tem;
   register enum syntaxcode synt;

-  register int c = c1;
-  Lisp_Object overwrite;
+  Lisp_Object overwrite, string;
+  /* Length of multi-byte form of C.  */
+  int len;
+  /* Working buffer and pointer for multi-byte form of C.  */
+  unsigned char str[MAX_MULTIBYTE_LENGTH];
+  int chars_to_delete = 0;
+  int spaces_to_insert = 0;

 
   overwrite = current_buffer->overwrite_mode;
 
   overwrite = current_buffer->overwrite_mode;

-  if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function)
-      || !NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
+  if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))

     hairy = 1;
 
     hairy = 1;
 

+  /* At first, get multi-byte form of C in STR.  */
+  if (!NILP (current_buffer->enable_multibyte_characters))
+    {
+      c = unibyte_char_to_multibyte (c);
+      len = CHAR_STRING (c, str);
+      if (len == 1)
+       /* If C has modifier bits, this makes C an appropriate
+           one-byte char.  */
+       c = *str;
+    }
+  else
+    {
+      str[0] = (SINGLE_BYTE_CHAR_P (c)
+               ? c
+               : multibyte_char_to_unibyte (c, Qnil));
+      len = 1;
+    }

   if (!NILP (overwrite)
   if (!NILP (overwrite)

-      && point < ZV
-      && (EQ (overwrite, Qoverwrite_mode_binary)
-         || (c != '\n' && FETCH_CHAR (point) != '\n'))
-      && (EQ (overwrite, Qoverwrite_mode_binary)
-         || FETCH_CHAR (point) != '\t'
-         || XINT (current_buffer->tab_width) <= 0
-         || XFASTINT (current_buffer->tab_width) > 20
-         || !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
+      && PT < ZV)

     {
     {

-      del_range (point, point + 1);
+      /* In overwrite-mode, we substitute a character at point (C2,
+        hereafter) by C.  For that, we delete C2 in advance.  But,
+        just substituting C2 by C may move a remaining text in the
+        line to the right or to the left, which is not preferable.
+        So we insert more spaces or delete more characters in the
+        following cases: if C is narrower than C2, after deleting C2,
+        we fill columns with spaces, if C is wider than C2, we delete
+        C2 and several characters following C2.  */
+
+      /* 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 = (current_column () 
+                                     + XINT (Fchar_width (make_number (c)))),
+                       target_clm % XFASTINT (current_buffer->tab_width)))))
+       {
+         int pos = PT;
+         int pos_byte = PT_BYTE;
+
+         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
+                character.  In that case, the new point is set after
+                that character.  */
+             int actual_clm
+               = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
+
+             chars_to_delete = PT - pos;
+
+             if (actual_clm > target_clm)
+               {
+                 /* We will delete too many columns.  Let's fill columns
+                    by spaces so that the remaining text won't move.  */
+                 spaces_to_insert = actual_clm - target_clm;
+               }
+           }
+         SET_PT_BOTH (pos, pos_byte);
+         hairy = 2;
+       }

       hairy = 2;
     }
   if (!NILP (current_buffer->abbrev_mode)
       && SYNTAX (c) != Sword
       && NILP (current_buffer->read_only)
       hairy = 2;
     }
   if (!NILP (current_buffer->abbrev_mode)
       && SYNTAX (c) != Sword
       && NILP (current_buffer->read_only)

-      && point > BEGV && SYNTAX (FETCH_CHAR (point - 1)) == Sword)
+      && PT > BEGV && SYNTAX (XFASTINT (Fprevious_char ())) == Sword)

     {
       int modiff = MODIFF;
     {
       int modiff = MODIFF;

-      Fexpand_abbrev ();
-      /* We can't trust the value of Fexpand_abbrev,
-        but if Fexpand_abbrev changed the buffer,
-        assume it expanded something.  */
+      Lisp_Object sym;
+
+      sym = Fexpand_abbrev ();
+
+      /* If we expanded an abbrev which has a hook,
+        and the hook has a non-nil `no-self-insert' property,
+        return right away--don't really self-insert.  */
+      if (! NILP (sym) && ! NILP (XSYMBOL (sym)->function)
+         && SYMBOLP (XSYMBOL (sym)->function))
+       {
+         Lisp_Object prop;
+         prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
+         if (! NILP (prop))
+           return 1;
+       }
+

       if (MODIFF != modiff)
        hairy = 2;
     }
       if (MODIFF != modiff)
        hairy = 2;
     }

-  if ((c == ' ' || c == '\n')
-      && !noautofill
-      && !NILP (current_buffer->auto_fill_function)
-      && current_column () > XFASTINT (current_buffer->fill_column))
+
+  if (chars_to_delete)

     {
     {

-      if (c1 != '\n')
-       insert_and_inherit (&c1, 1);
-      call0 (current_buffer->auto_fill_function);
-      if (c1 == '\n')
-       insert_and_inherit (&c1, 1);
-      hairy = 2;
+      string = make_string_from_bytes (str, 1, len);
+      if (spaces_to_insert)
+       {
+         tem = Fmake_string (make_number (spaces_to_insert),
+                             make_number (' '));
+         string = concat2 (tem, string);
+       }
+
+      replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
+      Fforward_char (make_number (1 + spaces_to_insert));

     }
   else
     }
   else

-    insert_and_inherit (&c1, 1);
+    insert_and_inherit (str, len);
+
+  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;
+
+      if (c == '\n')
+       /* After inserting a newline, move to previous line and fill
+          that.  Must have the newline in place already so filling and
+          justification, if any, know where the end is going to be.  */
+       SET_PT_BOTH (PT - 1, PT_BYTE - 1);
+      tem = call0 (current_buffer->auto_fill_function);
+      if (c == '\n')
+       SET_PT_BOTH (PT + 1, PT_BYTE + 1);
+      if (!NILP (tem))
+       hairy = 2;
+    }
+
+#ifdef HAVE_FACES
+  /* 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;
+    }
+#endif
+

   synt = SYNTAX (c);
   if ((synt == Sclose || synt == Smath)
   synt = SYNTAX (c);
   if ((synt == Sclose || synt == Smath)

-      && !NILP (Vblink_paren_function) && INTERACTIVE)
+      && !NILP (Vblink_paren_function) && INTERACTIVE
+      && !noautofill)

     {
       call0 (Vblink_paren_function);
       hairy = 2;
     {
       call0 (Vblink_paren_function);
       hairy = 2;


@@ -363,6 +517,7 @@ internal_self_insert (c1, noautofill)
 \f
 /* module initialization */
 
 \f
 /* module initialization */
 

+void

 syms_of_cmds ()
 {
   Qkill_backward_chars = intern ("kill-backward-chars");
 syms_of_cmds ()
 {
   Qkill_backward_chars = intern ("kill-backward-chars");


@@ -374,11 +529,22 @@ syms_of_cmds ()
   Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
   staticpro (&Qoverwrite_mode_binary);
 
   Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
   staticpro (&Qoverwrite_mode_binary);
 

+  DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
+    "If non-nil, set the face of the next self-inserting character to this.\n\
+See also `self-insert-face-command'.");
+  Vself_insert_face = Qnil;
+
+  DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
+    "This is the command that set up `self-insert-face'.\n\
+If `last-command' does not equal this value, we ignore `self-insert-face'.");
+  Vself_insert_face_command = Qnil;
+

   DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
     "Function called, if non-nil, whenever a close parenthesis is inserted.\n\
 More precisely, a char with closeparen syntax is self-inserted.");
   Vblink_paren_function = Qnil;
 
   DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
     "Function called, if non-nil, whenever a close parenthesis is inserted.\n\
 More precisely, a char with closeparen syntax is self-inserted.");
   Vblink_paren_function = Qnil;
 

+  defsubr (&Sforward_point);

   defsubr (&Sforward_char);
   defsubr (&Sbackward_char);
   defsubr (&Sforward_line);
   defsubr (&Sforward_char);
   defsubr (&Sbackward_char);
   defsubr (&Sforward_line);


@@ -389,15 +555,14 @@ More precisely, a char with closeparen syntax is self-inserted.");
   defsubr (&Sdelete_backward_char);
 
   defsubr (&Sself_insert_command);
   defsubr (&Sdelete_backward_char);
 
   defsubr (&Sself_insert_command);

-  defsubr (&Snewline);

 }
 
 }
 

+void

 keys_of_cmds ()
 {
   int n;
 
 keys_of_cmds ()
 {
   int n;
 

-  initial_define_key (global_map, Ctl('M'), "newline");
-  initial_define_key (global_map, Ctl('I'), "self-insert-command");
+  initial_define_key (global_map, Ctl ('I'), "self-insert-command");

   for (n = 040; n < 0177; n++)
     initial_define_key (global_map, n, "self-insert-command");
 #ifdef MSDOS
   for (n = 040; n < 0177; n++)
     initial_define_key (global_map, n, "self-insert-command");
 #ifdef MSDOS