#include "dispextern.h"
#include "frame.h"
-Lisp_Object Qkill_forward_chars, Qkill_backward_chars, Vblink_paren_function;
+Lisp_Object Qkill_forward_chars, Qkill_backward_chars;
/* A possible value for a buffer's overwrite-mode variable. */
Lisp_Object Qoverwrite_mode_binary;
-/* Non-nil means put this face on the next self-inserting character. */
-Lisp_Object Vself_insert_face;
-
-/* This is the command that set up Vself_insert_face. */
-Lisp_Object Vself_insert_face_command;
-
-extern Lisp_Object Qface;
-extern Lisp_Object Vtranslation_table_for_input;
+static int internal_self_insert (int, int);
\f
DEFUN ("forward-point", Fforward_point, Sforward_point, 1, 1, 0,
doc: /* Return buffer position N characters after (before if N negative) point. */)
DEFUN ("forward-line", Fforward_line, Sforward_line, 0, 1, "^p",
doc: /* Move N lines forward (backward if N is negative).
-Precisely, if point is on line I, move to the start of line I + N.
+Precisely, if point is on line I, move to the start of line I + N
+\("start of line" in the logical order).
If there isn't room, go as far as possible (no error).
Returns the count of lines left to move. If moving forward,
that is N - number of lines moved; if backward, N + number moved.
}
DEFUN ("beginning-of-line", Fbeginning_of_line, Sbeginning_of_line, 0, 1, "^p",
- doc: /* Move point to beginning of current line.
+ doc: /* Move point to beginning of current line (in the logical order).
With argument N not nil or 1, move forward N - 1 lines first.
If point reaches the beginning or end of buffer, it stops there.
}
DEFUN ("end-of-line", Fend_of_line, Send_of_line, 0, 1, "^p",
- doc: /* Move point to end of current line.
+ doc: /* Move point to end of current line (in the logical order).
With argument N not nil or 1, move forward N - 1 lines first.
If point reaches the beginning or end of buffer, it stops there.
To ignore intangibility, bind `inhibit-point-motion-hooks' to t.
{
int character = translate_char (Vtranslation_table_for_input,
XINT (last_command_event));
- if (XINT (n) >= 2 && NILP (current_buffer->overwrite_mode))
- {
- XSETFASTINT (n, XFASTINT (n) - 2);
- /* The first one might want to expand an abbrev. */
- internal_self_insert (character, 1);
- /* The bulk of the copies of this char can be inserted simply.
- We don't have to handle a user-specified face specially
- because it will get inherited from the first char inserted. */
- Finsert_char (make_number (character), n, Qt);
- /* The last one might want to auto-fill. */
- internal_self_insert (character, 0);
- }
- else
- while (XINT (n) > 0)
- {
- int val;
- /* Ok since old and new vals both nonneg */
- XSETFASTINT (n, XFASTINT (n) - 1);
- val = internal_self_insert (character, XFASTINT (n) != 0);
- if (val == 2)
- nonundocount = 0;
- frame_make_pointer_invisible ();
- }
+ int val = internal_self_insert (character, XFASTINT (n));
+ if (val == 2)
+ nonundocount = 0;
+ frame_make_pointer_invisible ();
}
return Qnil;
}
-/* Insert character C. If NOAUTOFILL is nonzero, don't do autofill
- even if it is enabled.
+/* Insert N times character C
If this insertion is suitable for direct output (completely simple),
return 0. A value of 1 indicates this *might* not have been simple.
A value of 2 means this did things that call for an undo boundary. */
static Lisp_Object Qexpand_abbrev;
+static Lisp_Object Qpost_self_insert_hook, Vpost_self_insert_hook;
-int
-internal_self_insert (int c, int noautofill)
+static int
+internal_self_insert (int c, int n)
{
int hairy = 0;
Lisp_Object tem;
register enum syntaxcode synt;
- Lisp_Object overwrite, string;
+ Lisp_Object overwrite;
/* Length of multi-byte form of C. */
int len;
/* Working buffer and pointer for multi-byte form of C. */
/* This is the character after point. */
int c2 = FETCH_CHAR (PT_BYTE);
- /* Column the cursor should be placed at after this insertion.
- The correct value should be calculated only when necessary. */
- int target_clm = 0;
-
/* Overwriting in binary-mode always replaces C2 by C.
Overwriting in textual-mode doesn't always do that.
It inserts newlines in the usual way,
and inserts any character at end of line
or before a tab if it doesn't use the whole width of the tab. */
- if (EQ (overwrite, Qoverwrite_mode_binary)
- || (c != '\n'
- && c2 != '\n'
- && ! (c2 == '\t'
- && XINT (current_buffer->tab_width) > 0
- && XFASTINT (current_buffer->tab_width) < 20
- && (target_clm = ((int) current_column () /* iftc */
- + XINT (Fchar_width (make_number (c)))),
- target_clm % XFASTINT (current_buffer->tab_width)))))
+ if (EQ (overwrite, Qoverwrite_mode_binary))
+ chars_to_delete = n;
+ else if (c != '\n' && c2 != '\n')
{
int pos = PT;
int pos_byte = PT_BYTE;
+ /* Column the cursor should be placed at after this insertion.
+ The correct value should be calculated only when necessary. */
+ int target_clm = ((int) current_column () /* iftc */
+ + n * XINT (Fchar_width (make_number (c))));
- if (target_clm == 0)
- chars_to_delete = 1;
- else
- {
/* The actual cursor position after the trial of moving
to column TARGET_CLM. It is greater than TARGET_CLM
if the TARGET_CLM is middle of multi-column
chars_to_delete = PT - pos;
if (actual_clm > target_clm)
- {
- /* We will delete too many columns. Let's fill columns
+ { /* We will delete too many columns. Let's fill columns
by spaces so that the remaining text won't move. */
+ EMACS_INT actual = PT_BYTE;
+ DEC_POS (actual);
+ if (FETCH_CHAR (actual) == '\t')
+ /* Rather than add spaces, let's just keep the tab. */
+ chars_to_delete--;
+ else
spaces_to_insert = actual_clm - target_clm;
}
- }
+
SET_PT_BOTH (pos, pos_byte);
- hairy = 2;
}
hairy = 2;
}
&& synt != Sword
&& NILP (current_buffer->read_only)
&& PT > BEGV
- && (!NILP (current_buffer->enable_multibyte_characters)
- ? SYNTAX (XFASTINT (Fprevious_char ())) == Sword
- : (SYNTAX (UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
- == Sword)))
+ && (SYNTAX (!NILP (current_buffer->enable_multibyte_characters)
+ ? XFASTINT (Fprevious_char ())
+ : UNIBYTE_TO_CHAR (XFASTINT (Fprevious_char ())))
+ == Sword))
{
int modiff = MODIFF;
Lisp_Object sym;
if (chars_to_delete)
{
- string = make_string_from_bytes (str, 1, len);
+ int mc = ((NILP (current_buffer->enable_multibyte_characters)
+ && SINGLE_BYTE_CHAR_P (c))
+ ? UNIBYTE_TO_CHAR (c) : c);
+ Lisp_Object string = Fmake_string (make_number (n), make_number (mc));
+
if (spaces_to_insert)
{
tem = Fmake_string (make_number (spaces_to_insert),
make_number (' '));
- string = concat2 (tem, string);
+ string = concat2 (string, tem);
}
replace_range (PT, PT + chars_to_delete, string, 1, 1, 1);
- Fforward_char (make_number (1 + spaces_to_insert));
+ Fforward_char (make_number (n + spaces_to_insert));
+ }
+ else if (n > 1)
+ {
+ USE_SAFE_ALLOCA;
+ unsigned char *strn, *p;
+ SAFE_ALLOCA (strn, unsigned char*, n * len);
+ for (p = strn; n > 0; n--, p += len)
+ memcpy (p, str, len);
+ insert_and_inherit (strn, p - strn);
+ SAFE_FREE ();
}
else
insert_and_inherit (str, len);
if ((CHAR_TABLE_P (Vauto_fill_chars)
? !NILP (CHAR_TABLE_REF (Vauto_fill_chars, c))
: (c == ' ' || c == '\n'))
- && !noautofill
&& !NILP (current_buffer->auto_fill_function))
{
Lisp_Object tem;
hairy = 2;
}
- /* If previous command specified a face to use, use it. */
- if (!NILP (Vself_insert_face)
- && EQ (current_kboard->Vlast_command, Vself_insert_face_command))
- {
- Fput_text_property (make_number (PT - 1), make_number (PT),
- Qface, Vself_insert_face, Qnil);
- Vself_insert_face = Qnil;
- }
+ /* Run hooks for electric keys. */
+ call1 (Vrun_hooks, Qpost_self_insert_hook);
- if ((synt == Sclose || synt == Smath)
- && !NILP (Vblink_paren_function) && INTERACTIVE
- && !noautofill)
- {
- call0 (Vblink_paren_function);
- hairy = 2;
- }
return hairy;
}
\f
Qexpand_abbrev = intern_c_string ("expand-abbrev");
staticpro (&Qexpand_abbrev);
- DEFVAR_LISP ("self-insert-face", &Vself_insert_face,
- doc: /* If non-nil, set the face of the next self-inserting character to this.
-See also `self-insert-face-command'. */);
- Vself_insert_face = Qnil;
-
- DEFVAR_LISP ("self-insert-face-command", &Vself_insert_face_command,
- doc: /* This is the command that set up `self-insert-face'.
-If `last-command' does not equal this value, we ignore `self-insert-face'. */);
- Vself_insert_face_command = Qnil;
+ Qpost_self_insert_hook = intern_c_string ("post-self-insert-hook");
+ staticpro (&Qpost_self_insert_hook);
- DEFVAR_LISP ("blink-paren-function", &Vblink_paren_function,
- doc: /* Function called, if non-nil, whenever a close parenthesis is inserted.
-More precisely, a char with closeparen syntax is self-inserted. */);
- Vblink_paren_function = Qnil;
+ DEFVAR_LISP ("post-self-insert-hook", &Vpost_self_insert_hook,
+ doc: /* Hook run at the end of `self-insert-command'.
+This is run after inserting the character. */);
+ Vpost_self_insert_hook = Qnil;
defsubr (&Sforward_point);
defsubr (&Sforward_char);