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 /* 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. */)
56 return make_number (PT
+ XINT (n
));
59 DEFUN ("forward-char", Fforward_char
, Sforward_char
, 0, 1, "^p",
60 doc
: /* Move point N characters forward (backward if N is negative).
61 On reaching end or beginning of buffer, stop and signal error.
63 Depending on the bidirectional context, the movement may be to the
64 right or to the left on the screen. This is in contrast with
65 \\[right-char], which see. */)
74 /* This used to just set point to point + XINT (n), and then check
75 to see if it was within boundaries. But now that SET_PT can
76 potentially do a lot of stuff (calling entering and exiting
77 hooks, etcetera), that's not a good approach. So we validate the
78 proposed position, then set point. */
80 int new_point
= PT
+ XINT (n
);
85 xsignal0 (Qbeginning_of_buffer
);
90 xsignal0 (Qend_of_buffer
);
99 DEFUN ("backward-char", Fbackward_char
, Sbackward_char
, 0, 1, "^p",
100 doc
: /* Move point N characters backward (forward if N is negative).
101 On attempt to pass beginning or end of buffer, stop and signal error.
103 Depending on the bidirectional context, the movement may be to the
104 right or to the left on the screen. This is in contrast with
105 \\[left-char], which see. */)
114 XSETINT (n
, - XINT (n
));
115 return Fforward_char (n
);
118 DEFUN ("forward-line", Fforward_line
, Sforward_line
, 0, 1, "^p",
119 doc
: /* Move N lines forward (backward if N is negative).
120 Precisely, if point is on line I, move to the start of line I + N.
121 If there isn't room, go as far as possible (no error).
122 Returns the count of lines left to move. If moving forward,
123 that is N - number of lines moved; if backward, N + number moved.
124 With positive N, a non-empty line at the end counts as one line
125 successfully moved (for the return value). */)
129 int opoint
= PT
, opoint_byte
= PT_BYTE
;
142 shortage
= scan_newline (PT
, PT_BYTE
, BEGV
, BEGV_BYTE
, count
- 1, 1);
144 shortage
= scan_newline (PT
, PT_BYTE
, ZV
, ZV_BYTE
, count
, 1);
146 /* Since scan_newline does TEMP_SET_PT_BOTH,
147 and we want to set PT "for real",
148 go back to the old point and then come back here. */
151 TEMP_SET_PT_BOTH (opoint
, opoint_byte
);
152 SET_PT_BOTH (pos
, pos_byte
);
158 && (FETCH_BYTE (PT_BYTE
- 1) != '\n'))))
161 return make_number (count
<= 0 ? - shortage
: shortage
);
164 DEFUN ("beginning-of-line", Fbeginning_of_line
, Sbeginning_of_line
, 0, 1, "^p",
165 doc
: /* Move point to beginning of current line.
166 With argument N not nil or 1, move forward N - 1 lines first.
167 If point reaches the beginning or end of buffer, it stops there.
169 This function constrains point to the current field unless this moves
170 point to a different line than the original, unconstrained result.
171 If N is nil or 1, and a front-sticky field starts at point, the point
172 does not move. To ignore field boundaries bind
173 `inhibit-field-text-motion' to t, or use the `forward-line' function
174 instead. For instance, `(forward-line 0)' does the same thing as
175 `(beginning-of-line)', except that it ignores field boundaries. */)
184 SET_PT (XINT (Fline_beginning_position (n
)));
189 DEFUN ("end-of-line", Fend_of_line
, Send_of_line
, 0, 1, "^p",
190 doc
: /* Move point to end of current line.
191 With argument N not nil or 1, move forward N - 1 lines first.
192 If point reaches the beginning or end of buffer, it stops there.
193 To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
195 This function constrains point to the current field unless this moves
196 point to a different line than the original, unconstrained result. If
197 N is nil or 1, and a rear-sticky field ends at point, the point does
198 not move. To ignore field boundaries bind `inhibit-field-text-motion'
212 newpos
= XINT (Fline_end_position (n
));
216 && FETCH_CHAR (PT
- 1) == '\n')
218 /* If we skipped over a newline that follows
219 an invisible intangible run,
220 move back to the last tangible position
226 else if (PT
> newpos
&& PT
< ZV
227 && FETCH_CHAR (PT
) != '\n')
228 /* If we skipped something intangible
229 and now we're not really at eol,
239 DEFUN ("delete-char", Fdelete_char
, Sdelete_char
, 1, 2, "p\nP",
240 doc
: /* Delete the following N characters (previous if N is negative).
241 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
242 Interactively, N is the prefix arg, and KILLFLAG is set if
243 N was explicitly specified.
245 The command `delete-forward' is preferable for interactive use. */)
247 Lisp_Object n
, killflag
;
259 xsignal0 (Qbeginning_of_buffer
);
266 xsignal0 (Qend_of_buffer
);
273 call1 (Qkill_forward_chars
, n
);
278 static int nonundocount
;
280 /* Note that there's code in command_loop_1 which typically avoids
282 DEFUN ("self-insert-command", Fself_insert_command
, Sself_insert_command
, 1, 1, "p",
283 doc
: /* Insert the character you type.
284 Whichever character you type to run this command is inserted.
285 Before insertion, `expand-abbrev' is executed if the inserted character does
286 not have word syntax and the previous character in the buffer does.
287 After insertion, the value of `auto-fill-function' is called if the
288 `auto-fill-chars' table has a non-nil value for the inserted character. */)
292 int remove_boundary
= 1;
295 if (!EQ (Vthis_command
, current_kboard
->Vlast_command
))
298 if (NILP (Vexecuting_kbd_macro
)
299 && !EQ (minibuf_window
, selected_window
))
301 if (nonundocount
<= 0 || nonundocount
>= 20)
310 && CONSP (current_buffer
->undo_list
)
311 && NILP (XCAR (current_buffer
->undo_list
)))
312 /* Remove the undo_boundary that was just pushed. */
313 current_buffer
->undo_list
= XCDR (current_buffer
->undo_list
);
315 /* Barf if the key that invoked this was not a character. */
316 if (!CHARACTERP (last_command_event
))
319 int character
= translate_char (Vtranslation_table_for_input
,
320 XINT (last_command_event
));
321 if (XINT (n
) >= 2 && NILP (current_buffer
->overwrite_mode
))
323 XSETFASTINT (n
, XFASTINT (n
) - 2);
324 /* The first one might want to expand an abbrev. */
325 internal_self_insert (character
, 1);
326 /* The bulk of the copies of this char can be inserted simply.
327 We don't have to handle a user-specified face specially
328 because it will get inherited from the first char inserted. */
329 Finsert_char (make_number (character
), n
, Qt
);
330 /* The last one might want to auto-fill. */
331 internal_self_insert (character
, 0);
337 /* Ok since old and new vals both nonneg */
338 XSETFASTINT (n
, XFASTINT (n
) - 1);
339 val
= internal_self_insert (character
, XFASTINT (n
) != 0);
342 frame_make_pointer_invisible ();
349 /* Insert character C. If NOAUTOFILL is nonzero, don't do autofill
350 even if it is enabled.
352 If this insertion is suitable for direct output (completely simple),
353 return 0. A value of 1 indicates this *might* not have been simple.
354 A value of 2 means this did things that call for an undo boundary. */
356 static Lisp_Object Qexpand_abbrev
;
359 internal_self_insert (int c
, int noautofill
)
363 register enum syntaxcode synt
;
364 Lisp_Object overwrite
, string
;
365 /* Length of multi-byte form of C. */
367 /* Working buffer and pointer for multi-byte form of C. */
368 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
369 int chars_to_delete
= 0;
370 int spaces_to_insert
= 0;
372 overwrite
= current_buffer
->overwrite_mode
;
373 if (!NILP (Vbefore_change_functions
) || !NILP (Vafter_change_functions
))
376 /* At first, get multi-byte form of C in STR. */
377 if (!NILP (current_buffer
->enable_multibyte_characters
))
379 len
= CHAR_STRING (c
, str
);
381 /* If C has modifier bits, this makes C an appropriate
387 str
[0] = (SINGLE_BYTE_CHAR_P (c
)
389 : multibyte_char_to_unibyte (c
, Qnil
));
392 if (!NILP (overwrite
)
395 /* In overwrite-mode, we substitute a character at point (C2,
396 hereafter) by C. For that, we delete C2 in advance. But,
397 just substituting C2 by C may move a remaining text in the
398 line to the right or to the left, which is not preferable.
399 So we insert more spaces or delete more characters in the
400 following cases: if C is narrower than C2, after deleting C2,
401 we fill columns with spaces, if C is wider than C2, we delete
402 C2 and several characters following C2. */
404 /* This is the character after point. */
405 int c2
= FETCH_CHAR (PT_BYTE
);
407 /* Column the cursor should be placed at after this insertion.
408 The correct value should be calculated only when necessary. */
411 /* Overwriting in binary-mode always replaces C2 by C.
412 Overwriting in textual-mode doesn't always do that.
413 It inserts newlines in the usual way,
414 and inserts any character at end of line
415 or before a tab if it doesn't use the whole width of the tab. */
416 if (EQ (overwrite
, Qoverwrite_mode_binary
)
420 && XINT (current_buffer
->tab_width
) > 0
421 && XFASTINT (current_buffer
->tab_width
) < 20
422 && (target_clm
= ((int) current_column () /* iftc */
423 + XINT (Fchar_width (make_number (c
)))),
424 target_clm
% XFASTINT (current_buffer
->tab_width
)))))
427 int pos_byte
= PT_BYTE
;
433 /* The actual cursor position after the trial of moving
434 to column TARGET_CLM. It is greater than TARGET_CLM
435 if the TARGET_CLM is middle of multi-column
436 character. In that case, the new point is set after
439 = XFASTINT (Fmove_to_column (make_number (target_clm
), Qnil
));
441 chars_to_delete
= PT
- pos
;
443 if (actual_clm
> target_clm
)
445 /* We will delete too many columns. Let's fill columns
446 by spaces so that the remaining text won't move. */
447 spaces_to_insert
= actual_clm
- target_clm
;
450 SET_PT_BOTH (pos
, pos_byte
);
458 if (!NILP (current_buffer
->abbrev_mode
)
460 && NILP (current_buffer
->read_only
)
462 && (!NILP (current_buffer
->enable_multibyte_characters
)
463 ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
464 : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
470 sym
= call0 (Qexpand_abbrev
);
472 /* If we expanded an abbrev which has a hook,
473 and the hook has a non-nil `no-self-insert' property,
474 return right away--don't really self-insert. */
475 if (SYMBOLP (sym
) && ! NILP (sym
) && ! NILP (XSYMBOL (sym
)->function
)
476 && SYMBOLP (XSYMBOL (sym
)->function
))
479 prop
= Fget (XSYMBOL (sym
)->function
, intern ("no-self-insert"));
484 if (MODIFF
!= modiff
)
490 string
= make_string_from_bytes (str
, 1, len
);
491 if (spaces_to_insert
)
493 tem
= Fmake_string (make_number (spaces_to_insert
),
495 string
= concat2 (tem
, string
);
498 replace_range (PT
, PT
+ chars_to_delete
, string
, 1, 1, 1);
499 Fforward_char (make_number (1 + spaces_to_insert
));
502 insert_and_inherit (str
, len
);
504 if ((CHAR_TABLE_P (Vauto_fill_chars
)
505 ? !NILP (CHAR_TABLE_REF (Vauto_fill_chars
, c
))
506 : (c
== ' ' || c
== '\n'))
508 && !NILP (current_buffer
->auto_fill_function
))
513 /* After inserting a newline, move to previous line and fill
514 that. Must have the newline in place already so filling and
515 justification, if any, know where the end is going to be. */
516 SET_PT_BOTH (PT
- 1, PT_BYTE
- 1);
517 tem
= call0 (current_buffer
->auto_fill_function
);
518 /* Test PT < ZV in case the auto-fill-function is strange. */
519 if (c
== '\n' && PT
< ZV
)
520 SET_PT_BOTH (PT
+ 1, PT_BYTE
+ 1);
525 /* If previous command specified a face to use, use it. */
526 if (!NILP (Vself_insert_face
)
527 && EQ (current_kboard
->Vlast_command
, Vself_insert_face_command
))
529 Fput_text_property (make_number (PT
- 1), make_number (PT
),
530 Qface
, Vself_insert_face
, Qnil
);
531 Vself_insert_face
= Qnil
;
534 if ((synt
== Sclose
|| synt
== Smath
)
535 && !NILP (Vblink_paren_function
) && INTERACTIVE
538 call0 (Vblink_paren_function
);
544 /* module initialization */
549 Qkill_backward_chars
= intern_c_string ("kill-backward-chars");
550 staticpro (&Qkill_backward_chars
);
552 Qkill_forward_chars
= intern_c_string ("kill-forward-chars");
553 staticpro (&Qkill_forward_chars
);
555 Qoverwrite_mode_binary
= intern_c_string ("overwrite-mode-binary");
556 staticpro (&Qoverwrite_mode_binary
);
558 Qexpand_abbrev
= intern_c_string ("expand-abbrev");
559 staticpro (&Qexpand_abbrev
);
561 DEFVAR_LISP ("self-insert-face", &Vself_insert_face
,
562 doc
: /* If non-nil, set the face of the next self-inserting character to this.
563 See also `self-insert-face-command'. */);
564 Vself_insert_face
= Qnil
;
566 DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command
,
567 doc
: /* This is the command that set up `self-insert-face'.
568 If `last-command' does not equal this value, we ignore `self-insert-face'. */);
569 Vself_insert_face_command
= Qnil
;
571 DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function
,
572 doc
: /* Function called, if non-nil, whenever a close parenthesis is inserted.
573 More precisely, a char with closeparen syntax is self-inserted. */);
574 Vblink_paren_function
= Qnil
;
576 defsubr (&Sforward_point
);
577 defsubr (&Sforward_char
);
578 defsubr (&Sbackward_char
);
579 defsubr (&Sforward_line
);
580 defsubr (&Sbeginning_of_line
);
581 defsubr (&Send_of_line
);
583 defsubr (&Sdelete_char
);
584 defsubr (&Sself_insert_command
);
593 initial_define_key (global_map
, Ctl ('I'), "self-insert-command");
594 for (n
= 040; n
< 0177; n
++)
595 initial_define_key (global_map
, n
, "self-insert-command");
597 for (n
= 0200; n
< 0240; n
++)
598 initial_define_key (global_map
, n
, "self-insert-command");
600 for (n
= 0240; n
< 0400; n
++)
601 initial_define_key (global_map
, n
, "self-insert-command");
603 initial_define_key (global_map
, Ctl ('A'), "beginning-of-line");
604 initial_define_key (global_map
, Ctl ('B'), "backward-char");
605 initial_define_key (global_map
, Ctl ('E'), "end-of-line");
606 initial_define_key (global_map
, Ctl ('F'), "forward-char");
609 /* arch-tag: 022ba3cd-67f9-4978-9c5d-7d2b18d8644e
610 (do not change this comment) */