Merge from emacs--devo--0
[emacs.git] / src / cmds.c
blob6d09556f32c8894dcc4a8ca61b2508e728bb9da4
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.
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, or (at your option)
11 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; 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. */
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"
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 /* 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. */)
326 Lisp_Object n;
328 CHECK_NUMBER (n);
330 /* Barf if the key that invoked this was not a character. */
331 if (!CHARACTERP (last_command_char))
332 bitch_at_user ();
334 int character = translate_char (Vtranslation_table_for_input,
335 XINT (last_command_char));
336 if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
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);
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);
355 else
356 while (XINT (n) > 0)
358 /* Ok since old and new vals both nonneg */
359 XSETFASTINT (n, XFASTINT (n) - 1);
360 internal_self_insert (character, XFASTINT (n) != 0);
364 return Qnil;
367 /* Insert character C. If NOAUTOFILL is nonzero, don't do autofill
368 even if it is enabled.
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. */
374 static Lisp_Object Qexpand_abbrev;
377 internal_self_insert (c, noautofill)
378 int c;
379 int noautofill;
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;
392 overwrite = current_buffer->overwrite_mode;
393 if (!NILP (Vbefore_change_functions) || !NILP (Vafter_change_functions))
394 hairy = 1;
396 /* At first, get multi-byte form of C in STR. */
397 if (!NILP (current_buffer->enable_multibyte_characters))
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;
405 else
407 str[0] = (SINGLE_BYTE_CHAR_P (c)
409 : multibyte_char_to_unibyte (c, Qnil));
410 len = 1;
412 if (!NILP (overwrite)
413 && PT < ZV)
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. */
424 /* This is the character after point. */
425 int c2 = FETCH_CHAR (PT_BYTE);
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;
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)))))
446 int pos = PT;
447 int pos_byte = PT_BYTE;
449 if (target_clm == 0)
450 chars_to_delete = 1;
451 else
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));
461 chars_to_delete = PT - pos;
463 if (actual_clm > target_clm)
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;
470 SET_PT_BOTH (pos, pos_byte);
471 hairy = 2;
473 hairy = 2;
476 if (NILP (current_buffer->enable_multibyte_characters))
477 MAKE_CHAR_MULTIBYTE (c);
478 synt = SYNTAX (c);
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)))
489 int modiff = MODIFF;
490 Lisp_Object sym;
492 sym = call0 (Qexpand_abbrev);
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))
500 Lisp_Object prop;
501 prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
502 if (! NILP (prop))
503 return 1;
506 if (MODIFF != modiff)
507 hairy = 2;
510 if (chars_to_delete)
512 string = make_string_from_bytes (str, 1, len);
513 if (spaces_to_insert)
515 tem = Fmake_string (make_number (spaces_to_insert),
516 make_number (' '));
517 string = concat2 (tem, string);
520 replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
521 Fforward_char (make_number (1 + spaces_to_insert));
523 else
524 insert_and_inherit (str, len);
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))
532 Lisp_Object tem;
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;
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))
551 Fput_text_property (make_number (PT - 1), make_number (PT),
552 Qface, Vself_insert_face, Qnil);
553 Vself_insert_face = Qnil;
556 if ((synt == Sclose || synt == Smath)
557 && !NILP (Vblink_paren_function) && INTERACTIVE
558 && !noautofill)
560 call0 (Vblink_paren_function);
561 hairy = 2;
563 return hairy;
566 /* module initialization */
568 void
569 syms_of_cmds ()
571 Qkill_backward_chars = intern ("kill-backward-chars");
572 staticpro (&Qkill_backward_chars);
574 Qkill_forward_chars = intern ("kill-forward-chars");
575 staticpro (&Qkill_forward_chars);
577 Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
578 staticpro (&Qoverwrite_mode_binary);
580 Qexpand_abbrev = intern ("expand-abbrev");
581 staticpro (&Qexpand_abbrev);
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;
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;
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;
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);
605 defsubr (&Sdelete_char);
606 defsubr (&Sdelete_backward_char);
608 defsubr (&Sself_insert_command);
611 void
612 keys_of_cmds ()
614 int n;
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");
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");
634 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e
635 (do not change this comment) */