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/>. */
27 #include "character.h"
32 #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 static int internal_self_insert (int, int);
42 DEFUN ("forward-point", Fforward_point
, Sforward_point
, 1, 1, 0,
43 doc
: /* Return buffer position N characters after (before if N negative) point. */)
48 return make_number (PT
+ XINT (n
));
51 DEFUN ("forward-char", Fforward_char
, Sforward_char
, 0, 1, "^p",
52 doc
: /* Move point N characters forward (backward if N is negative).
53 On reaching end or beginning of buffer, stop and signal error.
55 Depending on the bidirectional context, the movement may be to the
56 right or to the left on the screen. This is in contrast with
57 \\[right-char], which see. */)
65 /* This used to just set point to point + XINT (n), and then check
66 to see if it was within boundaries. But now that SET_PT can
67 potentially do a lot of stuff (calling entering and exiting
68 hooks, etcetera), that's not a good approach. So we validate the
69 proposed position, then set point. */
71 int new_point
= PT
+ XINT (n
);
76 xsignal0 (Qbeginning_of_buffer
);
81 xsignal0 (Qend_of_buffer
);
90 DEFUN ("backward-char", Fbackward_char
, Sbackward_char
, 0, 1, "^p",
91 doc
: /* Move point N characters backward (forward if N is negative).
92 On attempt to pass beginning or end of buffer, stop and signal error.
94 Depending on the bidirectional context, the movement may be to the
95 right or to the left on the screen. This is in contrast with
96 \\[left-char], which see. */)
104 XSETINT (n
, - XINT (n
));
105 return Fforward_char (n
);
108 DEFUN ("forward-line", Fforward_line
, Sforward_line
, 0, 1, "^p",
109 doc
: /* Move N lines forward (backward if N is negative).
110 Precisely, if point is on line I, move to the start of line I + N
111 \("start of line" in the logical order).
112 If there isn't room, go as far as possible (no error).
113 Returns the count of lines left to move. If moving forward,
114 that is N - number of lines moved; if backward, N + number moved.
115 With positive N, a non-empty line at the end counts as one line
116 successfully moved (for the return value). */)
119 int opoint
= PT
, opoint_byte
= PT_BYTE
;
132 shortage
= scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, count
- 1, 1);
134 shortage
= scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, count
, 1);
136 /* Since scan_newline does TEMP_SET_PT_BOTH,
137 and we want to set PT "for real",
138 go back to the old point and then come back here. */
141 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
142 SET_PT_BOTH (pos
, pos_byte
);
148 && (FETCH_BYTE (PT_BYTE
- 1) != '\n'))))
151 return make_number (count
<= 0 ? - shortage
: shortage
);
154 DEFUN ("beginning-of-line", Fbeginning_of_line
, Sbeginning_of_line
, 0, 1, "^p",
155 doc
: /* Move point to beginning of current line (in the logical order).
156 With argument N not nil or 1, move forward N - 1 lines first.
157 If point reaches the beginning or end of buffer, it stops there.
159 This function constrains point to the current field unless this moves
160 point to a different line than the original, unconstrained result.
161 If N is nil or 1, and a front-sticky field starts at point, the point
162 does not move. To ignore field boundaries bind
163 `inhibit-field-text-motion' to t, or use the `forward-line' function
164 instead. For instance, `(forward-line 0)' does the same thing as
165 `(beginning-of-line)', except that it ignores field boundaries. */)
173 SET_PT (XINT (Fline_beginning_position (n
)));
178 DEFUN ("end-of-line", Fend_of_line
, Send_of_line
, 0, 1, "^p",
179 doc
: /* Move point to end of current line (in the logical order).
180 With argument N not nil or 1, move forward N - 1 lines first.
181 If point reaches the beginning or end of buffer, it stops there.
182 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
184 This function constrains point to the current field unless this moves
185 point to a different line than the original, unconstrained result. If
186 N is nil or 1, and a rear-sticky field ends at point, the point does
187 not move. To ignore field boundaries bind `inhibit-field-text-motion'
200 newpos
= XINT (Fline_end_position (n
));
204 && FETCH_CHAR (PT
- 1) == '\n')
206 /* If we skipped over a newline that follows
207 an invisible intangible run,
208 move back to the last tangible position
214 else if (PT
> newpos
&& PT
< ZV
215 && FETCH_CHAR (PT
) != '\n')
216 /* If we skipped something intangible
217 and now we're not really at eol,
227 DEFUN ("delete-char", Fdelete_char
, Sdelete_char
, 1, 2, "p\nP",
228 doc
: /* Delete the following N characters (previous if N is negative).
229 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
230 Interactively, N is the prefix arg, and KILLFLAG is set if
231 N was explicitly specified.
233 The command `delete-forward' is preferable for interactive use. */)
234 (Lisp_Object n
, Lisp_Object killflag
)
246 xsignal0 (Qbeginning_of_buffer
);
253 xsignal0 (Qend_of_buffer
);
260 call1 (Qkill_forward_chars
, n
);
265 static int nonundocount
;
267 /* Note that there's code in command_loop_1 which typically avoids
269 DEFUN ("self-insert-command", Fself_insert_command
, Sself_insert_command
, 1, 1, "p",
270 doc
: /* Insert the character you type.
271 Whichever character you type to run this command is inserted.
272 Before insertion, `expand-abbrev' is executed if the inserted character does
273 not have word syntax and the previous character in the buffer does.
274 After insertion, the value of `auto-fill-function' is called if the
275 `auto-fill-chars' table has a non-nil value for the inserted character. */)
278 int remove_boundary
= 1;
281 if (!EQ (Vthis_command
, current_kboard
->Vlast_command
))
284 if (NILP (Vexecuting_kbd_macro
)
285 && !EQ (minibuf_window
, selected_window
))
287 if (nonundocount
<= 0 || nonundocount
>= 20)
296 && CONSP (current_buffer
->undo_list
)
297 && NILP (XCAR (current_buffer
->undo_list
)))
298 /* Remove the undo_boundary that was just pushed. */
299 current_buffer
->undo_list
= XCDR (current_buffer
->undo_list
);
301 /* Barf if the key that invoked this was not a character. */
302 if (!CHARACTERP (last_command_event
))
305 int character
= translate_char (Vtranslation_table_for_input
,
306 XINT (last_command_event
));
307 if (XINT (n
) >= 2 && NILP (current_buffer
->overwrite_mode
))
309 XSETFASTINT (n
, XFASTINT (n
) - 2);
310 /* The first one might want to expand an abbrev. */
311 internal_self_insert (character
, 1);
312 /* The bulk of the copies of this char can be inserted simply.
313 We don't have to handle a user-specified face specially
314 because it will get inherited from the first char inserted. */
315 Finsert_char (make_number (character
), n
, Qt
);
316 /* The last one might want to auto-fill. */
317 internal_self_insert (character
, 0);
323 /* Ok since old and new vals both nonneg */
324 XSETFASTINT (n
, XFASTINT (n
) - 1);
325 val
= internal_self_insert (character
, XFASTINT (n
) != 0);
328 frame_make_pointer_invisible ();
335 /* Insert character C. If NOAUTOFILL is nonzero, don't do autofill
336 even if it is enabled.
338 If this insertion is suitable for direct output (completely simple),
339 return 0. A value of 1 indicates this *might* not have been simple.
340 A value of 2 means this did things that call for an undo boundary. */
342 static Lisp_Object Qexpand_abbrev
;
343 static Lisp_Object Qpost_self_insert_hook
, Vpost_self_insert_hook
;
346 internal_self_insert (int c
, int noautofill
)
350 register enum syntaxcode synt
;
351 Lisp_Object overwrite
, string
;
352 /* Length of multi-byte form of C. */
354 /* Working buffer and pointer for multi-byte form of C. */
355 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
356 int chars_to_delete
= 0;
357 int spaces_to_insert
= 0;
359 overwrite
= current_buffer
->overwrite_mode
;
360 if (!NILP (Vbefore_change_functions
) || !NILP (Vafter_change_functions
))
363 /* At first, get multi-byte form of C in STR. */
364 if (!NILP (current_buffer
->enable_multibyte_characters
))
366 len
= CHAR_STRING (c
, str
);
368 /* If C has modifier bits, this makes C an appropriate
374 str
[0] = (SINGLE_BYTE_CHAR_P (c
)
376 : multibyte_char_to_unibyte (c
, Qnil
));
379 if (!NILP (overwrite
)
382 /* In overwrite-mode, we substitute a character at point (C2,
383 hereafter) by C. For that, we delete C2 in advance. But,
384 just substituting C2 by C may move a remaining text in the
385 line to the right or to the left, which is not preferable.
386 So we insert more spaces or delete more characters in the
387 following cases: if C is narrower than C2, after deleting C2,
388 we fill columns with spaces, if C is wider than C2, we delete
389 C2 and several characters following C2. */
391 /* This is the character after point. */
392 int c2
= FETCH_CHAR (PT_BYTE
);
394 /* Column the cursor should be placed at after this insertion.
395 The correct value should be calculated only when necessary. */
398 /* Overwriting in binary-mode always replaces C2 by C.
399 Overwriting in textual-mode doesn't always do that.
400 It inserts newlines in the usual way,
401 and inserts any character at end of line
402 or before a tab if it doesn't use the whole width of the tab. */
403 if (EQ (overwrite
, Qoverwrite_mode_binary
)
407 && XINT (current_buffer
->tab_width
) > 0
408 && XFASTINT (current_buffer
->tab_width
) < 20
409 && (target_clm
= ((int) current_column () /* iftc */
410 + XINT (Fchar_width (make_number (c
)))),
411 target_clm
% XFASTINT (current_buffer
->tab_width
)))))
414 int pos_byte
= PT_BYTE
;
420 /* The actual cursor position after the trial of moving
421 to column TARGET_CLM. It is greater than TARGET_CLM
422 if the TARGET_CLM is middle of multi-column
423 character. In that case, the new point is set after
426 = XFASTINT (Fmove_to_column (make_number (target_clm
), Qnil
));
428 chars_to_delete
= PT
- pos
;
430 if (actual_clm
> target_clm
)
432 /* We will delete too many columns. Let's fill columns
433 by spaces so that the remaining text won't move. */
434 spaces_to_insert
= actual_clm
- target_clm
;
437 SET_PT_BOTH (pos
, pos_byte
);
445 if (!NILP (current_buffer
->abbrev_mode
)
447 && NILP (current_buffer
->read_only
)
449 && (SYNTAX (!NILP (current_buffer
->enable_multibyte_characters
)
450 ? XFASTINT (Fprevious_char ())
451 : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
457 sym
= call0 (Qexpand_abbrev
);
459 /* If we expanded an abbrev which has a hook,
460 and the hook has a non-nil `no-self-insert' property,
461 return right away--don't really self-insert. */
462 if (SYMBOLP (sym
) && ! NILP (sym
) && ! NILP (XSYMBOL (sym
)->function
)
463 && SYMBOLP (XSYMBOL (sym
)->function
))
466 prop
= Fget (XSYMBOL (sym
)->function
, intern ("no-self-insert"));
471 if (MODIFF
!= modiff
)
477 string
= make_string_from_bytes (str
, 1, len
);
478 if (spaces_to_insert
)
480 tem
= Fmake_string (make_number (spaces_to_insert
),
482 string
= concat2 (tem
, string
);
485 replace_range (PT
, PT
+ chars_to_delete
, string
, 1, 1, 1);
486 Fforward_char (make_number (1 + spaces_to_insert
));
489 insert_and_inherit (str
, len
);
491 if ((CHAR_TABLE_P (Vauto_fill_chars
)
492 ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars
, c
))
493 : (c
== ' ' || c
== '\n'))
495 && !NILP (current_buffer
->auto_fill_function
))
500 /* After inserting a newline, move to previous line and fill
501 that. Must have the newline in place already so filling and
502 justification, if any, know where the end is going to be. */
503 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
504 tem
= call0 (current_buffer
->auto_fill_function
);
505 /* Test PT < ZV in case the auto-fill-function is strange. */
506 if (c
== '\n' && PT
< ZV
)
507 SET_PT_BOTH (PT
+ 1, PT_BYTE
+ 1);
512 if ((synt
== Sclose
|| synt
== Smath
)
513 && !NILP (Vblink_paren_function
) && INTERACTIVE
516 call0 (Vblink_paren_function
);
519 /* Run hooks for electric keys. */
520 call1 (Vrun_hooks
, Qpost_self_insert_hook
);
525 /* module initialization */
530 Qkill_backward_chars
= intern_c_string ("kill-backward-chars");
531 staticpro (&Qkill_backward_chars
);
533 Qkill_forward_chars
= intern_c_string ("kill-forward-chars");
534 staticpro (&Qkill_forward_chars
);
536 Qoverwrite_mode_binary
= intern_c_string ("overwrite-mode-binary");
537 staticpro (&Qoverwrite_mode_binary
);
539 Qexpand_abbrev
= intern_c_string ("expand-abbrev");
540 staticpro (&Qexpand_abbrev
);
542 Qpost_self_insert_hook
= intern_c_string ("post-self-insert-hook");
543 staticpro (&Qpost_self_insert_hook
);
545 DEFVAR_LISP ("post-self-insert-hook", &Vpost_self_insert_hook
,
546 doc
: /* Hook run at the end of `self-insert-command'.
547 This run is run after inserting the charater. */);
548 Vpost_self_insert_hook
= Qnil
;
550 DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function
,
551 doc
: /* Function called, if non-nil, whenever a close parenthesis is inserted.
552 More precisely, a char with closeparen syntax is self-inserted. */);
553 Vblink_paren_function
= Qnil
;
555 defsubr (&Sforward_point
);
556 defsubr (&Sforward_char
);
557 defsubr (&Sbackward_char
);
558 defsubr (&Sforward_line
);
559 defsubr (&Sbeginning_of_line
);
560 defsubr (&Send_of_line
);
562 defsubr (&Sdelete_char
);
563 defsubr (&Sself_insert_command
);
572 initial_define_key (global_map
, Ctl ('I'), "self-insert-command");
573 for (n
= 040; n
< 0177; n
++)
574 initial_define_key (global_map
, n
, "self-insert-command");
576 for (n
= 0200; n
< 0240; n
++)
577 initial_define_key (global_map
, n
, "self-insert-command");
579 for (n
= 0240; n
< 0400; n
++)
580 initial_define_key (global_map
, n
, "self-insert-command");
582 initial_define_key (global_map
, Ctl ('A'), "beginning-of-line");
583 initial_define_key (global_map
, Ctl ('B'), "backward-char");
584 initial_define_key (global_map
, Ctl ('E'), "end-of-line");
585 initial_define_key (global_map
, Ctl ('F'), "forward-char");
588 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e
589 (do not change this comment) */