1 /* Simple built-in editing commands.
3 Copyright (C) 1985, 1993-1998, 2001-2015 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/>. */
25 #include "character.h"
32 static int internal_self_insert (int, EMACS_INT
);
34 DEFUN ("forward-point", Fforward_point
, Sforward_point
, 1, 1, 0,
35 doc
: /* Return buffer position N characters after (before if N negative) point. */)
40 return make_number (PT
+ XINT (n
));
43 /* Add N to point; or subtract N if FORWARD is false. N defaults to 1.
44 Validate the new location. Return nil. */
46 move_point (Lisp_Object n
, bool forward
)
48 /* This used to just set point to point + XINT (n), and then check
49 to see if it was within boundaries. But now that SET_PT can
50 potentially do a lot of stuff (calling entering and exiting
51 hooks, etcetera), that's not a good approach. So we validate the
52 proposed position, then set point. */
61 new_point
= PT
+ (forward
? XINT (n
) : - XINT (n
));
66 xsignal0 (Qbeginning_of_buffer
);
71 xsignal0 (Qend_of_buffer
);
78 DEFUN ("forward-char", Fforward_char
, Sforward_char
, 0, 1, "^p",
79 doc
: /* Move point N characters forward (backward if N is negative).
80 On reaching end or beginning of buffer, stop and signal error.
81 Interactively, N is the numeric prefix argument.
82 If N is omitted or nil, move point 1 character forward.
84 Depending on the bidirectional context, the movement may be to the
85 right or to the left on the screen. This is in contrast with
86 \\[right-char], which see. */)
89 return move_point (n
, 1);
92 DEFUN ("backward-char", Fbackward_char
, Sbackward_char
, 0, 1, "^p",
93 doc
: /* Move point N characters backward (forward if N is negative).
94 On attempt to pass beginning or end of buffer, stop and signal error.
95 Interactively, N is the numeric prefix argument.
96 If N is omitted or nil, move point 1 character backward.
98 Depending on the bidirectional context, the movement may be to the
99 right or to the left on the screen. This is in contrast with
100 \\[left-char], which see. */)
103 return move_point (n
, 0);
106 DEFUN ("forward-line", Fforward_line
, Sforward_line
, 0, 1, "^p",
107 doc
: /* Move N lines forward (backward if N is negative).
108 Precisely, if point is on line I, move to the start of line I + N
109 ("start of line" in the logical order).
110 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 minus number of lines moved; if backward, N plus number
116 Exception: With positive N, a non-empty line at the end of the
117 buffer, or of its accessible portion, counts as one line
118 successfully moved (for the return value). This means that the
119 function will move point to the end of such a line and will count
120 it as a line moved across, even though there is no next line to
121 go to its beginning. */)
124 ptrdiff_t opoint
= PT
, pos
, pos_byte
, shortage
, count
;
134 shortage
= scan_newline_from_point (count
, &pos
, &pos_byte
);
136 SET_PT_BOTH (pos
, pos_byte
);
142 && (FETCH_BYTE (PT_BYTE
- 1) != '\n'))))
145 return make_number (count
<= 0 ? - shortage
: shortage
);
148 DEFUN ("beginning-of-line", Fbeginning_of_line
, Sbeginning_of_line
, 0, 1, "^p",
149 doc
: /* Move point to beginning of current line (in the logical order).
150 With argument N not nil or 1, move forward N - 1 lines first.
151 If point reaches the beginning or end of buffer, it stops there.
153 This function constrains point to the current field unless this moves
154 point to a different line than the original, unconstrained result.
155 If N is nil or 1, and a front-sticky field starts at point, the point
156 does not move. To ignore field boundaries bind
157 `inhibit-field-text-motion' to t, or use the `forward-line' function
158 instead. For instance, `(forward-line 0)' does the same thing as
159 `(beginning-of-line)', except that it ignores field boundaries. */)
167 SET_PT (XINT (Fline_beginning_position (n
)));
172 DEFUN ("end-of-line", Fend_of_line
, Send_of_line
, 0, 1, "^p",
173 doc
: /* Move point to end of current line (in the logical order).
174 With argument N not nil or 1, move forward N - 1 lines first.
175 If point reaches the beginning or end of buffer, it stops there.
176 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
178 This function constrains point to the current field unless this moves
179 point to a different line than the original, unconstrained result. If
180 N is nil or 1, and a rear-sticky field ends at point, the point does
181 not move. To ignore field boundaries bind `inhibit-field-text-motion'
194 newpos
= XINT (Fline_end_position (n
));
198 && FETCH_CHAR (PT
- 1) == '\n')
200 /* If we skipped over a newline that follows
201 an invisible intangible run,
202 move back to the last tangible position
208 else if (PT
> newpos
&& PT
< ZV
209 && FETCH_CHAR (PT
) != '\n')
210 /* If we skipped something intangible
211 and now we're not really at eol,
221 static int nonundocount
;
224 remove_excessive_undo_boundaries (void)
226 bool remove_boundary
= true;
228 if (!EQ (Vthis_command
, KVAR (current_kboard
, Vlast_command
)))
231 if (NILP (Vexecuting_kbd_macro
))
233 if (nonundocount
<= 0 || nonundocount
>= 20)
235 remove_boundary
= false;
242 && CONSP (BVAR (current_buffer
, undo_list
))
243 && NILP (XCAR (BVAR (current_buffer
, undo_list
)))
244 /* Only remove auto-added boundaries, not boundaries
245 added by explicit calls to undo-boundary. */
246 && EQ (BVAR (current_buffer
, undo_list
), last_undo_boundary
))
247 /* Remove the undo_boundary that was just pushed. */
248 bset_undo_list (current_buffer
, XCDR (BVAR (current_buffer
, undo_list
)));
251 DEFUN ("delete-char", Fdelete_char
, Sdelete_char
, 1, 2, "p\nP",
252 doc
: /* Delete the following N characters (previous if N is negative).
253 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
254 Interactively, N is the prefix arg, and KILLFLAG is set if
255 N was explicitly specified.
257 The command `delete-forward-char' is preferable for interactive use, e.g.
258 because it respects values of `delete-active-region' and `overwrite-mode'. */)
259 (Lisp_Object n
, Lisp_Object killflag
)
265 if (eabs (XINT (n
)) < 2)
266 remove_excessive_undo_boundaries ();
274 xsignal0 (Qbeginning_of_buffer
);
281 xsignal0 (Qend_of_buffer
);
288 call1 (Qkill_forward_chars
, n
);
293 /* Note that there's code in command_loop_1 which typically avoids
295 DEFUN ("self-insert-command", Fself_insert_command
, Sself_insert_command
, 1, 1, "p",
296 doc
: /* Insert the character you type.
297 Whichever character you type to run this command is inserted.
298 The numeric prefix argument N says how many times to repeat the insertion.
299 Before insertion, `expand-abbrev' is executed if the inserted character does
300 not have word syntax and the previous character in the buffer does.
301 After insertion, the value of `auto-fill-function' is called if the
302 `auto-fill-chars' table has a non-nil value for the inserted character.
303 At the end, it runs `post-self-insert-hook'. */)
309 error ("Negative repetition argument %"pI
"d", XINT (n
));
311 if (XFASTINT (n
) < 2)
312 remove_excessive_undo_boundaries ();
314 /* Barf if the key that invoked this was not a character. */
315 if (!CHARACTERP (last_command_event
))
319 int character
= translate_char (Vtranslation_table_for_input
,
320 XINT (last_command_event
));
321 int val
= internal_self_insert (character
, XFASTINT (n
));
324 frame_make_pointer_invisible (SELECTED_FRAME ());
330 /* Insert N times character C
332 If this insertion is suitable for direct output (completely simple),
333 return 0. A value of 1 indicates this *might* not have been simple.
334 A value of 2 means this did things that call for an undo boundary. */
337 internal_self_insert (int c
, EMACS_INT n
)
341 register enum syntaxcode synt
;
342 Lisp_Object overwrite
;
343 /* Length of multi-byte form of C. */
345 /* Working buffer and pointer for multi-byte form of C. */
346 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
347 ptrdiff_t chars_to_delete
= 0;
348 ptrdiff_t spaces_to_insert
= 0;
350 overwrite
= BVAR (current_buffer
, overwrite_mode
);
351 if (!NILP (Vbefore_change_functions
) || !NILP (Vafter_change_functions
))
354 /* At first, get multi-byte form of C in STR. */
355 if (!NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
357 len
= CHAR_STRING (c
, str
);
359 /* If C has modifier bits, this makes C an appropriate
365 str
[0] = SINGLE_BYTE_CHAR_P (c
) ? c
: CHAR_TO_BYTE8 (c
);
368 if (!NILP (overwrite
)
371 /* In overwrite-mode, we substitute a character at point (C2,
372 hereafter) by C. For that, we delete C2 in advance. But,
373 just substituting C2 by C may move a remaining text in the
374 line to the right or to the left, which is not preferable.
375 So we insert more spaces or delete more characters in the
376 following cases: if C is narrower than C2, after deleting C2,
377 we fill columns with spaces, if C is wider than C2, we delete
378 C2 and several characters following C2. */
380 /* This is the character after point. */
381 int c2
= FETCH_CHAR (PT_BYTE
);
385 /* Overwriting in binary-mode always replaces C2 by C.
386 Overwriting in textual-mode doesn't always do that.
387 It inserts newlines in the usual way,
388 and inserts any character at end of line
389 or before a tab if it doesn't use the whole width of the tab. */
390 if (EQ (overwrite
, Qoverwrite_mode_binary
))
391 chars_to_delete
= min (n
, PTRDIFF_MAX
);
392 else if (c
!= '\n' && c2
!= '\n'
393 && (cwidth
= XFASTINT (Fchar_width (make_number (c
)))) != 0)
396 ptrdiff_t pos_byte
= PT_BYTE
;
397 ptrdiff_t curcol
= current_column ();
399 if (n
<= (min (MOST_POSITIVE_FIXNUM
, PTRDIFF_MAX
) - curcol
) / cwidth
)
401 /* Column the cursor should be placed at after this insertion.
402 The value should be calculated only when necessary. */
403 ptrdiff_t target_clm
= curcol
+ n
* cwidth
;
405 /* The actual cursor position after the trial of moving
406 to column TARGET_CLM. It is greater than TARGET_CLM
407 if the TARGET_CLM is middle of multi-column
408 character. In that case, the new point is set after
411 = XFASTINT (Fmove_to_column (make_number (target_clm
), Qnil
));
413 chars_to_delete
= PT
- pos
;
415 if (actual_clm
> target_clm
)
417 /* We will delete too many columns. Let's fill columns
418 by spaces so that the remaining text won't move. */
419 ptrdiff_t actual
= PT_BYTE
;
421 if (FETCH_CHAR (actual
) == '\t')
422 /* Rather than add spaces, let's just keep the tab. */
425 spaces_to_insert
= actual_clm
- target_clm
;
428 SET_PT_BOTH (pos
, pos_byte
);
436 if (!NILP (BVAR (current_buffer
, abbrev_mode
))
438 && NILP (BVAR (current_buffer
, read_only
))
440 && (SYNTAX (!NILP (BVAR (current_buffer
, enable_multibyte_characters
))
441 ? XFASTINT (Fprevious_char ())
442 : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
445 EMACS_INT modiff
= MODIFF
;
448 sym
= call0 (Qexpand_abbrev
);
450 /* If we expanded an abbrev which has a hook,
451 and the hook has a non-nil `no-self-insert' property,
452 return right away--don't really self-insert. */
453 if (SYMBOLP (sym
) && ! NILP (sym
)
454 && ! NILP (XSYMBOL (sym
)->function
)
455 && SYMBOLP (XSYMBOL (sym
)->function
))
458 prop
= Fget (XSYMBOL (sym
)->function
, intern ("no-self-insert"));
463 if (MODIFF
!= modiff
)
469 int mc
= ((NILP (BVAR (current_buffer
, enable_multibyte_characters
))
470 && SINGLE_BYTE_CHAR_P (c
))
471 ? UNIBYTE_TO_CHAR (c
) : c
);
472 Lisp_Object string
= Fmake_string (make_number (n
), make_number (mc
));
474 if (spaces_to_insert
)
476 tem
= Fmake_string (make_number (spaces_to_insert
),
478 string
= concat2 (string
, tem
);
481 replace_range (PT
, PT
+ chars_to_delete
, string
, 1, 1, 1);
482 Fforward_char (make_number (n
));
488 SAFE_NALLOCA (strn
, len
, n
);
489 for (p
= strn
; n
> 0; n
--, p
+= len
)
490 memcpy (p
, str
, len
);
491 insert_and_inherit (strn
, p
- strn
);
495 insert_and_inherit ((char *) str
, len
);
497 if ((CHAR_TABLE_P (Vauto_fill_chars
)
498 ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars
, c
))
499 : (c
== ' ' || c
== '\n'))
500 && !NILP (BVAR (current_buffer
, auto_fill_function
)))
502 Lisp_Object auto_fill_result
;
505 /* After inserting a newline, move to previous line and fill
506 that. Must have the newline in place already so filling and
507 justification, if any, know where the end is going to be. */
508 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
509 auto_fill_result
= call0 (BVAR (current_buffer
, auto_fill_function
));
510 /* Test PT < ZV in case the auto-fill-function is strange. */
511 if (c
== '\n' && PT
< ZV
)
512 SET_PT_BOTH (PT
+ 1, PT_BYTE
+ 1);
513 if (!NILP (auto_fill_result
))
517 /* Run hooks for electric keys. */
518 run_hook (Qpost_self_insert_hook
);
523 /* module initialization */
528 DEFSYM (Qkill_forward_chars
, "kill-forward-chars");
530 /* A possible value for a buffer's overwrite-mode variable. */
531 DEFSYM (Qoverwrite_mode_binary
, "overwrite-mode-binary");
533 DEFSYM (Qexpand_abbrev
, "expand-abbrev");
534 DEFSYM (Qpost_self_insert_hook
, "post-self-insert-hook");
536 DEFVAR_LISP ("post-self-insert-hook", Vpost_self_insert_hook
,
537 doc
: /* Hook run at the end of `self-insert-command'.
538 This is run after inserting the character. */);
539 Vpost_self_insert_hook
= Qnil
;
541 defsubr (&Sforward_point
);
542 defsubr (&Sforward_char
);
543 defsubr (&Sbackward_char
);
544 defsubr (&Sforward_line
);
545 defsubr (&Sbeginning_of_line
);
546 defsubr (&Send_of_line
);
548 defsubr (&Sdelete_char
);
549 defsubr (&Sself_insert_command
);
558 initial_define_key (global_map
, Ctl ('I'), "self-insert-command");
559 for (n
= 040; n
< 0177; n
++)
560 initial_define_key (global_map
, n
, "self-insert-command");
562 for (n
= 0200; n
< 0240; n
++)
563 initial_define_key (global_map
, n
, "self-insert-command");
565 for (n
= 0240; n
< 0400; n
++)
566 initial_define_key (global_map
, n
, "self-insert-command");
568 initial_define_key (global_map
, Ctl ('A'), "beginning-of-line");
569 initial_define_key (global_map
, Ctl ('B'), "backward-char");
570 initial_define_key (global_map
, Ctl ('E'), "end-of-line");
571 initial_define_key (global_map
, Ctl ('F'), "forward-char");