1 /* Simple built-in editing commands.
3 Copyright (C) 1985, 1993-1998, 2001-2011 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "character.h"
31 #include "dispextern.h"
34 static Lisp_Object Qkill_forward_chars
, Qkill_backward_chars
;
36 /* A possible value for a buffer's overwrite-mode variable. */
37 static Lisp_Object Qoverwrite_mode_binary
;
39 static int internal_self_insert (int, EMACS_INT
);
41 DEFUN ("forward-point", Fforward_point
, Sforward_point
, 1, 1, 0,
42 doc
: /* Return buffer position N characters after (before if N negative) point. */)
47 return make_number (PT
+ XINT (n
));
50 DEFUN ("forward-char", Fforward_char
, Sforward_char
, 0, 1, "^p",
51 doc
: /* Move point N characters forward (backward if N is negative).
52 On reaching end or beginning of buffer, stop and signal error.
54 Depending on the bidirectional context, the movement may be to the
55 right or to the left on the screen. This is in contrast with
56 \\[right-char], which see. */)
64 /* This used to just set point to point + XINT (n), and then check
65 to see if it was within boundaries. But now that SET_PT can
66 potentially do a lot of stuff (calling entering and exiting
67 hooks, etcetera), that's not a good approach. So we validate the
68 proposed position, then set point. */
70 EMACS_INT new_point
= PT
+ XINT (n
);
75 xsignal0 (Qbeginning_of_buffer
);
80 xsignal0 (Qend_of_buffer
);
89 DEFUN ("backward-char", Fbackward_char
, Sbackward_char
, 0, 1, "^p",
90 doc
: /* Move point N characters backward (forward if N is negative).
91 On attempt to pass beginning or end of buffer, stop and signal error.
93 Depending on the bidirectional context, the movement may be to the
94 right or to the left on the screen. This is in contrast with
95 \\[left-char], which see. */)
103 XSETINT (n
, - XINT (n
));
104 return Fforward_char (n
);
107 DEFUN ("forward-line", Fforward_line
, Sforward_line
, 0, 1, "^p",
108 doc
: /* Move N lines forward (backward if N is negative).
109 Precisely, if point is on line I, move to the start of line I + N
110 \("start of line" in the logical order).
111 If there isn't room, go as far as possible (no error).
112 Returns the count of lines left to move. If moving forward,
113 that is N - number of lines moved; if backward, N + number moved.
114 With positive N, a non-empty line at the end counts as one line
115 successfully moved (for the return value). */)
118 EMACS_INT opoint
= PT
, opoint_byte
= PT_BYTE
;
119 EMACS_INT pos
, pos_byte
;
120 EMACS_INT count
, shortage
;
131 shortage
= scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, count
- 1, 1);
133 shortage
= scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, count
, 1);
135 /* Since scan_newline does TEMP_SET_PT_BOTH,
136 and we want to set PT "for real",
137 go back to the old point and then come back here. */
140 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
141 SET_PT_BOTH (pos
, pos_byte
);
147 && (FETCH_BYTE (PT_BYTE
- 1) != '\n'))))
150 return make_number (count
<= 0 ? - shortage
: shortage
);
153 DEFUN ("beginning-of-line", Fbeginning_of_line
, Sbeginning_of_line
, 0, 1, "^p",
154 doc
: /* Move point to beginning of current line (in the logical order).
155 With argument N not nil or 1, move forward N - 1 lines first.
156 If point reaches the beginning or end of buffer, it stops there.
158 This function constrains point to the current field unless this moves
159 point to a different line than the original, unconstrained result.
160 If N is nil or 1, and a front-sticky field starts at point, the point
161 does not move. To ignore field boundaries bind
162 `inhibit-field-text-motion' to t, or use the `forward-line' function
163 instead. For instance, `(forward-line 0)' does the same thing as
164 `(beginning-of-line)', except that it ignores field boundaries. */)
172 SET_PT (XINT (Fline_beginning_position (n
)));
177 DEFUN ("end-of-line", Fend_of_line
, Send_of_line
, 0, 1, "^p",
178 doc
: /* Move point to end of current line (in the logical order).
179 With argument N not nil or 1, move forward N - 1 lines first.
180 If point reaches the beginning or end of buffer, it stops there.
181 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
183 This function constrains point to the current field unless this moves
184 point to a different line than the original, unconstrained result. If
185 N is nil or 1, and a rear-sticky field ends at point, the point does
186 not move. To ignore field boundaries bind `inhibit-field-text-motion'
199 newpos
= XINT (Fline_end_position (n
));
203 && FETCH_CHAR (PT
- 1) == '\n')
205 /* If we skipped over a newline that follows
206 an invisible intangible run,
207 move back to the last tangible position
213 else if (PT
> newpos
&& PT
< ZV
214 && FETCH_CHAR (PT
) != '\n')
215 /* If we skipped something intangible
216 and now we're not really at eol,
226 DEFUN ("delete-char", Fdelete_char
, Sdelete_char
, 1, 2, "p\nP",
227 doc
: /* Delete the following N characters (previous if N is negative).
228 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
229 Interactively, N is the prefix arg, and KILLFLAG is set if
230 N was explicitly specified.
232 The command `delete-forward-char' is preferable for interactive use. */)
233 (Lisp_Object n
, Lisp_Object killflag
)
245 xsignal0 (Qbeginning_of_buffer
);
252 xsignal0 (Qend_of_buffer
);
259 call1 (Qkill_forward_chars
, n
);
264 static int nonundocount
;
266 /* Note that there's code in command_loop_1 which typically avoids
268 DEFUN ("self-insert-command", Fself_insert_command
, Sself_insert_command
, 1, 1, "p",
269 doc
: /* Insert the character you type.
270 Whichever character you type to run this command is inserted.
271 Before insertion, `expand-abbrev' is executed if the inserted character does
272 not have word syntax and the previous character in the buffer does.
273 After insertion, the value of `auto-fill-function' is called if the
274 `auto-fill-chars' table has a non-nil value for the inserted character. */)
277 int remove_boundary
= 1;
280 if (!EQ (Vthis_command
, KVAR (current_kboard
, Vlast_command
)))
283 if (NILP (Vexecuting_kbd_macro
)
284 && !EQ (minibuf_window
, selected_window
))
286 if (nonundocount
<= 0 || nonundocount
>= 20)
295 && CONSP (BVAR (current_buffer
, undo_list
))
296 && NILP (XCAR (BVAR (current_buffer
, undo_list
))))
297 /* Remove the undo_boundary that was just pushed. */
298 BVAR (current_buffer
, undo_list
) = XCDR (BVAR (current_buffer
, undo_list
));
300 /* Barf if the key that invoked this was not a character. */
301 if (!CHARACTERP (last_command_event
))
304 int character
= translate_char (Vtranslation_table_for_input
,
305 (int) XINT (last_command_event
));
306 int val
= internal_self_insert (character
, XFASTINT (n
));
309 frame_make_pointer_invisible ();
315 /* Insert N times character C
317 If this insertion is suitable for direct output (completely simple),
318 return 0. A value of 1 indicates this *might* not have been simple.
319 A value of 2 means this did things that call for an undo boundary. */
321 static Lisp_Object Qexpand_abbrev
;
322 static Lisp_Object Qpost_self_insert_hook
;
325 internal_self_insert (int c
, EMACS_INT n
)
329 register enum syntaxcode synt
;
330 Lisp_Object overwrite
;
331 /* Length of multi-byte form of C. */
333 /* Working buffer and pointer for multi-byte form of C. */
334 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
335 EMACS_INT chars_to_delete
= 0;
336 EMACS_INT spaces_to_insert
= 0;
338 overwrite
= BVAR (current_buffer
, overwrite_mode
);
339 if (!NILP (Vbefore_change_functions
) || !NILP (Vafter_change_functions
))
342 /* At first, get multi-byte form of C in STR. */
343 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
345 len
= CHAR_STRING (c
, str
);
347 /* If C has modifier bits, this makes C an appropriate
353 str
[0] = (SINGLE_BYTE_CHAR_P (c
)
355 : multibyte_char_to_unibyte (c
));
358 if (!NILP (overwrite
)
361 /* In overwrite-mode, we substitute a character at point (C2,
362 hereafter) by C. For that, we delete C2 in advance. But,
363 just substituting C2 by C may move a remaining text in the
364 line to the right or to the left, which is not preferable.
365 So we insert more spaces or delete more characters in the
366 following cases: if C is narrower than C2, after deleting C2,
367 we fill columns with spaces, if C is wider than C2, we delete
368 C2 and several characters following C2. */
370 /* This is the character after point. */
371 int c2
= FETCH_CHAR (PT_BYTE
);
373 /* Overwriting in binary-mode always replaces C2 by C.
374 Overwriting in textual-mode doesn't always do that.
375 It inserts newlines in the usual way,
376 and inserts any character at end of line
377 or before a tab if it doesn't use the whole width of the tab. */
378 if (EQ (overwrite
, Qoverwrite_mode_binary
))
380 else if (c
!= '\n' && c2
!= '\n')
383 EMACS_INT pos_byte
= PT_BYTE
;
385 /* FIXME: Check for integer overflow when calculating
386 target_clm and actual_clm. */
388 /* Column the cursor should be placed at after this insertion.
389 The correct value should be calculated only when necessary. */
390 EMACS_INT target_clm
= (current_column ()
391 + n
* XINT (Fchar_width (make_number (c
))));
393 /* The actual cursor position after the trial of moving
394 to column TARGET_CLM. It is greater than TARGET_CLM
395 if the TARGET_CLM is middle of multi-column
396 character. In that case, the new point is set after
399 = XFASTINT (Fmove_to_column (make_number (target_clm
), Qnil
));
401 chars_to_delete
= PT
- pos
;
403 if (actual_clm
> target_clm
)
405 /* We will delete too many columns. Let's fill columns
406 by spaces so that the remaining text won't move. */
407 EMACS_INT actual
= PT_BYTE
;
409 if (FETCH_CHAR (actual
) == '\t')
410 /* Rather than add spaces, let's just keep the tab. */
413 spaces_to_insert
= actual_clm
- target_clm
;
416 SET_PT_BOTH (pos
, pos_byte
);
423 if (!NILP (BVAR (current_buffer
, abbrev_mode
))
425 && NILP (BVAR (current_buffer
, read_only
))
427 && (SYNTAX (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
428 ? XFASTINT (Fprevious_char ())
429 : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
435 sym
= call0 (Qexpand_abbrev
);
437 /* If we expanded an abbrev which has a hook,
438 and the hook has a non-nil `no-self-insert' property,
439 return right away--don't really self-insert. */
440 if (SYMBOLP (sym
) && ! NILP (sym
) && ! NILP (XSYMBOL (sym
)->function
)
441 && SYMBOLP (XSYMBOL (sym
)->function
))
444 prop
= Fget (XSYMBOL (sym
)->function
, intern ("no-self-insert"));
449 if (MODIFF
!= modiff
)
455 int mc
= ((NILP (BVAR (current_buffer
, enable_multibyte_characters
))
456 && SINGLE_BYTE_CHAR_P (c
))
457 ? UNIBYTE_TO_CHAR (c
) : c
);
458 Lisp_Object string
= Fmake_string (make_number (n
), make_number (mc
));
460 if (spaces_to_insert
)
462 tem
= Fmake_string (make_number (spaces_to_insert
),
464 string
= concat2 (string
, tem
);
467 replace_range (PT
, PT
+ chars_to_delete
, string
, 1, 1, 1);
468 Fforward_char (make_number (n
+ spaces_to_insert
));
474 SAFE_ALLOCA (strn
, char *, n
* len
);
475 for (p
= strn
; n
> 0; n
--, p
+= len
)
476 memcpy (p
, str
, len
);
477 insert_and_inherit (strn
, p
- strn
);
481 insert_and_inherit ((char *) str
, len
);
483 if ((CHAR_TABLE_P (Vauto_fill_chars
)
484 ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars
, c
))
485 : (c
== ' ' || c
== '\n'))
486 && !NILP (BVAR (current_buffer
, auto_fill_function
)))
488 Lisp_Object auto_fill_result
;
491 /* After inserting a newline, move to previous line and fill
492 that. Must have the newline in place already so filling and
493 justification, if any, know where the end is going to be. */
494 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
495 auto_fill_result
= call0 (BVAR (current_buffer
, auto_fill_function
));
496 /* Test PT < ZV in case the auto-fill-function is strange. */
497 if (c
== '\n' && PT
< ZV
)
498 SET_PT_BOTH (PT
+ 1, PT_BYTE
+ 1);
499 if (!NILP (auto_fill_result
))
503 /* Run hooks for electric keys. */
504 Frun_hooks (1, &Qpost_self_insert_hook
);
509 /* module initialization */
514 DEFSYM (Qkill_backward_chars
, "kill-backward-chars");
515 DEFSYM (Qkill_forward_chars
, "kill-forward-chars");
516 DEFSYM (Qoverwrite_mode_binary
, "overwrite-mode-binary");
517 DEFSYM (Qexpand_abbrev
, "expand-abbrev");
518 DEFSYM (Qpost_self_insert_hook
, "post-self-insert-hook");
520 DEFVAR_LISP ("post-self-insert-hook", Vpost_self_insert_hook
,
521 doc
: /* Hook run at the end of `self-insert-command'.
522 This is run after inserting the character. */);
523 Vpost_self_insert_hook
= Qnil
;
525 defsubr (&Sforward_point
);
526 defsubr (&Sforward_char
);
527 defsubr (&Sbackward_char
);
528 defsubr (&Sforward_line
);
529 defsubr (&Sbeginning_of_line
);
530 defsubr (&Send_of_line
);
532 defsubr (&Sdelete_char
);
533 defsubr (&Sself_insert_command
);
542 initial_define_key (global_map
, Ctl ('I'), "self-insert-command");
543 for (n
= 040; n
< 0177; n
++)
544 initial_define_key (global_map
, n
, "self-insert-command");
546 for (n
= 0200; n
< 0240; n
++)
547 initial_define_key (global_map
, n
, "self-insert-command");
549 for (n
= 0240; n
< 0400; n
++)
550 initial_define_key (global_map
, n
, "self-insert-command");
552 initial_define_key (global_map
, Ctl ('A'), "beginning-of-line");
553 initial_define_key (global_map
, Ctl ('B'), "backward-char");
554 initial_define_key (global_map
, Ctl ('E'), "end-of-line");
555 initial_define_key (global_map
, Ctl ('F'), "forward-char");