(byte-compile-insert-header): If emacs-version

[bpt/emacs.git] / src / cmds.c

diff --git a/src/cmds.c b/src/cmds.c
index f0dbf72..1d835d8 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 Free Software Foundation, Inc.
+   Copyright (C) 1985, 93, 94, 95, 1996 Free Software Foundation, Inc.

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


@@ -15,29 +15,39 @@ 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 <config.h>

 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
 #include "syntax.h"
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
 #include "syntax.h"

+#include "window.h"
+#include "keyboard.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
 DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
 \f
 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;
 {
   if (NILP (n))
 On reaching end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;
 {
   if (NILP (n))

-    XFASTINT (n) = 1;
+    XSETFASTINT (n, 1);

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


@@ -47,7 +57,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)
       {


@@ -67,13 +77,13 @@ 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;
 {
   if (NILP (n))
 On attempt to pass beginning or end of buffer, stop and signal error.")
   (n)
      Lisp_Object n;
 {
   if (NILP (n))

-    XFASTINT (n) = 1;
+    XSETFASTINT (n, 1);

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


@@ -82,17 +92,17 @@ 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 pos2 = PT;

   int pos;
   int count, shortage, negp;
 
   int pos;
   int count, shortage, negp;
 


@@ -105,7 +115,7 @@ With positive ARG, a non-empty line at the end counts as one line\n\
     }
 
   negp = count <= 0;
     }
 
   negp = count <= 0;

-  pos = scan_buffer ('\n', pos2, count - negp, &shortage);
+  pos = scan_buffer ('\n', pos2, 0, count - negp, &shortage, 1);

   if (shortage > 0
       && (negp
          || (ZV > BEGV
   if (shortage > 0
       && (negp
          || (ZV > BEGV


@@ -119,13 +129,13 @@ With positive ARG, a non-empty line at the end counts as one line\n\
 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\
+With argument N not nil or 1, move forward N - 1 lines first.\n\

 If scan reaches end of buffer, stop there without error.")
   (n)
      Lisp_Object n;
 {
   if (NILP (n))
 If scan reaches end of buffer, stop there without error.")
   (n)
      Lisp_Object n;
 {
   if (NILP (n))

-    XFASTINT (n) = 1;
+    XSETFASTINT (n, 1);

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


@@ -136,7 +146,7 @@ If scan reaches end of buffer, stop there without error.")
 DEFUN ("end-of-line", Fend_of_line, Send_of_line,
   0, 1, "p",
   "Move point to end of current line.\n\
 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\
+With argument N not nil or 1, move forward N - 1 lines first.\n\

 If scan reaches end of buffer, stop there without error.")
   (n)
      Lisp_Object n;
 If scan reaches end of buffer, stop there without error.")
   (n)
      Lisp_Object n;


@@ -145,26 +155,20 @@ If scan reaches end of buffer, stop there without error.")
   register int stop;
 
   if (NILP (n))
   register int stop;
 
   if (NILP (n))

-    XFASTINT (n) = 1;
+    XSETFASTINT (n, 1);

   else
     CHECK_NUMBER (n, 0);
 
   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 (find_before_next_newline (PT, 0, XINT (n) - (XINT (n) <= 0)));

 
   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;
 {


@@ -174,17 +178,17 @@ ARG was explicitly specified.")
     {
       if (XINT (n) < 0)
        {
     {
       if (XINT (n) < 0)
        {

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

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

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

        }
       else
        {
        }
       else
        {

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

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

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

        }
     }
   else
        }
     }
   else


@@ -196,89 +200,93 @@ 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 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.  */
+  for (i = 1; i <= XINT (n); i++)
+    {
+      if (PT - i < BEGV)
+       break;
+      if (FETCH_CHAR (PT - i) == '\t' || FETCH_CHAR (PT - i) == '\n')
+       {
+         deleted_special = 1;
+         break;
+       }
+    }
+
+  value = Fdelete_char (make_number (-XINT (n)), killflag);
+
+  /* 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_CHAR (PT) == '\n'))
+    {
+      Finsert_char (make_number (' '), XINT (n));
+      SET_PT (PT - XINT (n));
+    }
+
+  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);
+  CHECK_NUMBER (n, 0);

 
   /* Barf if the key that invoked this was not a character.  */
 
   /* Barf if the key that invoked this was not a character.  */

-  if (XTYPE (last_command_char) != Lisp_Int)
+  if (!INTEGERP (last_command_char))

     bitch_at_user ();
     bitch_at_user ();

+  else 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 (XINT (last_command_char), 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 (last_command_char, n, Qt);
+      /* The last one might want to auto-fill.  */
+      internal_self_insert (XINT (last_command_char), 0);
+    }

   else
   else

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

       {
       {

-       XFASTINT (arg)--;       /* Ok since old and new vals both nonneg */
-       internal_self_insert (XINT (last_command_char), XFASTINT (arg) != 0);
+       /* Ok since old and new vals both nonneg */
+       XSETFASTINT (n, XFASTINT (n) - 1);
+       internal_self_insert (XINT (last_command_char), 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 ebginning fo 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';
-  if (flag)
-    SET_PT (point - 1);
-
-  while (XINT (arg) > 0)
-    {
-      if (flag)
-       insert (&c1, 1);
-      else
-       internal_self_insert ('\n', !NILP (arg1));
-      XFASTINT (arg)--;                /* Ok since old and new vals both nonneg */
-    }
-
-  if (flag)
-    SET_PT (point + 1);
-
-  return Qnil;
-}
-

 /* Insert character C1.  If NOAUTOFILL is nonzero, don't do autofill
    even if it is enabled.
 
    If this insertion is suitable for direct output (completely simple),
 /* Insert character C1.  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.  */
+   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)
 
 internal_self_insert (c1, noautofill)

-     char c1;
+     /* This has to be unsigned char; when it is char,
+       some compilers sign-extend it in SYNTAX_ENTRY, despite
+       the casts to unsigned char there.  */
+     unsigned char c1;

      int noautofill;
 {
   extern Lisp_Object Fexpand_abbrev ();
      int noautofill;
 {
   extern Lisp_Object Fexpand_abbrev ();


@@ -286,28 +294,30 @@ internal_self_insert (c1, noautofill)
   Lisp_Object tem;
   register enum syntaxcode synt;
   register int c = c1;
   Lisp_Object tem;
   register enum syntaxcode synt;
   register int c = c1;

-  Lisp_Object overwrite = current_buffer->overwrite_mode;
+  Lisp_Object overwrite;

 
 

-  if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function))
+  overwrite = current_buffer->overwrite_mode;
+  if (!NILP (Vbefore_change_function) || !NILP (Vafter_change_function)
+      || !NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))

     hairy = 1;
 
   if (!NILP (overwrite)
     hairy = 1;
 
   if (!NILP (overwrite)

-      && point < ZV
+      && PT < ZV

       && (EQ (overwrite, Qoverwrite_mode_binary)
       && (EQ (overwrite, Qoverwrite_mode_binary)

-         || (c != '\n' && FETCH_CHAR (point) != '\n'))
+         || (c != '\n' && FETCH_CHAR (PT) != '\n'))

       && (EQ (overwrite, Qoverwrite_mode_binary)
       && (EQ (overwrite, Qoverwrite_mode_binary)

-         || FETCH_CHAR (point) != '\t'
+         || FETCH_CHAR (PT) != '\t'

          || XINT (current_buffer->tab_width) <= 0
          || XFASTINT (current_buffer->tab_width) > 20
          || !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
     {
          || XINT (current_buffer->tab_width) <= 0
          || XFASTINT (current_buffer->tab_width) > 20
          || !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
     {

-      del_range (point, point + 1);
-      hairy = 1;
+      del_range (PT, PT + 1);
+      hairy = 2;

     }
   if (!NILP (current_buffer->abbrev_mode)
       && SYNTAX (c) != Sword
       && NILP (current_buffer->read_only)
     }
   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 (FETCH_CHAR (PT - 1)) == Sword)

     {
       int modiff = MODIFF;
       Fexpand_abbrev ();
     {
       int modiff = MODIFF;
       Fexpand_abbrev ();


@@ -315,28 +325,48 @@ internal_self_insert (c1, noautofill)
         but if Fexpand_abbrev changed the buffer,
         assume it expanded something.  */
       if (MODIFF != modiff)
         but if Fexpand_abbrev changed the buffer,
         assume it expanded something.  */
       if (MODIFF != modiff)

-       hairy = 1;
+       hairy = 2;

     }
   if ((c == ' ' || c == '\n')
       && !noautofill
     }
   if ((c == ' ' || c == '\n')
       && !noautofill

-      && !NILP (current_buffer->auto_fill_function)
-      && current_column () > XFASTINT (current_buffer->fill_column))
+      && !NILP (current_buffer->auto_fill_function))

     {
     {

-      if (c1 != '\n')
-       insert (&c1, 1);
-      call0 (current_buffer->auto_fill_function);
+      Lisp_Object tem;
+
+      insert_and_inherit (&c1, 1);

       if (c1 == '\n')
       if (c1 == '\n')

-       insert (&c1, 1);
-      hairy = 1;
+       /* 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 (PT - 1);
+      tem = call0 (current_buffer->auto_fill_function);
+      if (c1 == '\n')
+       SET_PT (PT + 1);
+      if (!NILP (tem))
+       hairy = 2;

     }
   else
     }
   else

-    insert (&c1, 1);
+    insert_and_inherit (&c1, 1);
+
+#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))
+    {
+      Lisp_Object before, after;
+      XSETINT (before, PT - 1);
+      XSETINT (after, PT);
+      Fput_text_property (before, after, 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);
     {
       call0 (Vblink_paren_function);

-      hairy = 1;
+      hairy = 2;

     }
   return hairy;
 }
     }
   return hairy;
 }


@@ -354,6 +384,16 @@ 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.");
   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.");


@@ -369,18 +409,20 @@ 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);

 }
 
 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");
   for (n = 040; n < 0177; n++)
     initial_define_key (global_map, n, "self-insert-command");

-  for (n = 0240; n < 0377; n++)
+#ifdef MSDOS
+  for (n = 0200; n < 0240; n++)
+    initial_define_key (global_map, n, "self-insert-command");
+#endif
+  for (n = 0240; n < 0400; n++)

     initial_define_key (global_map, n, "self-insert-command");
 
   initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
     initial_define_key (global_map, n, "self-insert-command");
 
   initial_define_key (global_map, Ctl ('A'), "beginning-of-line");