#include <sys/types.h>
-#include "config.h"
+#include <config.h>
#ifdef VMS
#include "vms-pwd.h"
region_limit (beginningp)
int beginningp;
{
+ extern Lisp_Object Vmark_even_if_inactive; /* Defined in callint.c. */
register Lisp_Object m;
- if (!NILP (Vtransient_mark_mode) && NILP (current_buffer->mark_active))
- error ("There is no region now");
+ if (!NILP (Vtransient_mark_mode) && NILP (Vmark_even_if_inactive)
+ && NILP (current_buffer->mark_active))
+ Fsignal (Qmark_inactive, Qnil);
m = Fmarker_position (current_buffer->mark);
if (NILP (m)) error ("There is no region now");
if ((point < XFASTINT (m)) == beginningp)
Fset_marker (current_buffer->mark, tem, Fcurrent_buffer ());
unchain_marker (tem);
tem = Fcdr (Fcdr (info));
+#if 0 /* We used to make the current buffer visible in the selected window
+ if that was true previously. That avoids some anomalies.
+ But it creates others, and it wasn't documented, and it is simpler
+ and cleaner never to alter the window/buffer connections. */
tem1 = Fcar (tem);
if (!NILP (tem1)
&& current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
Fswitch_to_buffer (Fcurrent_buffer (), Qnil);
+#endif /* 0 */
tem1 = current_buffer->mark_active;
current_buffer->mark_active = Fcdr (tem);
DEFUN ("point-min", Fpoint_min, Spoint_min, 0, 0, 0,
"Return the minimum permissible value of point in the current buffer.\n\
-This is 1, unless a clipping restriction is in effect.")
+This is 1, unless narrowing (a buffer restriction) is in effect.")
()
{
Lisp_Object temp;
DEFUN ("point-min-marker", Fpoint_min_marker, Spoint_min_marker, 0, 0, 0,
"Return a marker to the minimum permissible value of point in this buffer.\n\
-This is the beginning, unless a clipping restriction is in effect.")
+This is the beginning, unless narrowing (a buffer restriction) is in effect.")
()
{
return buildmark (BEGV);
DEFUN ("point-max", Fpoint_max, Spoint_max, 0, 0, 0,
"Return the maximum permissible value of point in the current buffer.\n\
-This is (1+ (buffer-size)), unless a clipping restriction is in effect,\n\
-in which case it is less.")
+This is (1+ (buffer-size)), unless narrowing (a buffer restriction)\n\
+is in effect, in which case it is less.")
()
{
Lisp_Object temp;
DEFUN ("point-max-marker", Fpoint_max_marker, Spoint_max_marker, 0, 0, 0,
"Return a marker to the maximum permissible value of point in this buffer.\n\
-This is (1+ (buffer-size)), unless a clipping restriction is in effect,\n\
-in which case it is less.")
+This is (1+ (buffer-size)), unless narrowing (a buffer restriction)\n\
+is in effect, in which case it is less.")
()
{
return buildmark (ZV);
}
else if (XTYPE (tem) == Lisp_String)
{
- insert_from_string (tem, 0, XSTRING (tem)->size);
+ insert_from_string (tem, 0, XSTRING (tem)->size, 0);
+ }
+ else
+ {
+ tem = wrong_type_argument (Qchar_or_string_p, tem);
+ goto retry;
+ }
+ }
+
+ return Qnil;
+}
+
+DEFUN ("insert-and-inherit", Finsert_and_inherit, Sinsert_and_inherit,
+ 0, MANY, 0,
+ "Insert the arguments at point, inheriting properties from adjoining text.\n\
+Point moves forward so that it ends up after the inserted text.\n\
+Any other markers at the point of insertion remain before the text.")
+ (nargs, args)
+ int nargs;
+ register Lisp_Object *args;
+{
+ register int argnum;
+ register Lisp_Object tem;
+ char str[1];
+
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ tem = args[argnum];
+ retry:
+ if (XTYPE (tem) == Lisp_Int)
+ {
+ str[0] = XINT (tem);
+ insert (str, 1);
+ }
+ else if (XTYPE (tem) == Lisp_String)
+ {
+ insert_from_string (tem, 0, XSTRING (tem)->size, 1);
}
else
{
}
else if (XTYPE (tem) == Lisp_String)
{
- insert_from_string_before_markers (tem, 0, XSTRING (tem)->size);
+ insert_from_string_before_markers (tem, 0, XSTRING (tem)->size, 0);
+ }
+ else
+ {
+ tem = wrong_type_argument (Qchar_or_string_p, tem);
+ goto retry;
+ }
+ }
+
+ return Qnil;
+}
+
+DEFUN ("insert-before-markers-and-inherit",
+ Finsert_and_inherit_before_markers, Sinsert_and_inherit_before_markers,
+ 0, MANY, 0,
+ "Insert text at point, relocating markers and inheriting properties.\n\
+Point moves forward so that it ends up after the inserted text.\n\
+Any other markers at the point of insertion also end up after the text.")
+ (nargs, args)
+ int nargs;
+ register Lisp_Object *args;
+{
+ register int argnum;
+ register Lisp_Object tem;
+ char str[1];
+
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ tem = args[argnum];
+ retry:
+ if (XTYPE (tem) == Lisp_Int)
+ {
+ str[0] = XINT (tem);
+ insert_before_markers (str, 1);
+ }
+ else if (XTYPE (tem) == Lisp_String)
+ {
+ insert_from_string_before_markers (tem, 0, XSTRING (tem)->size, 1);
}
else
{
/* Return a Lisp_String containing the text of the current buffer from
START to END. If text properties are in use and the current buffer
- has properties in the range specifed, the resulting string will also
+ has properties in the range specified, the resulting string will also
have them.
We don't want to use plain old make_string here, because it calls
make_buffer_string (start, end)
int start, end;
{
- Lisp_Object result;
+ Lisp_Object result, tem;
if (start < GPT && GPT < end)
move_gap (start);
result = make_uninit_string (end - start);
bcopy (&FETCH_CHAR (start), XSTRING (result)->data, end - start);
- /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
- copy_intervals_to_string (result, current_buffer, start, end - start);
+ tem = Fnext_property_change (make_number (start), Qnil, make_number (end));
+
+#ifdef USE_TEXT_PROPERTIES
+ if (XINT (tem) != end)
+ copy_intervals_to_string (result, current_buffer, start, end - start);
+#endif
return result;
}
DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_substring,
1, 3, 0,
- "Insert before point a substring of the contents buffer BUFFER.\n\
+ "Insert before point a substring of the contents of buffer BUFFER.\n\
BUFFER may be a buffer or a buffer name.\n\
Arguments START and END are character numbers specifying the substring.\n\
They default to the beginning and the end of BUFFER.")
/* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
graft_intervals_into_buffer (copy_intervals (bp->intervals, start, len),
- opoint, bp);
+ opoint, len, current_buffer, 0);
return Qnil;
}
Lisp_Object start, end, fromchar, tochar, noundo;
{
register int pos, stop, look;
+ int changed = 0;
validate_region (&start, &end);
CHECK_NUMBER (fromchar, 2);
stop = XINT (end);
look = XINT (fromchar);
- modify_region (current_buffer, pos, stop);
if (! NILP (noundo))
{
if (MODIFF - 1 == current_buffer->save_modified)
{
if (FETCH_CHAR (pos) == look)
{
+ if (! changed)
+ {
+ modify_region (current_buffer, XINT (start), stop);
+ changed = 1;
+ }
+
if (NILP (noundo))
record_change (pos, 1);
FETCH_CHAR (pos) = XINT (tochar);
- if (NILP (noundo))
- signal_after_change (pos, 1, 1);
}
pos++;
}
+ if (changed)
+ signal_after_change (XINT (start),
+ stop - XINT (start), stop - XINT (start));
+
return Qnil;
}
else if (XTYPE (args[n]) == Lisp_Int && *format != 's')
{
#ifdef LISP_FLOAT_TYPE
- /* The following loop issumes the Lisp type indicates
+ /* 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
be a double. */
{
register int nstrings = n + 1;
+
+ /* Allocate twice as many strings as we have %-escapes; floats occupy
+ two slots, and we're not sure how many of those we have. */
register unsigned char **strings
- = (unsigned char **) alloca (nstrings * sizeof (unsigned char *));
+ = (unsigned char **) alloca (2 * nstrings * sizeof (unsigned char *));
+ int i;
+ i = 0;
for (n = 0; n < nstrings; n++)
{
if (n >= nargs)
- strings[n] = (unsigned char *) "";
+ strings[i++] = (unsigned char *) "";
else if (XTYPE (args[n]) == Lisp_Int)
/* We checked above that the corresponding format effector
isn't %s, which would cause MPV. */
- strings[n] = (unsigned char *) XINT (args[n]);
+ strings[i++] = (unsigned char *) XINT (args[n]);
#ifdef LISP_FLOAT_TYPE
else if (XTYPE (args[n]) == Lisp_Float)
{
union { double d; int half[2]; } u;
u.d = XFLOAT (args[n])->data;
- strings[n++] = (unsigned char *) u.half[0];
- strings[n] = (unsigned char *) u.half[1];
+ strings[i++] = (unsigned char *) u.half[0];
+ strings[i++] = (unsigned char *) u.half[1];
}
#endif
else
- strings[n] = XSTRING (args[n])->data;
+ strings[i++] = XSTRING (args[n])->data;
}
/* Format it in bigger and bigger buf's until it all fits. */
buf = (char *) alloca (total + 1);
buf[total - 1] = 0;
- length = doprnt (buf, total + 1, strings[0], end, nargs, strings + 1);
+ length = doprnt (buf, total + 1, strings[0], end, i-1, strings + 1);
if (buf[total - 1] == 0)
break;
void
syms_of_editfns ()
{
- DEFVAR_LISP ("system-name", &Vsystem_name,
- "The name of the machine Emacs is running on.");
-
- DEFVAR_LISP ("user-full-name", &Vuser_full_name,
- "The full name of the user logged in.");
-
- DEFVAR_LISP ("user-name", &Vuser_name,
- "The user's name, based on the effective uid.");
-
- DEFVAR_LISP ("user-real-name", &Vuser_real_name,
- "The user's name, base upon the real uid.");
+ staticpro (&Vuser_name);
+ staticpro (&Vuser_full_name);
+ staticpro (&Vuser_real_name);
+ staticpro (&Vsystem_name);
defsubr (&Schar_equal);
defsubr (&Sgoto_char);
defsubr (&Schar_after);
defsubr (&Sinsert);
defsubr (&Sinsert_before_markers);
+ defsubr (&Sinsert_and_inherit);
+ defsubr (&Sinsert_and_inherit_before_markers);
defsubr (&Sinsert_char);
defsubr (&Suser_login_name);