* ede.texi (EDE Mode): Refer to init file rather than `.emacs'. Note
[emacs.git] / src / cmds.c
blobfd337f378bb55a875f065e3f4f8851ba7d84e0a0
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, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
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 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 #include <config.h>
23 #include <setjmp.h>
24 #include "lisp.h"
25 #include "commands.h"
26 #include "buffer.h"
27 #include "character.h"
28 #include "syntax.h"
29 #include "window.h"
30 #include "keyboard.h"
31 #include "keymap.h"
32 #include "dispextern.h"
33 #include "frame.h"
35 Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
37 /* A possible value for a buffer's overwrite-mode variable. */
38 Lisp_Object Qoverwrite_mode_binary;
40 /* Non-nil means put this face on the next self-inserting character. */
41 Lisp_Object Vself_insert_face;
43 /* This is the command that set up Vself_insert_face. */
44 Lisp_Object Vself_insert_face_command;
46 extern Lisp_Object Qface;
47 extern Lisp_Object Vtranslation_table_for_input;
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;
54 CHECK_NUMBER (n);
56 return make_number (PT + XINT (n));
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;
65 if (NILP (n))
66 XSETFASTINT (n, 1);
67 else
68 CHECK_NUMBER (n);
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. */
76 int new_point = PT + XINT (n);
78 if (new_point < BEGV)
80 SET_PT (BEGV);
81 xsignal0 (Qbeginning_of_buffer);
83 if (new_point > ZV)
85 SET_PT (ZV);
86 xsignal0 (Qend_of_buffer);
89 SET_PT (new_point);
92 return Qnil;
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;
101 if (NILP (n))
102 XSETFASTINT (n, 1);
103 else
104 CHECK_NUMBER (n);
106 XSETINT (n, - XINT (n));
107 return Fforward_char (n);
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). */)
119 Lisp_Object n;
121 int opoint = PT, opoint_byte = PT_BYTE;
122 int pos, pos_byte;
123 int count, shortage;
125 if (NILP (n))
126 count = 1;
127 else
129 CHECK_NUMBER (n);
130 count = XINT (n);
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);
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);
146 if (shortage > 0
147 && (count <= 0
148 || (ZV > BEGV
149 && PT != opoint
150 && (FETCH_BYTE (PT_BYTE - 1) != '\n'))))
151 shortage--;
153 return make_number (count <= 0 ? - shortage : shortage);
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.
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. */)
169 Lisp_Object n;
171 if (NILP (n))
172 XSETFASTINT (n, 1);
173 else
174 CHECK_NUMBER (n);
176 SET_PT (XINT (Fline_beginning_position (n)));
178 return Qnil;
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.
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. */)
193 Lisp_Object n;
195 int newpos;
197 if (NILP (n))
198 XSETFASTINT (n, 1);
199 else
200 CHECK_NUMBER (n);
202 while (1)
204 newpos = XINT (Fline_end_position (n));
205 SET_PT (newpos);
207 if (PT > newpos
208 && FETCH_CHAR (PT - 1) == '\n')
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. */
215 SET_PT (PT - 1);
216 break;
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;
228 return Qnil;
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;
239 int pos;
241 CHECK_NUMBER (n);
243 pos = PT + XINT (n);
244 if (NILP (killflag))
246 if (XINT (n) < 0)
248 if (pos < BEGV)
249 xsignal0 (Qbeginning_of_buffer);
250 else
251 del_range (pos, PT);
253 else
255 if (pos > ZV)
256 xsignal0 (Qend_of_buffer);
257 else
258 del_range (PT, pos);
261 else
263 call1 (Qkill_forward_chars, n);
265 return Qnil;
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;
277 Lisp_Object value;
278 int deleted_special = 0;
279 int pos, pos_byte, i;
281 CHECK_NUMBER (n);
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++)
288 int c;
290 DEC_BOTH (pos, pos_byte);
291 c = FETCH_BYTE (pos_byte);
292 if (c == '\t' || c == '\n')
294 deleted_special = 1;
295 break;
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'))
306 int column = (int) current_column (); /* iftc */
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);
314 else
315 value = Fdelete_char (make_number (-XINT (n)), killflag);
317 return value;
320 int nonundocount;
322 /* Note that there's code in command_loop_1 which typically avoids
323 calling this. */
324 DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
325 doc: /* Insert the character you type.
326 Whichever character you type to run this command is inserted.
327 Before insertion, `expand-abbrev' is executed if the inserted character does
328 not have word syntax and the previous character in the buffer does.
329 After insertion, the value of `auto-fill-function' is called if the
330 `auto-fill-chars' table has a non-nil value for the inserted character. */)
332 Lisp_Object n;
334 int remove_boundary = 1;
335 CHECK_NUMBER (n);
337 if (!EQ (Vthis_command, current_kboard->Vlast_command))
338 nonundocount = 0;
340 if (NILP (Vexecuting_kbd_macro)
341 && !EQ (minibuf_window, selected_window))
343 if (nonundocount <= 0 || nonundocount >= 20)
345 remove_boundary = 0;
346 nonundocount = 0;
348 nonundocount++;
351 if (remove_boundary
352 && CONSP (current_buffer->undo_list)
353 && NILP (XCAR (current_buffer->undo_list)))
354 /* Remove the undo_boundary that was just pushed. */
355 current_buffer->undo_list = XCDR (current_buffer->undo_list);
357 /* Barf if the key that invoked this was not a character. */
358 if (!CHARACTERP (last_command_event))
359 bitch_at_user ();
361 int character = translate_char (Vtranslation_table_for_input,
362 XINT (last_command_event));
363 if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
365 XSETFASTINT (n, XFASTINT (n) - 2);
366 /* The first one might want to expand an abbrev. */
367 internal_self_insert (character, 1);
368 /* The bulk of the copies of this char can be inserted simply.
369 We don't have to handle a user-specified face specially
370 because it will get inherited from the first char inserted. */
371 Finsert_char (make_number (character), n, Qt);
372 /* The last one might want to auto-fill. */
373 internal_self_insert (character, 0);
375 else
376 while (XINT (n) > 0)
378 int val;
379 /* Ok since old and new vals both nonneg */
380 XSETFASTINT (n, XFASTINT (n) - 1);
381 val = internal_self_insert (character, XFASTINT (n) != 0);
382 if (val == 2)
383 nonundocount = 0;
384 frame_make_pointer_invisible ();
388 return Qnil;
391 /* Insert character C. If NOAUTOFILL is nonzero, don't do autofill
392 even if it is enabled.
394 If this insertion is suitable for direct output (completely simple),
395 return 0. A value of 1 indicates this *might* not have been simple.
396 A value of 2 means this did things that call for an undo boundary. */
398 static Lisp_Object Qexpand_abbrev;
401 internal_self_insert (c, noautofill)
402 int c;
403 int noautofill;
405 int hairy = 0;
406 Lisp_Object tem;
407 register enum syntaxcode synt;
408 Lisp_Object overwrite, string;
409 /* Length of multi-byte form of C. */
410 int len;
411 /* Working buffer and pointer for multi-byte form of C. */
412 unsigned char str[MAX_MULTIBYTE_LENGTH];
413 int chars_to_delete = 0;
414 int spaces_to_insert = 0;
416 overwrite = current_buffer->overwrite_mode;
417 if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
418 hairy = 1;
420 /* At first, get multi-byte form of C in STR. */
421 if (!NILP (current_buffer->enable_multibyte_characters))
423 len = CHAR_STRING (c, str);
424 if (len == 1)
425 /* If C has modifier bits, this makes C an appropriate
426 one-byte char. */
427 c = *str;
429 else
431 str[0] = (SINGLE_BYTE_CHAR_P (c)
433 : multibyte_char_to_unibyte (c, Qnil));
434 len = 1;
436 if (!NILP (overwrite)
437 && PT < ZV)
439 /* In overwrite-mode, we substitute a character at point (C2,
440 hereafter) by C. For that, we delete C2 in advance. But,
441 just substituting C2 by C may move a remaining text in the
442 line to the right or to the left, which is not preferable.
443 So we insert more spaces or delete more characters in the
444 following cases: if C is narrower than C2, after deleting C2,
445 we fill columns with spaces, if C is wider than C2, we delete
446 C2 and several characters following C2. */
448 /* This is the character after point. */
449 int c2 = FETCH_CHAR (PT_BYTE);
451 /* Column the cursor should be placed at after this insertion.
452 The correct value should be calculated only when necessary. */
453 int target_clm = 0;
455 /* Overwriting in binary-mode always replaces C2 by C.
456 Overwriting in textual-mode doesn't always do that.
457 It inserts newlines in the usual way,
458 and inserts any character at end of line
459 or before a tab if it doesn't use the whole width of the tab. */
460 if (EQ (overwrite, Qoverwrite_mode_binary)
461 || (c != '\n'
462 && c2 != '\n'
463 && ! (c2 == '\t'
464 && XINT (current_buffer->tab_width) > 0
465 && XFASTINT (current_buffer->tab_width) < 20
466 && (target_clm = ((int) current_column () /* iftc */
467 + XINT (Fchar_width (make_number (c)))),
468 target_clm % XFASTINT (current_buffer->tab_width)))))
470 int pos = PT;
471 int pos_byte = PT_BYTE;
473 if (target_clm == 0)
474 chars_to_delete = 1;
475 else
477 /* The actual cursor position after the trial of moving
478 to column TARGET_CLM. It is greater than TARGET_CLM
479 if the TARGET_CLM is middle of multi-column
480 character. In that case, the new point is set after
481 that character. */
482 int actual_clm
483 = XFASTINT (Fmove_to_column (make_number (target_clm), Qnil));
485 chars_to_delete = PT - pos;
487 if (actual_clm > target_clm)
489 /* We will delete too many columns. Let's fill columns
490 by spaces so that the remaining text won't move. */
491 spaces_to_insert = actual_clm - target_clm;
494 SET_PT_BOTH (pos, pos_byte);
495 hairy = 2;
497 hairy = 2;
500 synt = SYNTAX (c);
502 if (!NILP (current_buffer->abbrev_mode)
503 && synt != Sword
504 && NILP (current_buffer->read_only)
505 && PT > BEGV
506 && (!NILP (current_buffer->enable_multibyte_characters)
507 ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
508 : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
509 == Sword)))
511 int modiff = MODIFF;
512 Lisp_Object sym;
514 sym = call0 (Qexpand_abbrev);
516 /* If we expanded an abbrev which has a hook,
517 and the hook has a non-nil `no-self-insert' property,
518 return right away--don't really self-insert. */
519 if (SYMBOLP (sym) && ! NILP (sym) && ! NILP (XSYMBOL (sym)->function)
520 && SYMBOLP (XSYMBOL (sym)->function))
522 Lisp_Object prop;
523 prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
524 if (! NILP (prop))
525 return 1;
528 if (MODIFF != modiff)
529 hairy = 2;
532 if (chars_to_delete)
534 string = make_string_from_bytes (str, 1, len);
535 if (spaces_to_insert)
537 tem = Fmake_string (make_number (spaces_to_insert),
538 make_number (' '));
539 string = concat2 (tem, string);
542 replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
543 Fforward_char (make_number (1 + spaces_to_insert));
545 else
546 insert_and_inherit (str, len);
548 if ((CHAR_TABLE_P (Vauto_fill_chars)
549 ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
550 : (c == ' ' || c == '\n'))
551 && !noautofill
552 && !NILP (current_buffer->auto_fill_function))
554 Lisp_Object tem;
556 if (c == '\n')
557 /* After inserting a newline, move to previous line and fill
558 that. Must have the newline in place already so filling and
559 justification, if any, know where the end is going to be. */
560 SET_PT_BOTH (PT - 1, PT_BYTE - 1);
561 tem = call0 (current_buffer->auto_fill_function);
562 /* Test PT < ZV in case the auto-fill-function is strange. */
563 if (c == '\n' && PT < ZV)
564 SET_PT_BOTH (PT + 1, PT_BYTE + 1);
565 if (!NILP (tem))
566 hairy = 2;
569 /* If previous command specified a face to use, use it. */
570 if (!NILP (Vself_insert_face)
571 && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
573 Fput_text_property (make_number (PT - 1), make_number (PT),
574 Qface, Vself_insert_face, Qnil);
575 Vself_insert_face = Qnil;
578 if ((synt == Sclose || synt == Smath)
579 && !NILP (Vblink_paren_function) && INTERACTIVE
580 && !noautofill)
582 call0 (Vblink_paren_function);
583 hairy = 2;
585 return hairy;
588 /* module initialization */
590 void
591 syms_of_cmds ()
593 Qkill_backward_chars = intern_c_string ("kill-backward-chars");
594 staticpro (&Qkill_backward_chars);
596 Qkill_forward_chars = intern_c_string ("kill-forward-chars");
597 staticpro (&Qkill_forward_chars);
599 Qoverwrite_mode_binary = intern_c_string ("overwrite-mode-binary");
600 staticpro (&Qoverwrite_mode_binary);
602 Qexpand_abbrev = intern_c_string ("expand-abbrev");
603 staticpro (&Qexpand_abbrev);
605 DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
606 doc: /* If non-nil, set the face of the next self-inserting character to this.
607 See also `self-insert-face-command'. */);
608 Vself_insert_face = Qnil;
610 DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
611 doc: /* This is the command that set up `self-insert-face'.
612 If `last-command' does not equal this value, we ignore `self-insert-face'. */);
613 Vself_insert_face_command = Qnil;
615 DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
616 doc: /* Function called, if non-nil, whenever a close parenthesis is inserted.
617 More precisely, a char with closeparen syntax is self-inserted. */);
618 Vblink_paren_function = Qnil;
620 defsubr (&Sforward_point);
621 defsubr (&Sforward_char);
622 defsubr (&Sbackward_char);
623 defsubr (&Sforward_line);
624 defsubr (&Sbeginning_of_line);
625 defsubr (&Send_of_line);
627 defsubr (&Sdelete_char);
628 defsubr (&Sdelete_backward_char);
630 defsubr (&Sself_insert_command);
633 void
634 keys_of_cmds ()
636 int n;
638 nonundocount = 0;
639 initial_define_key (global_map, Ctl ('I'), "self-insert-command");
640 for (n = 040; n < 0177; n++)
641 initial_define_key (global_map, n, "self-insert-command");
642 #ifdef MSDOS
643 for (n = 0200; n < 0240; n++)
644 initial_define_key (global_map, n, "self-insert-command");
645 #endif
646 for (n = 0240; n < 0400; n++)
647 initial_define_key (global_map, n, "self-insert-command");
649 initial_define_key (global_map, Ctl ('A'), "beginning-of-line");
650 initial_define_key (global_map, Ctl ('B'), "backward-char");
651 initial_define_key (global_map, Ctl ('D'), "delete-char");
652 initial_define_key (global_map, Ctl ('E'), "end-of-line");
653 initial_define_key (global_map, Ctl ('F'), "forward-char");
654 initial_define_key (global_map, 0177, "delete-backward-char");
657 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e
658 (do not change this comment) */