]> code.delx.au - gnu-emacs/blobdiff - src/cmds.c
merge from trunk
[gnu-emacs] / src / cmds.c
index ed37603eb453f2bd54a651f40f85d2920653cebb..4cb6ca199e7df5c03a6c138c300bee0c928e960a 100644 (file)
@@ -1,14 +1,14 @@
 /* Simple built-in editing commands.
    Copyright (C) 1985, 1993, 1994, 1995, 1996, 1997, 1998, 2001, 2002,
-                 2003, 2004, 2005, 2006, 2007, 2008
+                 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
                  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
-GNU Emacs is free software; you can redistribute it and/or modify
+GNU Emacs is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
 GNU Emacs is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,12 +16,11 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 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
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #include <config.h>
+#include <setjmp.h>
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
@@ -31,6 +30,7 @@ Boston, MA 02110-1301, USA.  */
 #include "keyboard.h"
 #include "keymap.h"
 #include "dispextern.h"
+#include "frame.h"
 
 Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
 
@@ -43,13 +43,11 @@ 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;
-extern Lisp_Object Vtranslation_table_for_input;
+static int internal_self_insert (int, int);
 \f
 DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
        doc: /* Return buffer position N characters after (before if N negative) point.  */)
-     (n)
-     Lisp_Object n;
+  (Lisp_Object n)
 {
   CHECK_NUMBER (n);
 
@@ -57,10 +55,13 @@ DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
 }
 
 DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "^p",
-       doc: /* Move point right N characters (left if N is negative).
-On reaching end of buffer, stop and signal error.  */)
-     (n)
-     Lisp_Object n;
+       doc: /* Move point N characters forward (backward if N is negative).
+On reaching end or beginning of buffer, stop and signal error.
+
+Depending on the bidirectional context, the movement may be to the
+right or to the left on the screen.  This is in contrast with
+\\[right-char], which see.  */)
+  (Lisp_Object n)
 {
   if (NILP (n))
     XSETFASTINT (n, 1);
@@ -93,10 +94,13 @@ On reaching end of buffer, stop and signal error.  */)
 }
 
 DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "^p",
-       doc: /* Move point left N characters (right if N is negative).
-On attempt to pass beginning or end of buffer, stop and signal error.  */)
-     (n)
-     Lisp_Object n;
+       doc: /* Move point N characters backward (forward if N is negative).
+On attempt to pass beginning or end of buffer, stop and signal error.
+
+Depending on the bidirectional context, the movement may be to the
+right or to the left on the screen.  This is in contrast with
+\\[left-char], which see.  */)
+  (Lisp_Object n)
 {
   if (NILP (n))
     XSETFASTINT (n, 1);
@@ -109,14 +113,14 @@ On attempt to pass beginning or end of buffer, stop and signal error.  */)
 
 DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "^p",
        doc: /* Move N lines forward (backward if N is negative).
-Precisely, if point is on line I, move to the start of line I + N.
+Precisely, if point is on line I, move to the start of line I + N
+\("start of line" in the logical order).
 If there isn't room, go as far as possible (no error).
 Returns the count of lines left to move.  If moving forward,
 that is N - number of lines moved; if backward, N + number moved.
 With positive N, a non-empty line at the end counts as one line
-  successfully moved (for the return value).  */)
-     (n)
-     Lisp_Object n;
+successfully moved (for the return value).  */)
+  (Lisp_Object n)
 {
   int opoint = PT, opoint_byte = PT_BYTE;
   int pos, pos_byte;
@@ -154,19 +158,18 @@ With positive N, a non-empty line at the end counts as one line
 }
 
 DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line, 0, 1, "^p",
-       doc: /* Move point to beginning of current line.
+       doc: /* Move point to beginning of current line (in the logical order).
 With argument N not nil or 1, move forward N - 1 lines first.
 If point reaches the beginning or end of buffer, it stops there.
 
 This function constrains point to the current field unless this moves
-point to a different line than the original, unconstrained result.  If
-N is nil or 1, and a front-sticky field starts at point, the point
+point to a different line than the original, unconstrained result.
+If N is nil or 1, and a front-sticky field starts at point, the point
 does not move.  To ignore field boundaries bind
 `inhibit-field-text-motion' to t, or use the `forward-line' function
 instead.  For instance, `(forward-line 0)' does the same thing as
 `(beginning-of-line)', except that it ignores field boundaries.  */)
-     (n)
-     Lisp_Object n;
+  (Lisp_Object n)
 {
   if (NILP (n))
     XSETFASTINT (n, 1);
@@ -179,7 +182,7 @@ instead.  For instance, `(forward-line 0)' does the same thing as
 }
 
 DEFUN ("end-of-line", Fend_of_line, Send_of_line, 0, 1, "^p",
-       doc: /* Move point to end of current line.
+       doc: /* Move point to end of current line (in the logical order).
 With argument N not nil or 1, move forward N - 1 lines first.
 If point reaches the beginning or end of buffer, it stops there.
 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
@@ -189,8 +192,7 @@ point to a different line than the original, unconstrained result.  If
 N is nil or 1, and a rear-sticky field ends at point, the point does
 not move.  To ignore field boundaries bind `inhibit-field-text-motion'
 to t.  */)
-     (n)
-     Lisp_Object n;
+  (Lisp_Object n)
 {
   int newpos;
 
@@ -232,9 +234,10 @@ DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
        doc: /* Delete the following N characters (previous if N is negative).
 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
 Interactively, N is the prefix arg, and KILLFLAG is set if
-N was explicitly specified.  */)
-     (n, killflag)
-     Lisp_Object n, killflag;
+N was explicitly specified.
+
+The command `delete-forward' is preferable for interactive use.  */)
+  (Lisp_Object n, Lisp_Object killflag)
 {
   int pos;
 
@@ -265,99 +268,70 @@ N was explicitly specified.  */)
   return Qnil;
 }
 
-DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
-       1, 2, "p\nP",
-       doc: /* Delete the previous N characters (following if N is negative).
-Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
-Interactively, N is the prefix arg, and KILLFLAG is set if
-N was explicitly specified.  */)
-     (n, killflag)
-     Lisp_Object n, killflag;
-{
-  Lisp_Object value;
-  int deleted_special = 0;
-  int pos, pos_byte, i;
+static int nonundocount;
 
+/* Note that there's code in command_loop_1 which typically avoids
+   calling this.  */
+DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
+       doc: /* Insert the character you type.
+Whichever character you type to run this command is inserted.
+Before insertion, `expand-abbrev' is executed if the inserted character does
+not have word syntax and the previous character in the buffer does.
+After insertion, the value of `auto-fill-function' is called if the
+`auto-fill-chars' table has a non-nil value for the inserted character.  */)
+  (Lisp_Object n)
+{
+  int remove_boundary = 1;
   CHECK_NUMBER (n);
 
-  /* 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;
+  if (!EQ (Vthis_command, current_kboard->Vlast_command))
+    nonundocount = 0;
 
-      DEC_BOTH (pos, pos_byte);
-      c = FETCH_BYTE (pos_byte);
-      if (c == '\t' || c == '\n')
+  if (NILP (Vexecuting_kbd_macro)
+      && !EQ (minibuf_window, selected_window))
+    {
+      if (nonundocount <= 0 || nonundocount >= 20)
        {
-         deleted_special = 1;
-         break;
+         remove_boundary = 0;
+         nonundocount = 0;
        }
+      nonundocount++;
     }
 
-  /* 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 = (int) current_column (); /* iftc */
-
-      value = Fdelete_char (make_number (-XINT (n)), killflag);
-      i = column - (int) current_column (); /* iftc */
-      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;
-}
-
-/* Note that there's code in command_loop_1 which typically avoids
-   calling this.  */
-DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
-       doc: /* Insert the character you type.
-Whichever character you type to run this command is inserted.  */)
-     (n)
-     Lisp_Object n;
-{
-  CHECK_NUMBER (n);
+  if (remove_boundary
+      && CONSP (current_buffer->undo_list)
+      && NILP (XCAR (current_buffer->undo_list)))
+    /* Remove the undo_boundary that was just pushed.  */
+    current_buffer->undo_list = XCDR (current_buffer->undo_list);
 
   /* Barf if the key that invoked this was not a character.  */
-  if (!CHARACTERP (last_command_char))
+  if (!CHARACTERP (last_command_event))
     bitch_at_user ();
   {
     int character = translate_char (Vtranslation_table_for_input,
-                                   XINT (last_command_char));
+                                   XINT (last_command_event));
     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);
+       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);
-         internal_self_insert (character, XFASTINT (n) != 0);
+         val = internal_self_insert (character, XFASTINT (n) != 0);
+         if (val == 2)
+           nonundocount = 0;
+         frame_make_pointer_invisible ();
        }
   }
 
@@ -373,10 +347,8 @@ Whichever character you type to run this command is inserted.  */)
 
 static Lisp_Object Qexpand_abbrev;
 
-int
-internal_self_insert (c, noautofill)
-     int c;
-     int noautofill;
+static int
+internal_self_insert (int c, int noautofill)
 {
   int hairy = 0;
   Lisp_Object tem;
@@ -473,8 +445,6 @@ internal_self_insert (c, noautofill)
       hairy = 2;
     }
 
-  if (NILP (current_buffer->enable_multibyte_characters))
-    MAKE_CHAR_MULTIBYTE (c);
   synt = SYNTAX (c);
 
   if (!NILP (current_buffer->abbrev_mode)
@@ -483,7 +453,7 @@ internal_self_insert (c, noautofill)
       && PT > BEGV
       && (!NILP (current_buffer->enable_multibyte_characters)
          ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
-         : (SYNTAX (unibyte_char_to_multibyte (XFASTINT (Fprevious_char ())))
+         : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
             == Sword)))
     {
       int modiff = MODIFF;
@@ -494,7 +464,7 @@ internal_self_insert (c, noautofill)
       /* 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)
+      if (SYMBOLP (sym) && ! NILP (sym) && ! NILP (XSYMBOL (sym)->function)
          && SYMBOLP (XSYMBOL (sym)->function))
        {
          Lisp_Object prop;
@@ -566,18 +536,18 @@ internal_self_insert (c, noautofill)
 /* module initialization */
 
 void
-syms_of_cmds ()
+syms_of_cmds (void)
 {
-  Qkill_backward_chars = intern ("kill-backward-chars");
+  Qkill_backward_chars = intern_c_string ("kill-backward-chars");
   staticpro (&Qkill_backward_chars);
 
-  Qkill_forward_chars = intern ("kill-forward-chars");
+  Qkill_forward_chars = intern_c_string ("kill-forward-chars");
   staticpro (&Qkill_forward_chars);
 
-  Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
+  Qoverwrite_mode_binary = intern_c_string ("overwrite-mode-binary");
   staticpro (&Qoverwrite_mode_binary);
 
-  Qexpand_abbrev = intern ("expand-abbrev");
+  Qexpand_abbrev = intern_c_string ("expand-abbrev");
   staticpro (&Qexpand_abbrev);
 
   DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
@@ -603,16 +573,15 @@ More precisely, a char with closeparen syntax is self-inserted.  */);
   defsubr (&Send_of_line);
 
   defsubr (&Sdelete_char);
-  defsubr (&Sdelete_backward_char);
-
   defsubr (&Sself_insert_command);
 }
 
 void
-keys_of_cmds ()
+keys_of_cmds (void)
 {
   int n;
 
+  nonundocount = 0;
   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");
@@ -625,10 +594,8 @@ keys_of_cmds ()
 
   initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
   initial_define_key (global_map, Ctl ('B'), "backward-char");
-  initial_define_key (global_map, Ctl ('D'), "delete-char");
   initial_define_key (global_map, Ctl ('E'), "end-of-line");
   initial_define_key (global_map, Ctl ('F'), "forward-char");
-  initial_define_key (global_map, 0177, "delete-backward-char");
 }
 
 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e