Lisp_Object Fuser_full_name ();
+/* Non-nil means don't stop at field boundary in text motion commands. */
+
+Lisp_Object Vinhibit_field_text_motion;
+
/* Some static data, and a function to initialize it for each run */
Lisp_Object Vsystem_name;
Lisp_Object character;
{
int len;
- unsigned char workbuf[4], *str;
+ unsigned char str[MAX_MULTIBYTE_LENGTH];
CHECK_NUMBER (character, 0);
- len = CHAR_STRING (XFASTINT (character), workbuf, str);
+ len = CHAR_STRING (XFASTINT (character), str);
return make_string_from_bytes (str, 1, len);
}
if (EQ (rear_non_sticky, Qnil)
|| (CONSP (rear_non_sticky)
- && !Fmemq (prop, rear_non_sticky)))
+ && NILP (Fmemq (prop, rear_non_sticky))))
/* PROP is not rear-non-sticky, and since this takes precedence over
any front-stickiness, PROP is inherited from before. */
return -1;
if (EQ (front_sticky, Qt)
|| (CONSP (front_sticky)
- && Fmemq (prop, front_sticky)))
+ && !NILP (Fmemq (prop, front_sticky))))
/* PROP is inherited from after. */
return 1;
NEW-POS would move it to a different line, NEW-POS is returned\n\
unconstrained. This useful for commands that move by line, like\n\
\\[next-line] or \\[beginning-of-line], which should generally respect field boundaries\n\
-only in the case where they can still move to the right line.")
+only in the case where they can still move to the right line.\n\
+\n\
+Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.")
(new_pos, old_pos, escape_from_edge, only_in_line)
Lisp_Object new_pos, old_pos, escape_from_edge, only_in_line;
{
XSETFASTINT (new_pos, PT);
}
- if (!EQ (new_pos, old_pos) && !text_property_eq (Qfield, new_pos, old_pos))
+ if (NILP (Vinhibit_field_text_motion)
+ && !EQ (new_pos, old_pos)
+ && !text_property_eq (Qfield, new_pos, old_pos))
/* NEW_POS is not within the same field as OLD_POS; try to
move NEW_POS so that it is. */
{
With argument N not nil or 1, move forward N - 1 lines first.\n\
If scan reaches end of buffer, return that position.\n\
The scan does not cross a field boundary unless it would move\n\
-beyond there to a different line. And if N is nil or 1,\n\
-and scan starts at a field boundary, the scan stops as soon as it starts.\n\n\
+beyond there to a different line. Field boundaries are not noticed if\n\
+`inhibit-field-text-motion' is non-nil. .And if N is nil or 1,\n\
+and scan starts at a field boundary, the scan stops as soon as it starts.\n\
+\n\
This function does not move point.")
(n)
Lisp_Object n;
end_pos = find_before_next_newline (orig, 0, XINT (n) - (XINT (n) <= 0));
/* Return END_POS constrained to the current input field. */
- return
- Fconstrain_to_field (make_number (end_pos), make_number (orig), Qnil, Qt);
+ return Fconstrain_to_field (make_number (end_pos), make_number (orig),
+ Qnil, Qt);
}
\f
Lisp_Object
\f
DEFUN ("following-char", Ffollowing_char, Sfollowing_char, 0, 0, 0,
"Return the character following point, as a number.\n\
-At the end of the buffer or accessible region, return 0.\n\
-If `enable-multibyte-characters' is nil or point is not\n\
- at character boundary, multibyte form is ignored,\n\
- and only one byte following point is returned as a character.")
+At the end of the buffer or accessible region, return 0.")
()
{
Lisp_Object temp;
DEFUN ("preceding-char", Fprevious_char, Sprevious_char, 0, 0, 0,
"Return the character preceding point, as a number.\n\
-At the beginning of the buffer or accessible region, return 0.\n\
-If `enable-multibyte-characters' is nil or point is not\n\
- at character boundary, multi-byte form is ignored,\n\
- and only one byte preceding point is returned as a character.")
+At the beginning of the buffer or accessible region, return 0.")
()
{
Lisp_Object temp;
DEFUN ("char-after", Fchar_after, Schar_after, 0, 1, 0,
"Return character in current buffer at position POS.\n\
-POS is an integer or a buffer pointer.\n\
+POS is an integer or a marker.\n\
If POS is out of range, the value is nil.")
(pos)
Lisp_Object pos;
DEFUN ("char-before", Fchar_before, Schar_before, 0, 1, 0,
"Return character in current buffer preceding position POS.\n\
-POS is an integer or a buffer pointer.\n\
+POS is an integer or a marker.\n\
If POS is out of range, the value is nil.")
(pos)
Lisp_Object pos;
retry:
if (INTEGERP (val))
{
- unsigned char workbuf[4], *str;
+ unsigned char str[MAX_MULTIBYTE_LENGTH];
int len;
if (!NILP (current_buffer->enable_multibyte_characters))
- len = CHAR_STRING (XFASTINT (val), workbuf, str);
+ len = CHAR_STRING (XFASTINT (val), str);
else
{
- workbuf[0] = (SINGLE_BYTE_CHAR_P (XINT (val))
- ? XINT (val)
- : multibyte_char_to_unibyte (XINT (val), Qnil));
- str = workbuf;
+ str[0] = (SINGLE_BYTE_CHAR_P (XINT (val))
+ ? XINT (val)
+ : multibyte_char_to_unibyte (XINT (val), Qnil));
len = 1;
}
(*insert_func) (str, len);
register int strlen;
register int i, n;
int len;
- unsigned char workbuf[4], *str;
+ unsigned char str[MAX_MULTIBYTE_LENGTH];
CHECK_NUMBER (character, 0);
CHECK_NUMBER (count, 1);
if (!NILP (current_buffer->enable_multibyte_characters))
- len = CHAR_STRING (XFASTINT (character), workbuf, str);
+ len = CHAR_STRING (XFASTINT (character), str);
else
- workbuf[0] = XFASTINT (character), str = workbuf, len = 1;
+ str[0] = XFASTINT (character), len = 1;
n = XINT (count) * len;
if (n <= 0)
return Qnil;
{
register int pos, pos_byte, stop, i, len, end_byte;
int changed = 0;
- unsigned char fromwork[4], *fromstr, towork[4], *tostr, *p;
+ unsigned char fromstr[MAX_MULTIBYTE_LENGTH], tostr[MAX_MULTIBYTE_LENGTH];
+ unsigned char *p;
int count = specpdl_ptr - specpdl;
#define COMBINING_NO 0
#define COMBINING_BEFORE 1
#define COMBINING_AFTER 2
#define COMBINING_BOTH (COMBINING_BEFORE | COMBINING_AFTER)
int maybe_byte_combining = COMBINING_NO;
+ int last_changed;
+ int multibyte_p = !NILP (current_buffer->enable_multibyte_characters);
validate_region (&start, &end);
CHECK_NUMBER (fromchar, 2);
CHECK_NUMBER (tochar, 3);
- if (! NILP (current_buffer->enable_multibyte_characters))
+ if (multibyte_p)
{
- len = CHAR_STRING (XFASTINT (fromchar), fromwork, fromstr);
- if (CHAR_STRING (XFASTINT (tochar), towork, tostr) != len)
+ len = CHAR_STRING (XFASTINT (fromchar), fromstr);
+ if (CHAR_STRING (XFASTINT (tochar), tostr) != len)
error ("Characters in subst-char-in-region have different byte-lengths");
if (!ASCII_BYTE_P (*tostr))
{
else
{
len = 1;
- fromwork[0] = XFASTINT (fromchar), fromstr = fromwork;
- towork[0] = XFASTINT (tochar), tostr = towork;
+ fromstr[0] = XFASTINT (fromchar);
+ tostr[0] = XFASTINT (tochar);
}
pos = XINT (start);
stop = end_byte;
}
p = BYTE_POS_ADDR (pos_byte);
- INC_POS (pos_byte_next);
+ if (multibyte_p)
+ INC_POS (pos_byte_next);
+ else
+ ++pos_byte_next;
if (pos_byte_next - pos_byte == len
&& p[0] == fromstr[0]
&& (len == 1
{
if (! changed)
{
- modify_region (current_buffer, XINT (start), XINT (end));
+ changed = pos;
+ modify_region (current_buffer, changed, XINT (end));
if (! NILP (noundo))
{
if (MODIFF - 1 == current_buffer->auto_save_modified)
current_buffer->auto_save_modified++;
}
-
- changed = 1;
}
/* Take care of the case where the new character
record_change (pos, 1);
for (i = 0; i < len; i++) *p++ = tostr[i];
}
+ last_changed = pos + 1;
}
pos_byte = pos_byte_next;
pos++;
}
if (changed)
- signal_after_change (XINT (start),
- XINT (end) - XINT (start), XINT (end) - XINT (start));
+ {
+ signal_after_change (changed,
+ last_changed - changed, last_changed - changed);
+ update_compositions (changed, last_changed, CHECK_ALL);
+ }
unbind_to (count, Qnil);
return Qnil;
record_change (pos, 1);
*p = nc;
signal_after_change (pos, 1, 1);
+ update_compositions (pos, pos + 1, CHECK_BORDER);
}
++cnt;
}
del_range (XINT (start), XINT (end));
return Qnil;
}
+
+DEFUN ("delete-and-extract-region", Fdelete_and_extract_region,
+ Sdelete_and_extract_region, 2, 2, 0,
+ "Delete the text between START and END and return it.")
+ (start, end)
+ Lisp_Object start, end;
+{
+ validate_region (&start, &end);
+ return del_range_1 (XINT (start), XINT (end), 1, 1);
+}
\f
DEFUN ("widen", Fwiden, Swiden, 0, 0, "",
"Remove restrictions (narrowing) from current buffer.\n\
{
#ifdef HAVE_MENUS
if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
- && NILP (use_dialog_box))
+ && use_dialog_box)
return Fmessage_box (nargs, args);
#endif
return Fmessage (nargs, args);
DEFUN ("propertize", Fpropertize, Spropertize, 3, MANY, 0,
"Return a copy of STRING with text properties added.\n\
First argument is the string to copy.\n\
-Remaining arguments are sequences of PROPERTY VALUE pairs for text\n\
+Remaining arguments form a sequence of PROPERTY VALUE pairs for text\n\
properties to add to the result ")
(nargs, args)
int nargs;
}
else if (SYMBOLP (args[n]))
{
- XSETSTRING (args[n], XSYMBOL (args[n])->name);
+ /* Use a temp var to avoid problems when ENABLE_CHECKING
+ is turned on. */
+ struct Lisp_String *t = XSYMBOL (args[n])->name;
+ XSETSTRING (args[n], t);
if (STRING_MULTIBYTE (args[n]) && ! multibyte)
{
multibyte = 1;
/* Would get MPV otherwise, since Lisp_Int's `point' to low memory. */
else if (INTEGERP (args[n]) && *format != 's')
{
-#ifdef LISP_FLOAT_TYPE
/* The following loop assumes the Lisp type indicates
the proper way to pass the argument.
So make sure we have a flonum if the argument should
if (*format == 'e' || *format == 'f' || *format == 'g')
args[n] = Ffloat (args[n]);
else
-#endif
if (*format != 'd' && *format != 'o' && *format != 'x'
&& *format != 'i' && *format != 'X' && *format != 'c')
error ("Invalid format operation %%%c", *format);
thissize = STRING_BYTES (XSTRING (args[n]));
}
}
-#ifdef LISP_FLOAT_TYPE
else if (FLOATP (args[n]) && *format != 's')
{
if (! (*format == 'e' || *format == 'f' || *format == 'g'))
args[n] = Ftruncate (args[n], Qnil);
thissize = 200;
}
-#endif
else
{
/* Anything but a string, convert to a string using princ. */
len1, current_buffer, 0);
graft_intervals_into_buffer (tmp_interval2, start1,
len2, current_buffer, 0);
+ update_compositions (start1, start1 + len2, CHECK_BORDER);
+ update_compositions (start1 + len2, end2, CHECK_TAIL);
}
/* Non-adjacent regions, because end1 != start2, bleagh... */
else
graft_intervals_into_buffer (tmp_interval2, start1,
len2, current_buffer, 0);
}
+
+ update_compositions (start1, start1 + len2, CHECK_BORDER);
+ update_compositions (end2 - len1, end2, CHECK_BORDER);
}
/* When doing multiple transpositions, it might be nice
= intern ("buffer-access-fontify-functions");
staticpro (&Qbuffer_access_fontify_functions);
+ DEFVAR_LISP ("inhibit-field-text-motion", &Vinhibit_field_text_motion,
+ "Non-nil means.text motion commands don't notice fields.");
+ Vinhibit_field_text_motion = Qnil;
+
DEFVAR_LISP ("buffer-access-fontify-functions",
&Vbuffer_access_fontify_functions,
"List of functions called by `buffer-substring' to fontify if necessary.\n\
defsubr (&Ssubst_char_in_region);
defsubr (&Stranslate_region);
defsubr (&Sdelete_region);
+ defsubr (&Sdelete_and_extract_region);
defsubr (&Swiden);
defsubr (&Snarrow_to_region);
defsubr (&Ssave_restriction);