update.

[chise/xemacs-chise.git.1] / src / cmds.c

diff --git a/src/cmds.c b/src/cmds.c
index 5470341..ec8d39e 100644 (file)
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -1,5 +1,6 @@
 /* Simple built-in editing commands.
    Copyright (C) 1985, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
 /* Simple built-in editing commands.
    Copyright (C) 1985, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.

+   Copyright (C) 2001 MORIOKA Tomohiko

 
 This file is part of XEmacs.
 
 
 This file is part of XEmacs.
 

@@ -41,33 +42,41 @@ Lisp_Object Vself_insert_face;
 
 /* This is the command that set up Vself_insert_face.  */
 Lisp_Object Vself_insert_face_command;
 
 /* This is the command that set up Vself_insert_face.  */
 Lisp_Object Vself_insert_face_command;

+
+/* A char-table for characters which may invoke auto-filling.  */
+Lisp_Object Vauto_fill_chars;

 \f
 DEFUN ("forward-char", Fforward_char, 0, 2, "_p", /*
 \f
 DEFUN ("forward-char", Fforward_char, 0, 2, "_p", /*

-Move point right N characters (left if N negative).
+Move point right COUNT characters (left if COUNT is negative).

 On attempt to pass end of buffer, stop and signal `end-of-buffer'.
 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'.
 On reaching end of buffer, stop and signal error.
 On attempt to pass end of buffer, stop and signal `end-of-buffer'.
 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'.
 On reaching end of buffer, stop and signal error.

+
+The characters that are moved over may be added to the current selection
+\(i.e. active region) if the Shift key is held down, a motion key is used
+to invoke this command, and `shifted-motion-keys-select-region' is t; see
+the documentation for this variable for more details.

 */
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *buf = decode_buffer (buffer, 1);
 {
   struct buffer *buf = decode_buffer (buffer, 1);

-  EMACS_INT count;
+  EMACS_INT n;

 
 

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

   else
     {
   else
     {

-      CHECK_INT (n);
-      count = XINT (n);
+      CHECK_INT (count);
+      n = XINT (count);

     }
 
     }
 

-  /* This used to just set point to point + XINT (n), and then check
+  /* This used to just set point to point + XINT (count), and then check

      to see if it was within boundaries.  But now that SET_PT can
      potentially do a lot of stuff (calling entering and exiting
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {
      to see if it was within boundaries.  But now that SET_PT can
      potentially do a lot of stuff (calling entering and exiting
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {

-    Bufpos new_point = BUF_PT (buf) + count;
+    Bufpos new_point = BUF_PT (buf) + n;

 
     if (new_point < BUF_BEGV (buf))
       {
 
     if (new_point < BUF_BEGV (buf))
       {

@@ -89,49 +98,59 @@ On reaching end of buffer, stop and signal error.
 }
 
 DEFUN ("backward-char", Fbackward_char, 0, 2, "_p", /*
 }
 
 DEFUN ("backward-char", Fbackward_char, 0, 2, "_p", /*

-Move point left N characters (right if N negative).
+Move point left COUNT characters (right if COUNT is negative).

 On attempt to pass end of buffer, stop and signal `end-of-buffer'.
 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'.
 On attempt to pass end of buffer, stop and signal `end-of-buffer'.
 On attempt to pass beginning of buffer, stop and signal `beginning-of-buffer'.

+
+The characters that are moved over may be added to the current selection
+\(i.e. active region) if the Shift key is held down, a motion key is used
+to invoke this command, and `shifted-motion-keys-select-region' is t; see
+the documentation for this variable for more details.

 */
 */

-       (n, buffer))
+       (count, buffer))

 {
 {

-  if (NILP (n))
-    n = make_int (-1);
+  if (NILP (count))
+    count = make_int (-1);

   else
     {
   else
     {

-      CHECK_INT (n);
-      XSETINT (n, - XINT (n));
+      CHECK_INT (count);
+      count = make_int (- XINT (count));

     }
     }

-  return Fforward_char (n, buffer);
+  return Fforward_char (count, buffer);

 }
 
 DEFUN ("forward-line", Fforward_line, 0, 2, "_p", /*
 }
 
 DEFUN ("forward-line", Fforward_line, 0, 2, "_p", /*

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

 If there isn't room, go as far as possible (no error).
 Returns the count of lines left to move.  If moving forward,
 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
+that is COUNT - number of lines moved; if backward, COUNT + number moved.
+With positive COUNT, a non-empty line at the end counts as one line

   successfully moved (for the return value).
 If BUFFER is nil, the current buffer is assumed.
   successfully moved (for the return value).
 If BUFFER is nil, the current buffer is assumed.

+
+The characters that are moved over may be added to the current selection
+\(i.e. active region) if the Shift key is held down, a motion key is used
+to invoke this command, and `shifted-motion-keys-select-region' is t; see
+the documentation for this variable for more details.

 */
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *buf = decode_buffer (buffer, 1);
   Bufpos pos2 = BUF_PT (buf);
   Bufpos pos;
 {
   struct buffer *buf = decode_buffer (buffer, 1);
   Bufpos pos2 = BUF_PT (buf);
   Bufpos pos;

-  EMACS_INT count, shortage, negp;
+  EMACS_INT n, shortage, negp;

 
 

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

   else
     {
   else
     {

-      CHECK_INT (n);
-      count = XINT (n);
+      CHECK_INT (count);
+      n = XINT (count);

     }
 
     }
 

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

   if (shortage > 0
       && (negp
          || (BUF_ZV (buf) > BUF_BEGV (buf)
   if (shortage > 0
       && (negp
          || (BUF_ZV (buf) > BUF_BEGV (buf)

@@ -144,26 +163,26 @@ If BUFFER is nil, the current buffer is assumed.
 
 DEFUN ("point-at-bol", Fpoint_at_bol, 0, 2, 0, /*
 Return the character position of the first character on the current line.
 
 DEFUN ("point-at-bol", Fpoint_at_bol, 0, 2, 0, /*
 Return the character position of the first character on the current line.

-With argument N not nil or 1, move forward N - 1 lines first.
+With argument COUNT not nil or 1, move forward COUNT - 1 lines first.

 If scan reaches end of buffer, return that position.
 This function does not move point.
 */
 If scan reaches end of buffer, return that position.
 This function does not move point.
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *b = decode_buffer (buffer, 1);
   REGISTER int orig, end;
 
   XSETBUFFER (buffer, b);
 {
   struct buffer *b = decode_buffer (buffer, 1);
   REGISTER int orig, end;
 
   XSETBUFFER (buffer, b);

-  if (NILP (n))
-    n = make_int (0);
+  if (NILP (count))
+    count = make_int (0);

   else
     {
   else
     {

-      CHECK_INT (n);
-      n = make_int (XINT (n) - 1);
+      CHECK_INT (count);
+      count = make_int (XINT (count) - 1);

     }
 
   orig = BUF_PT (b);
     }
 
   orig = BUF_PT (b);

-  Fforward_line (n, buffer);
+  Fforward_line (count, buffer);

   end = BUF_PT (b);
   BUF_SET_PT (b, orig);
 
   end = BUF_PT (b);
   BUF_SET_PT (b, orig);
 

@@ -172,75 +191,90 @@ This function does not move point.
 
 DEFUN ("beginning-of-line", Fbeginning_of_line, 0, 2, "_p", /*
 Move point to beginning of current line.
 
 DEFUN ("beginning-of-line", Fbeginning_of_line, 0, 2, "_p", /*
 Move point to beginning of current line.

-With argument N not nil or 1, move forward N - 1 lines first.
+With argument COUNT not nil or 1, move forward COUNT - 1 lines first.

 If scan reaches end of buffer, stop there without error.
 If BUFFER is nil, the current buffer is assumed.
 If scan reaches end of buffer, stop there without error.
 If BUFFER is nil, the current buffer is assumed.

+
+The characters that are moved over may be added to the current selection
+\(i.e. active region) if the Shift key is held down, a motion key is used
+to invoke this command, and `shifted-motion-keys-select-region' is t; see
+the documentation for this variable for more details.

 */
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *b = decode_buffer (buffer, 1);
 
 {
   struct buffer *b = decode_buffer (buffer, 1);
 

-  BUF_SET_PT (b, XINT (Fpoint_at_bol (n, buffer)));
+  BUF_SET_PT (b, XINT (Fpoint_at_bol (count, buffer)));

   return Qnil;
 }
 
 DEFUN ("point-at-eol", Fpoint_at_eol, 0, 2, 0, /*
 Return the character position of the last character on the current line.
   return Qnil;
 }
 
 DEFUN ("point-at-eol", Fpoint_at_eol, 0, 2, 0, /*
 Return the character position of the last character on the current line.

-With argument N not nil or 1, move forward N - 1 lines first.
+With argument COUNT not nil or 1, move forward COUNT - 1 lines first.

 If scan reaches end of buffer, return that position.
 This function does not move point.
 */
 If scan reaches end of buffer, return that position.
 This function does not move point.
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *buf = decode_buffer (buffer, 1);
 {
   struct buffer *buf = decode_buffer (buffer, 1);

-  int count;
+  EMACS_INT n;

 
 

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

   else
     {
   else
     {

-      CHECK_INT (n);
-      count = XINT (n);
+      CHECK_INT (count);
+      n = XINT (count);

     }
 
   return make_int (find_before_next_newline (buf, BUF_PT (buf), 0,
     }
 
   return make_int (find_before_next_newline (buf, BUF_PT (buf), 0,

-                                            count - (count <= 0)));
+                                            n - (n <= 0)));

 }
 
 DEFUN ("end-of-line", Fend_of_line, 0, 2, "_p", /*
 Move point to end of current line.
 }
 
 DEFUN ("end-of-line", Fend_of_line, 0, 2, "_p", /*
 Move point to end of current line.

-With argument N not nil or 1, move forward N - 1 lines first.
+With argument COUNT not nil or 1, move forward COUNT - 1 lines first.

 If scan reaches end of buffer, stop there without error.
 If BUFFER is nil, the current buffer is assumed.
 If scan reaches end of buffer, stop there without error.
 If BUFFER is nil, the current buffer is assumed.

+
+The characters that are moved over may be added to the current selection
+\(i.e. active region) if the Shift key is held down, a motion key is used
+to invoke this command, and `shifted-motion-keys-select-region' is t; see
+the documentation for this variable for more details.

 */
 */

-       (n, buffer))
+       (count, buffer))

 {
   struct buffer *b = decode_buffer (buffer, 1);
 
 {
   struct buffer *b = decode_buffer (buffer, 1);
 

-  BUF_SET_PT (b, XINT (Fpoint_at_eol (n, buffer)));
+  BUF_SET_PT (b, XINT (Fpoint_at_eol (count, buffer)));

   return Qnil;
 }
 
   return Qnil;
 }
 

-DEFUN ("delete-char", Fdelete_char, 1, 2, "*p\nP", /*
-Delete the following N characters (previous, with negative N).
-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.
+DEFUN ("delete-char", Fdelete_char, 0, 2, "*p\nP", /*
+Delete the following COUNT characters (previous, with negative COUNT).
+Optional second arg KILLP non-nil means kill instead (save in kill ring).
+Interactively, COUNT is the prefix arg, and KILLP is set if
+COUNT was explicitly specified.

 */
 */

-       (n, killflag))
+       (count, killp))

 {
   /* This function can GC */
   Bufpos pos;
   struct buffer *buf = current_buffer;
 {
   /* This function can GC */
   Bufpos pos;
   struct buffer *buf = current_buffer;

-  int count;
+  EMACS_INT n;

 
 

-  CHECK_INT (n);
-  count = XINT (n);
+  if (NILP (count))
+    n = 1;
+  else
+    {
+      CHECK_INT (count);
+      n = XINT (count);
+    }

 
 

-  pos = BUF_PT (buf) + count;
-  if (NILP (killflag))
+  pos = BUF_PT (buf) + n;
+  if (NILP (killp))

     {
     {

-      if (count < 0)
+      if (n < 0)

        {
          if (pos < BUF_BEGV (buf))
            signal_error (Qbeginning_of_buffer, Qnil);
        {
          if (pos < BUF_BEGV (buf))
            signal_error (Qbeginning_of_buffer, Qnil);

@@ -257,22 +291,31 @@ N was explicitly specified.
     }
   else
     {
     }
   else
     {

-      call1 (Qkill_forward_chars, n);
+      call1 (Qkill_forward_chars, count);

     }
   return Qnil;
 }
 
     }
   return Qnil;
 }
 

-DEFUN ("delete-backward-char", Fdelete_backward_char, 1, 2, "*p\nP", /*
-Delete the previous N characters (following, with negative N).
-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.
+DEFUN ("delete-backward-char", Fdelete_backward_char, 0, 2, "*p\nP", /*
+Delete the previous COUNT characters (following, with negative COUNT).
+Optional second arg KILLP non-nil means kill instead (save in kill ring).
+Interactively, COUNT is the prefix arg, and KILLP is set if
+COUNT was explicitly specified.

 */
 */

-       (n, killflag))
+       (count, killp))

 {
   /* This function can GC */
 {
   /* This function can GC */

-  CHECK_INT (n);
-  return Fdelete_char (make_int (- XINT (n)), killflag);
+  EMACS_INT n;
+
+  if (NILP (count))
+    n = 1;
+  else
+    {
+      CHECK_INT (count);
+      n = XINT (count);
+    }
+
+  return Fdelete_char (make_int (- n), killp);

 }
 
 static void internal_self_insert (Emchar ch, int noautofill);
 }
 
 static void internal_self_insert (Emchar ch, int noautofill);

@@ -280,16 +323,17 @@ static void internal_self_insert (Emchar ch, int noautofill);
 DEFUN ("self-insert-command", Fself_insert_command, 1, 1, "*p", /*
 Insert the character you type.
 Whichever character you type to run this command is inserted.
 DEFUN ("self-insert-command", Fself_insert_command, 1, 1, "*p", /*
 Insert the character you type.
 Whichever character you type to run this command is inserted.

+If a prefix arg COUNT is specified, the character is inserted COUNT times.

 */
 */

-       (n))
+       (count))

 {
   /* This function can GC */
   Emchar ch;
   Lisp_Object c;
 {
   /* This function can GC */
   Emchar ch;
   Lisp_Object c;

-  int count;
+  EMACS_INT n;

 
 

-  CHECK_NATNUM (n);
-  count = XINT (n);
+  CHECK_NATNUM (count);
+  n = XINT (count);

 
   if (CHAR_OR_CHAR_INTP (Vlast_command_char))
     c = Vlast_command_char;
 
   if (CHAR_OR_CHAR_INTP (Vlast_command_char))
     c = Vlast_command_char;

@@ -304,8 +348,8 @@ Whichever character you type to run this command is inserted.
 
   ch = XCHAR (c);
 
 
   ch = XCHAR (c);
 

-  while (count--)
-    internal_self_insert (ch, (count != 0));
+  while (n--)
+    internal_self_insert (ch, (n != 0));

 
   return Qnil;
 }
 
   return Qnil;
 }

@@ -332,7 +376,11 @@ internal_self_insert (Emchar c1, int noautofill)
   int tab_width;
 
   overwrite = buf->overwrite_mode;
   int tab_width;
 
   overwrite = buf->overwrite_mode;

+#ifdef UTF2000
+  syntax_table = XCHAR_TABLE (buf->syntax_table);
+#else

   syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
   syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);

+#endif

 
 #if 0
   /* No, this is very bad, it makes undo *always* undo a character at a time
 
 #if 0
   /* No, this is very bad, it makes undo *always* undo a character at a time

@@ -396,7 +444,9 @@ internal_self_insert (Emchar c1, int noautofill)
 #endif /* FSFmacs */
         }
     }
 #endif /* FSFmacs */
         }
     }

-  if ((c1 == ' ' || c1 == '\n')
+  if ((CHAR_TABLEP (Vauto_fill_chars)
+       ? !NILP (XCHAR_TABLE_VALUE_UNSAFE (Vauto_fill_chars, c1))
+       : (c1 == ' ' || c1 == '\n'))

       && !noautofill
       && !NILP (buf->auto_fill_function))
     {
       && !noautofill
       && !NILP (buf->auto_fill_function))
     {

@@ -442,13 +492,13 @@ internal_self_insert (Emchar c1, int noautofill)
 /* (this comes from Mule but is a generally good idea) */
 
 DEFUN ("self-insert-internal", Fself_insert_internal, 1, 1, 0, /*
 /* (this comes from Mule but is a generally good idea) */
 
 DEFUN ("self-insert-internal", Fself_insert_internal, 1, 1, 0, /*

-Invoke `self-insert-command' as if CH is entered from keyboard.
+Invoke `self-insert-command' as if CHARACTER is entered from keyboard.

 */
 */

-       (ch))
+       (character))

 {
   /* This function can GC */
 {
   /* This function can GC */

-  CHECK_CHAR_COERCE_INT (ch);
-  internal_self_insert (XCHAR (ch), 0);
+  CHECK_CHAR_COERCE_INT (character);
+  internal_self_insert (XCHAR (character), 0);

   return Qnil;
 }
 \f
   return Qnil;
 }
 \f

@@ -498,4 +548,17 @@ 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;
 More precisely, a char with closeparen syntax is self-inserted.
 */ );
   Vblink_paren_function = Qnil;

+
+  DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars /*
+A char-table for characters which invoke auto-filling.
+Such characters have value t in this table.
+*/);
+  Vauto_fill_chars = Fmake_char_table (Qgeneric);
+#ifdef UTF2000
+  put_char_id_table_0 (XCHAR_TABLE (Vauto_fill_chars), ' ', Qt);
+  put_char_id_table_0 (XCHAR_TABLE (Vauto_fill_chars), '\n', Qt);
+#else
+  XCHAR_TABLE (Vauto_fill_chars)->ascii[' '] = Qt;
+  XCHAR_TABLE (Vauto_fill_chars)->ascii['\n'] = Qt;
+#endif

 }
 }