/* undo handling for GNU Emacs.
- Copyright (C) 1990, 1993, 1994 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1993, 1994, 2000 Free Software Foundation, Inc.
This file is part of GNU Emacs.
an undo-boundary. */
Lisp_Object pending_boundary;
+/* Record point as it was at beginning of this command (if necessary)
+ And prepare the undo info for recording a change.
+ PT is the position of point that will naturally occur as a result of the
+ undo record that will be added just after this command terminates. */
+
+static void
+record_point (pt)
+ int pt;
+{
+ int at_boundary;
+
+ /* Allocate a cons cell to be the undo boundary after this command. */
+ if (NILP (pending_boundary))
+ pending_boundary = Fcons (Qnil, Qnil);
+
+ if (!BUFFERP (last_undo_buffer)
+ || current_buffer != XBUFFER (last_undo_buffer))
+ Fundo_boundary ();
+ XSETBUFFER (last_undo_buffer, current_buffer);
+
+ if (CONSP (current_buffer->undo_list))
+ {
+ /* Set AT_BOUNDARY to 1 only when we have nothing other than
+ marker adjustment before undo boundary. */
+
+ Lisp_Object tail = current_buffer->undo_list, elt;
+
+ while (1)
+ {
+ if (NILP (tail))
+ elt = Qnil;
+ else
+ elt = XCAR (tail);
+ if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
+ break;
+ tail = XCDR (tail);
+ }
+ at_boundary = NILP (elt);
+ }
+ else
+ at_boundary = 1;
+
+ if (MODIFF <= SAVE_MODIFF)
+ record_first_change ();
+
+ /* If we are just after an undo boundary, and
+ point wasn't at start of deleted range, record where it was. */
+ if (at_boundary
+ && last_point_position != pt
+ /* If we're called from batch mode, this could be nil. */
+ && BUFFERP (last_point_position_buffer)
+ && current_buffer == XBUFFER (last_point_position_buffer))
+ current_buffer->undo_list
+ = Fcons (make_number (last_point_position), current_buffer->undo_list);
+}
+
/* Record an insertion that just happened or is about to happen,
for LENGTH characters at position BEG.
(It is possible to record an insertion before or after the fact
if (EQ (current_buffer->undo_list, Qt))
return;
- /* Allocate a cons cell to be the undo boundary after this command. */
- if (NILP (pending_boundary))
- pending_boundary = Fcons (Qnil, Qnil);
-
- if (current_buffer != XBUFFER (last_undo_buffer))
- Fundo_boundary ();
- XSETBUFFER (last_undo_buffer, current_buffer);
-
- if (MODIFF <= SAVE_MODIFF)
- record_first_change ();
+ record_point (beg);
/* If this is following another insertion and consecutive with it
in the buffer, combine the two. */
if (CONSP (current_buffer->undo_list))
{
Lisp_Object elt;
- elt = XCONS (current_buffer->undo_list)->car;
+ elt = XCAR (current_buffer->undo_list);
if (CONSP (elt)
- && INTEGERP (XCONS (elt)->car)
- && INTEGERP (XCONS (elt)->cdr)
- && XINT (XCONS (elt)->cdr) == beg)
+ && INTEGERP (XCAR (elt))
+ && INTEGERP (XCDR (elt))
+ && XINT (XCDR (elt)) == beg)
{
- XSETINT (XCONS (elt)->cdr, beg + length);
+ XSETCDR (elt, make_number (beg + length));
return;
}
}
Lisp_Object string;
{
Lisp_Object sbeg;
- int at_boundary;
if (EQ (current_buffer->undo_list, Qt))
return;
- /* Allocate a cons cell to be the undo boundary after this command. */
- if (NILP (pending_boundary))
- pending_boundary = Fcons (Qnil, Qnil);
-
- if (current_buffer != XBUFFER (last_undo_buffer))
- Fundo_boundary ();
- XSETBUFFER (last_undo_buffer, current_buffer);
-
- at_boundary = (CONSP (current_buffer->undo_list)
- && NILP (XCONS (current_buffer->undo_list)->car));
-
- if (MODIFF <= SAVE_MODIFF)
- record_first_change ();
-
- if (PT == beg + XSTRING (string)->size)
- XSETINT (sbeg, -beg);
+ if (PT == beg + SCHARS (string))
+ {
+ XSETINT (sbeg, -beg);
+ record_point (PT);
+ }
else
- XSETFASTINT (sbeg, beg);
-
- /* If we are just after an undo boundary, and
- point wasn't at start of deleted range, record where it was. */
- if (at_boundary
- && last_point_position != XFASTINT (sbeg)
- && current_buffer == XBUFFER (last_point_position_buffer))
- current_buffer->undo_list
- = Fcons (make_number (last_point_position), current_buffer->undo_list);
+ {
+ XSETFASTINT (sbeg, beg);
+ record_point (beg);
+ }
current_buffer->undo_list
= Fcons (Fcons (string, sbeg), current_buffer->undo_list);
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
- if (current_buffer != XBUFFER (last_undo_buffer))
+ if (!BUFFERP (last_undo_buffer)
+ || current_buffer != XBUFFER (last_undo_buffer))
Fundo_boundary ();
XSETBUFFER (last_undo_buffer, current_buffer);
if (EQ (current_buffer->undo_list, Qt))
return;
- if (current_buffer != XBUFFER (last_undo_buffer))
+ if (!BUFFERP (last_undo_buffer)
+ || current_buffer != XBUFFER (last_undo_buffer))
Fundo_boundary ();
XSETBUFFER (last_undo_buffer, current_buffer);
}
DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
- "Mark a boundary between units of undo.\n\
-An undo command will stop at this point,\n\
-but another undo command will undo to the previous boundary.")
- ()
+ doc: /* Mark a boundary between units of undo.
+An undo command will stop at this point,
+but another undo command will undo to the previous boundary. */)
+ ()
{
Lisp_Object tem;
if (EQ (current_buffer->undo_list, Qt))
{
/* If we have preallocated the cons cell to use here,
use that one. */
- XCONS (pending_boundary)->cdr = current_buffer->undo_list;
+ XSETCDR (pending_boundary, current_buffer->undo_list);
current_buffer->undo_list = pending_boundary;
pending_boundary = Qnil;
}
/* At garbage collection time, make an undo list shorter at the end,
returning the truncated list.
- MINSIZE and MAXSIZE are the limits on size allowed, as described below.
- In practice, these are the values of undo-limit and
- undo-strong-limit. */
+ MINSIZE, MAXSIZE and LIMITSIZE are the limits on size allowed,
+ as described below.
+ In practice, these are the values of undo-limit,
+ undo-strong-limit, and undo-outer-limit. */
Lisp_Object
-truncate_undo_list (list, minsize, maxsize)
+truncate_undo_list (list, minsize, maxsize, limitsize)
Lisp_Object list;
- int minsize, maxsize;
+ int minsize, maxsize, limitsize;
{
Lisp_Object prev, next, last_boundary;
int size_so_far = 0;
next = list;
last_boundary = Qnil;
- /* Always preserve at least the most recent undo record.
+ /* Always preserve at least the most recent undo record
+ unless it is really horribly big.
If the first element is an undo boundary, skip past it.
Skip, skip, skip the undo, skip, skip, skip the undo,
- Skip, skip, skip the undo, skip to the undo bound'ry.
+ Skip, skip, skip the undo, skip to the undo bound'ry.
(Get it? "Skip to my Loo?") */
- if (CONSP (next) && NILP (XCONS (next)->car))
+ if (CONSP (next) && NILP (XCAR (next)))
{
/* Add in the space occupied by this element and its chain link. */
size_so_far += sizeof (struct Lisp_Cons);
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
- while (CONSP (next) && ! NILP (XCONS (next)->car))
+
+ while (CONSP (next) && ! NILP (XCAR (next)))
{
Lisp_Object elt;
- elt = XCONS (next)->car;
+ elt = XCAR (next);
/* Add in the space occupied by this element and its chain link. */
size_so_far += sizeof (struct Lisp_Cons);
if (CONSP (elt))
{
size_so_far += sizeof (struct Lisp_Cons);
- if (STRINGP (XCONS (elt)->car))
+ if (STRINGP (XCAR (elt)))
size_so_far += (sizeof (struct Lisp_String) - 1
- + XSTRING (XCONS (elt)->car)->size);
+ + SCHARS (XCAR (elt)));
}
+ /* If we reach LIMITSIZE before the first boundary,
+ we're heading for memory full, so truncate the list to nothing. */
+ if (size_so_far > limitsize)
+ return Qnil;
+
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
+
if (CONSP (next))
last_boundary = prev;
+ /* Keep more if it fits. */
while (CONSP (next))
{
Lisp_Object elt;
- elt = XCONS (next)->car;
+ elt = XCAR (next);
/* When we get to a boundary, decide whether to truncate
either before or after it. The lower threshold, MINSIZE,
if (CONSP (elt))
{
size_so_far += sizeof (struct Lisp_Cons);
- if (STRINGP (XCONS (elt)->car))
+ if (STRINGP (XCAR (elt)))
size_so_far += (sizeof (struct Lisp_String) - 1
- + XSTRING (XCONS (elt)->car)->size);
+ + SCHARS (XCAR (elt)));
}
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
/* If we scanned the whole list, it is short enough; don't change it. */
/* Truncate at the boundary where we decided to truncate. */
if (!NILP (last_boundary))
{
- XCONS (last_boundary)->cdr = Qnil;
+ XSETCDR (last_boundary, Qnil);
return list;
}
else
}
\f
DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
- "Undo N records from the front of the list LIST.\n\
-Return what remains of the list.")
- (n, list)
+ doc: /* Undo N records from the front of the list LIST.
+Return what remains of the list. */)
+ (n, list)
Lisp_Object n, list;
{
struct gcpro gcpro1, gcpro2;
Lisp_Object next;
- int count = specpdl_ptr - specpdl;
+ int count = SPECPDL_INDEX ();
register int arg;
+
#if 0 /* This is a good feature, but would make undo-start
unable to do what is expected. */
Lisp_Object tem;
list = Fcdr (list);
#endif
- CHECK_NUMBER (n, 0);
+ CHECK_NUMBER (n);
arg = XINT (n);
next = Qnil;
GCPRO2 (next, list);
- /* Don't let read-only properties interfere with undo. */
+ /* In a writable buffer, enable undoing read-only text that is so
+ because of text properties. */
if (NILP (current_buffer->read_only))
specbind (Qinhibit_read_only, Qt);
+ /* Don't let `intangible' properties interfere with undo. */
+ specbind (Qinhibit_point_motion_hooks, Qt);
+
while (arg > 0)
{
- while (1)
+ while (CONSP (list))
{
- next = Fcar (list);
- list = Fcdr (list);
+ next = XCAR (list);
+ list = XCDR (list);
/* Exit inner loop at undo boundary. */
if (NILP (next))
break;
{
Lisp_Object car, cdr;
- car = Fcar (next);
- cdr = Fcdr (next);
+ car = XCAR (next);
+ cdr = XCDR (next);
if (EQ (car, Qt))
{
/* Element (t high . low) records previous modtime. */
#endif /* CLASH_DETECTION */
Fset_buffer_modified_p (Qnil);
}
-#ifdef USE_TEXT_PROPERTIES
else if (EQ (car, Qnil))
{
/* Element (nil prop val beg . end) is property change. */
Fput_text_property (beg, end, prop, val, Qnil);
}
-#endif /* USE_TEXT_PROPERTIES */
else if (INTEGERP (car) && INTEGERP (cdr))
{
/* Element (BEG . END) means range was inserted. */
- Lisp_Object end;
if (XINT (car) < BEGV
|| XINT (cdr) > ZV)
return unbind_to (count, list);
}
+void
syms_of_undo ()
{
Qinhibit_read_only = intern ("inhibit-read-only");
defsubr (&Sprimitive_undo);
defsubr (&Sundo_boundary);
}
+
+/* arch-tag: d546ee01-4aed-4ffb-bb8b-eefaae50d38a
+ (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff