src/cmds.c

   1 /* Simple built-in editing commands.
   2    Copyright (C) 1985, 1993, 1994, 1995, 1996, 1997, 1998, 2001, 2002,
   3                  2003, 2004, 2005, 2006, 2007, 2008
   4                  Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs; see the file COPYING.  If not, write to
  20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  22
  23
  24 #include <config.h>
  25 #include "lisp.h"
  26 #include "commands.h"
  27 #include "buffer.h"
  28 #include "character.h"
  29 #include "syntax.h"
  30 #include "window.h"
  31 #include "keyboard.h"
  32 #include "keymap.h"
  33 #include "dispextern.h"
  34
  35 Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
  36
  37 /* A possible value for a buffer's overwrite-mode variable.  */
  38 Lisp_Object Qoverwrite_mode_binary;
  39
  40 /* Non-nil means put this face on the next self-inserting character.  */
  41 Lisp_Object Vself_insert_face;
  42
  43 /* This is the command that set up Vself_insert_face.  */
  44 Lisp_Object Vself_insert_face_command;
  45
  46 extern Lisp_Object Qface;
  47 extern Lisp_Object Vtranslation_table_for_input;
  48 \f
  49 DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
  50        doc: /* Return buffer position N characters after (before if N negative) point.  */)
  51      (n)
  52      Lisp_Object n;
  53 {
  54   CHECK_NUMBER (n);
  55
  56   return make_number (PT + XINT (n));
  57 }
  58
  59 DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "^p",
  60        doc: /* Move point right N characters (left if N is negative).
  61 On reaching end of buffer, stop and signal error.  */)
  62      (n)
  63      Lisp_Object n;
  64 {
  65   if (NILP (n))
  66     XSETFASTINT (n, 1);
  67   else
  68     CHECK_NUMBER (n);
  69
  70   /* This used to just set point to point + XINT (n), and then check
  71      to see if it was within boundaries.  But now that SET_PT can
  72      potentially do a lot of stuff (calling entering and exiting
  73      hooks, etcetera), that's not a good approach.  So we validate the
  74      proposed position, then set point.  */
  75   {
  76     int new_point = PT + XINT (n);
  77
  78     if (new_point < BEGV)
  79       {
  80         SET_PT (BEGV);
  81         xsignal0 (Qbeginning_of_buffer);
  82       }
  83     if (new_point > ZV)
  84       {
  85         SET_PT (ZV);
  86         xsignal0 (Qend_of_buffer);
  87       }
  88
  89     SET_PT (new_point);
  90   }
  91
  92   return Qnil;
  93 }
  94
  95 DEFUN ("backward-char", Fbackward_char, Sbackward_char, 0, 1, "^p",
  96        doc: /* Move point left N characters (right if N is negative).
  97 On attempt to pass beginning or end of buffer, stop and signal error.  */)
  98      (n)
  99      Lisp_Object n;
 100 {
 101   if (NILP (n))
 102     XSETFASTINT (n, 1);
 103   else
 104     CHECK_NUMBER (n);
 105
 106   XSETINT (n, - XINT (n));
 107   return Fforward_char (n);
 108 }
 109
 110 DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "^p",
 111        doc: /* Move N lines forward (backward if N is negative).
 112 Precisely, if point is on line I, move to the start of line I + N.
 113 If there isn't room, go as far as possible (no error).
 114 Returns the count of lines left to move.  If moving forward,
 115 that is N - number of lines moved; if backward, N + number moved.
 116 With positive N, a non-empty line at the end counts as one line
 117   successfully moved (for the return value).  */)
 118      (n)
 119      Lisp_Object n;
 120 {
 121   int opoint = PT, opoint_byte = PT_BYTE;
 122   int pos, pos_byte;
 123   int count, shortage;
 124
 125   if (NILP (n))
 126     count = 1;
 127   else
 128     {
 129       CHECK_NUMBER (n);
 130       count = XINT (n);
 131     }
 132
 133   if (count <= 0)
 134     shortage = scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, count - 1, 1);
 135   else
 136     shortage = scan_newline (PT, PT_BYTE, ZV, ZV_BYTE, count, 1);
 137
 138   /* Since scan_newline does TEMP_SET_PT_BOTH,
 139      and we want to set PT "for real",
 140      go back to the old point and then come back here.  */
 141   pos = PT;
 142   pos_byte = PT_BYTE;
 143   TEMP_SET_PT_BOTH (opoint, opoint_byte);
 144   SET_PT_BOTH (pos, pos_byte);
 145
 146   if (shortage > 0
 147       && (count <= 0
 148           || (ZV > BEGV
 149               && PT != opoint
 150               && (FETCH_BYTE (PT_BYTE - 1) != '\n'))))
 151     shortage--;
 152
 153   return make_number (count <= 0 ? - shortage : shortage);
 154 }
 155
 156 DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line, 0, 1, "^p",
 157        doc: /* Move point to beginning of current line.
 158 With argument N not nil or 1, move forward N - 1 lines first.
 159 If point reaches the beginning or end of buffer, it stops there.
 160
 161 This function constrains point to the current field unless this moves
 162 point to a different line than the original, unconstrained result.  If
 163 N is nil or 1, and a front-sticky field starts at point, the point
 164 does not move.  To ignore field boundaries bind
 165 `inhibit-field-text-motion' to t, or use the `forward-line' function
 166 instead.  For instance, `(forward-line 0)' does the same thing as
 167 `(beginning-of-line)', except that it ignores field boundaries.  */)
 168      (n)
 169      Lisp_Object n;
 170 {
 171   if (NILP (n))
 172     XSETFASTINT (n, 1);
 173   else
 174     CHECK_NUMBER (n);
 175
 176   SET_PT (XINT (Fline_beginning_position (n)));
 177
 178   return Qnil;
 179 }
 180
 181 DEFUN ("end-of-line", Fend_of_line, Send_of_line, 0, 1, "^p",
 182        doc: /* Move point to end of current line.
 183 With argument N not nil or 1, move forward N - 1 lines first.
 184 If point reaches the beginning or end of buffer, it stops there.
 185 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
 186
 187 This function constrains point to the current field unless this moves
 188 point to a different line than the original, unconstrained result.  If
 189 N is nil or 1, and a rear-sticky field ends at point, the point does
 190 not move.  To ignore field boundaries bind `inhibit-field-text-motion'
 191 to t.  */)
 192      (n)
 193      Lisp_Object n;
 194 {
 195   int newpos;
 196
 197   if (NILP (n))
 198     XSETFASTINT (n, 1);
 199   else
 200     CHECK_NUMBER (n);
 201
 202   while (1)
 203     {
 204       newpos = XINT (Fline_end_position (n));
 205       SET_PT (newpos);
 206
 207       if (PT > newpos
 208           && FETCH_CHAR (PT - 1) == '\n')
 209         {
 210           /* If we skipped over a newline that follows
 211              an invisible intangible run,
 212              move back to the last tangible position
 213              within the line.  */
 214
 215           SET_PT (PT - 1);
 216           break;
 217         }
 218       else if (PT > newpos && PT < ZV
 219                && FETCH_CHAR (PT) != '\n')
 220         /* If we skipped something intangible
 221            and now we're not really at eol,
 222            keep going.  */
 223         n = make_number (1);
 224       else
 225         break;
 226     }
 227
 228   return Qnil;
 229 }
 230
 231 DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
 232        doc: /* Delete the following N characters (previous if N is negative).
 233 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
 234 Interactively, N is the prefix arg, and KILLFLAG is set if
 235 N was explicitly specified.  */)
 236      (n, killflag)
 237      Lisp_Object n, killflag;
 238 {
 239   int pos;
 240
 241   CHECK_NUMBER (n);
 242
 243   pos = PT + XINT (n);
 244   if (NILP (killflag))
 245     {
 246       if (XINT (n) < 0)
 247         {
 248           if (pos < BEGV)
 249             xsignal0 (Qbeginning_of_buffer);
 250           else
 251             del_range (pos, PT);
 252         }
 253       else
 254         {
 255           if (pos > ZV)
 256             xsignal0 (Qend_of_buffer);
 257           else
 258             del_range (PT, pos);
 259         }
 260     }
 261   else
 262     {
 263       call1 (Qkill_forward_chars, n);
 264     }
 265   return Qnil;
 266 }
 267
 268 DEFUN ("delete-backward-char", Fdelete_backward_char, Sdelete_backward_char,
 269        1, 2, "p\nP",
 270        doc: /* Delete the previous N characters (following if N is negative).
 271 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
 272 Interactively, N is the prefix arg, and KILLFLAG is set if
 273 N was explicitly specified.  */)
 274      (n, killflag)
 275      Lisp_Object n, killflag;
 276 {
 277   Lisp_Object value;
 278   int deleted_special = 0;
 279   int pos, pos_byte, i;
 280
 281   CHECK_NUMBER (n);
 282
 283   /* See if we are about to delete a tab or newline backwards.  */
 284   pos = PT;
 285   pos_byte = PT_BYTE;
 286   for (i = 0; i < XINT (n) && pos_byte > BEGV_BYTE; i++)
 287     {
 288       int c;
 289
 290       DEC_BOTH (pos, pos_byte);
 291       c = FETCH_BYTE (pos_byte);
 292       if (c == '\t' || c == '\n')
 293         {
 294           deleted_special = 1;
 295           break;
 296         }
 297     }
 298
 299   /* In overwrite mode, back over columns while clearing them out,
 300      unless at end of line.  */
 301   if (XINT (n) > 0
 302       && ! NILP (current_buffer->overwrite_mode)
 303       && ! deleted_special
 304       && ! (PT == ZV || FETCH_BYTE (PT_BYTE) == '\n'))
 305     {
 306       int column = (int) current_column (); /* iftc */
 307
 308       value = Fdelete_char (make_number (-XINT (n)), killflag);
 309       i = column - (int) current_column (); /* iftc */
 310       Finsert_char (make_number (' '), make_number (i), Qnil);
 311       /* Whitespace chars are ASCII chars, so we can simply subtract.  */
 312       SET_PT_BOTH (PT - i, PT_BYTE - i);
 313     }
 314   else
 315     value = Fdelete_char (make_number (-XINT (n)), killflag);
 316
 317   return value;
 318 }
 319
 320 /* Note that there's code in command_loop_1 which typically avoids
 321    calling this.  */
 322 DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
 323        doc: /* Insert the character you type.
 324 Whichever character you type to run this command is inserted.  */)
 325      (n)
 326      Lisp_Object n;
 327 {
 328   CHECK_NUMBER (n);
 329
 330   /* Barf if the key that invoked this was not a character.  */
 331   if (!CHARACTERP (last_command_char))
 332     bitch_at_user ();
 333   {
 334     int character = translate_char (Vtranslation_table_for_input,
 335                                     XINT (last_command_char));
 336     if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
 337       {
 338         int modified_char = character;
 339         /* Add the offset to the character, for Finsert_char.
 340            We pass internal_self_insert the unmodified character
 341            because it itself does this offsetting.  */
 342         if (! NILP (current_buffer->enable_multibyte_characters))
 343           modified_char = unibyte_char_to_multibyte (modified_char);
 344
 345         XSETFASTINT (n, XFASTINT (n) - 2);
 346         /* The first one might want to expand an abbrev.  */
 347         internal_self_insert (character, 1);
 348         /* The bulk of the copies of this char can be inserted simply.
 349            We don't have to handle a user-specified face specially
 350            because it will get inherited from the first char inserted.  */
 351         Finsert_char (make_number (modified_char), n, Qt);
 352         /* The last one might want to auto-fill.  */
 353         internal_self_insert (character, 0);
 354       }
 355     else
 356       while (XINT (n) > 0)
 357         {
 358           /* Ok since old and new vals both nonneg */
 359           XSETFASTINT (n, XFASTINT (n) - 1);
 360           internal_self_insert (character, XFASTINT (n) != 0);
 361         }
 362   }
 363
 364   return Qnil;
 365 }
 366
 367 /* Insert character C.  If NOAUTOFILL is nonzero, don't do autofill
 368    even if it is enabled.
 369
 370    If this insertion is suitable for direct output (completely simple),
 371    return 0.  A value of 1 indicates this *might* not have been simple.
 372    A value of 2 means this did things that call for an undo boundary.  */
 373
 374 static Lisp_Object Qexpand_abbrev;
 375
 376 int
 377 internal_self_insert (c, noautofill)
 378      int c;
 379      int noautofill;
 380 {
 381   int hairy = 0;
 382   Lisp_Object tem;
 383   register enum syntaxcode synt;
 384   Lisp_Object overwrite, string;
 385   /* Length of multi-byte form of C.  */
 386   int len;
 387   /* Working buffer and pointer for multi-byte form of C.  */
 388   unsigned char str[MAX_MULTIBYTE_LENGTH];
 389   int chars_to_delete = 0;
 390   int spaces_to_insert = 0;
 391
 392   overwrite = current_buffer->overwrite_mode;
 393   if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
 394     hairy = 1;
 395
 396   /* At first, get multi-byte form of C in STR.  */
 397   if (!NILP (current_buffer->enable_multibyte_characters))
 398     {
 399       len = CHAR_STRING (c, str);
 400       if (len == 1)
 401         /* If C has modifier bits, this makes C an appropriate
 402            one-byte char.  */
 403         c = *str;
 404     }
 405   else
 406     {
 407       str[0] = (SINGLE_BYTE_CHAR_P (c)
 408                 ? c
 409                 : multibyte_char_to_unibyte (c, Qnil));
 410       len = 1;
 411     }
 412   if (!NILP (overwrite)
 413       && PT < ZV)
 414     {
 415       /* In overwrite-mode, we substitute a character at point (C2,
 416          hereafter) by C.  For that, we delete C2 in advance.  But,
 417          just substituting C2 by C may move a remaining text in the
 418          line to the right or to the left, which is not preferable.
 419          So we insert more spaces or delete more characters in the
 420          following cases: if C is narrower than C2, after deleting C2,
 421          we fill columns with spaces, if C is wider than C2, we delete
 422          C2 and several characters following C2.  */
 423
 424       /* This is the character after point.  */
 425       int c2 = FETCH_CHAR (PT_BYTE);
 426
 427       /* Column the cursor should be placed at after this insertion.
 428          The correct value should be calculated only when necessary.  */
 429       int target_clm = 0;
 430
 431       /* Overwriting in binary-mode always replaces C2 by C.
 432          Overwriting in textual-mode doesn't always do that.
 433          It inserts newlines in the usual way,
 434          and inserts any character at end of line
 435          or before a tab if it doesn't use the whole width of the tab.  */
 436       if (EQ (overwrite, Qoverwrite_mode_binary)
 437           || (c != '\n'
 438               && c2 != '\n'
 439               && ! (c2 == '\t'
 440                     && XINT (current_buffer->tab_width) > 0
 441                     && XFASTINT (current_buffer->tab_width) < 20
 442                     && (target_clm = ((int) current_column () /* iftc */
 443                                       + XINT (Fchar_width (make_number (c)))),
 444                         target_clm % XFASTINT (current_buffer->tab_width)))))
 445         {
 446           int pos = PT;
 447           int pos_byte = PT_BYTE;
 448
 449           if (target_clm == 0)
 450             chars_to_delete = 1;
 451           else
 452             {
 453               /* The actual cursor position after the trial of moving
 454                  to column TARGET_CLM.  It is greater than TARGET_CLM
 455                  if the TARGET_CLM is middle of multi-column
 456                  character.  In that case, the new point is set after
 457                  that character.  */
 458               int actual_clm
 459                 = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
 460
 461               chars_to_delete = PT - pos;
 462
 463               if (actual_clm > target_clm)
 464                 {
 465                   /* We will delete too many columns.  Let's fill columns
 466                      by spaces so that the remaining text won't move.  */
 467                   spaces_to_insert = actual_clm - target_clm;
 468                 }
 469             }
 470           SET_PT_BOTH (pos, pos_byte);
 471           hairy = 2;
 472         }
 473       hairy = 2;
 474     }
 475
 476   if (NILP (current_buffer->enable_multibyte_characters))
 477     MAKE_CHAR_MULTIBYTE (c);
 478   synt = SYNTAX (c);
 479
 480   if (!NILP (current_buffer->abbrev_mode)
 481       && synt != Sword
 482       && NILP (current_buffer->read_only)
 483       && PT > BEGV
 484       && (!NILP (current_buffer->enable_multibyte_characters)
 485           ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
 486           : (SYNTAX (unibyte_char_to_multibyte (XFASTINT (Fprevious_char ())))
 487              == Sword)))
 488     {
 489       int modiff = MODIFF;
 490       Lisp_Object sym;
 491
 492       sym = call0 (Qexpand_abbrev);
 493
 494       /* If we expanded an abbrev which has a hook,
 495          and the hook has a non-nil `no-self-insert' property,
 496          return right away--don't really self-insert.  */
 497       if (! NILP (sym) && ! NILP (XSYMBOL (sym)->function)
 498           && SYMBOLP (XSYMBOL (sym)->function))
 499         {
 500           Lisp_Object prop;
 501           prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
 502           if (! NILP (prop))
 503             return 1;
 504         }
 505
 506       if (MODIFF != modiff)
 507         hairy = 2;
 508     }
 509
 510   if (chars_to_delete)
 511     {
 512       string = make_string_from_bytes (str, 1, len);
 513       if (spaces_to_insert)
 514         {
 515           tem = Fmake_string (make_number (spaces_to_insert),
 516                               make_number (' '));
 517           string = concat2 (tem, string);
 518         }
 519
 520       replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
 521       Fforward_char (make_number (1 + spaces_to_insert));
 522     }
 523   else
 524     insert_and_inherit (str, len);
 525
 526   if ((CHAR_TABLE_P (Vauto_fill_chars)
 527        ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
 528        : (c == ' ' || c == '\n'))
 529       && !noautofill
 530       && !NILP (current_buffer->auto_fill_function))
 531     {
 532       Lisp_Object tem;
 533
 534       if (c == '\n')
 535         /* After inserting a newline, move to previous line and fill
 536            that.  Must have the newline in place already so filling and
 537            justification, if any, know where the end is going to be.  */
 538         SET_PT_BOTH (PT - 1, PT_BYTE - 1);
 539       tem = call0 (current_buffer->auto_fill_function);
 540       /* Test PT < ZV in case the auto-fill-function is strange.  */
 541       if (c == '\n' && PT < ZV)
 542         SET_PT_BOTH (PT + 1, PT_BYTE + 1);
 543       if (!NILP (tem))
 544         hairy = 2;
 545     }
 546
 547   /* If previous command specified a face to use, use it.  */
 548   if (!NILP (Vself_insert_face)
 549       && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
 550     {
 551       Fput_text_property (make_number (PT - 1), make_number (PT),
 552                           Qface, Vself_insert_face, Qnil);
 553       Vself_insert_face = Qnil;
 554     }
 555
 556   if ((synt == Sclose || synt == Smath)
 557       && !NILP (Vblink_paren_function) && INTERACTIVE
 558       && !noautofill)
 559     {
 560       call0 (Vblink_paren_function);
 561       hairy = 2;
 562     }
 563   return hairy;
 564 }
 565 \f
 566 /* module initialization */
 567
 568 void
 569 syms_of_cmds ()
 570 {
 571   Qkill_backward_chars = intern ("kill-backward-chars");
 572   staticpro (&Qkill_backward_chars);
 573
 574   Qkill_forward_chars = intern ("kill-forward-chars");
 575   staticpro (&Qkill_forward_chars);
 576
 577   Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
 578   staticpro (&Qoverwrite_mode_binary);
 579
 580   Qexpand_abbrev = intern ("expand-abbrev");
 581   staticpro (&Qexpand_abbrev);
 582
 583   DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
 584                doc: /* If non-nil, set the face of the next self-inserting character to this.
 585 See also `self-insert-face-command'.  */);
 586   Vself_insert_face = Qnil;
 587
 588   DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
 589                doc: /* This is the command that set up `self-insert-face'.
 590 If `last-command' does not equal this value, we ignore `self-insert-face'.  */);
 591   Vself_insert_face_command = Qnil;
 592
 593   DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
 594                doc: /* Function called, if non-nil, whenever a close parenthesis is inserted.
 595 More precisely, a char with closeparen syntax is self-inserted.  */);
 596   Vblink_paren_function = Qnil;
 597
 598   defsubr (&Sforward_point);
 599   defsubr (&Sforward_char);
 600   defsubr (&Sbackward_char);
 601   defsubr (&Sforward_line);
 602   defsubr (&Sbeginning_of_line);
 603   defsubr (&Send_of_line);
 604
 605   defsubr (&Sdelete_char);
 606   defsubr (&Sdelete_backward_char);
 607
 608   defsubr (&Sself_insert_command);
 609 }
 610
 611 void
 612 keys_of_cmds ()
 613 {
 614   int n;
 615
 616   initial_define_key (global_map, Ctl ('I'), "self-insert-command");
 617   for (n = 040; n < 0177; n++)
 618     initial_define_key (global_map, n, "self-insert-command");
 619 #ifdef MSDOS
 620   for (n = 0200; n < 0240; n++)
 621     initial_define_key (global_map, n, "self-insert-command");
 622 #endif
 623   for (n = 0240; n < 0400; n++)
 624     initial_define_key (global_map, n, "self-insert-command");
 625
 626   initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
 627   initial_define_key (global_map, Ctl ('B'), "backward-char");
 628   initial_define_key (global_map, Ctl ('D'), "delete-char");
 629   initial_define_key (global_map, Ctl ('E'), "end-of-line");
 630   initial_define_key (global_map, Ctl ('F'), "forward-char");
 631   initial_define_key (global_map, 0177, "delete-backward-char");
 632 }
 633
 634 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e
 635    (do not change this comment) */