/* 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.
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
GNU Emacs is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY. No author or distributor
-accepts responsibility to anyone for the consequences of using it
-or for whether it serves any particular purpose or works at all,
-unless he says so in writing. Refer to the GNU Emacs General Public
-License for full details.
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
-Everyone is granted permission to copy, modify and redistribute
-GNU Emacs, but only under the conditions described in the
-GNU Emacs General Public License. A copy of this license is
-supposed to have been given to you along with GNU Emacs so you
-can know your rights and responsibilities. It should be in a
-file named COPYING. Among other things, the copyright notice
-and this notice must be preserved on all copies. */
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING. If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <config.h>
(It is possible to record an insertion before or after the fact
because we don't need to record the contents.) */
+void
record_insert (beg, length)
- Lisp_Object beg, length;
+ int beg, length;
{
Lisp_Object lbeg, lend;
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 (MODIFF <= current_buffer->save_modified)
+ if (MODIFF <= SAVE_MODIFF)
record_first_change ();
/* If this is following another insertion and consecutive with it
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) == XINT (beg))
+ && INTEGERP (XCAR (elt))
+ && INTEGERP (XCDR (elt))
+ && XINT (XCDR (elt)) == beg)
{
- XSETINT (XCONS (elt)->cdr, XINT (beg) + XINT (length));
+ XSETCDR (elt, make_number (beg + length));
return;
}
}
- lbeg = beg;
- XSETINT (lend, XINT (beg) + XINT (length));
+ XSETFASTINT (lbeg, beg);
+ XSETINT (lend, beg + length);
current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
current_buffer->undo_list);
}
/* Record that a deletion is about to take place,
- for LENGTH characters at location BEG. */
+ of the characters in STRING, at location BEG. */
-record_delete (beg, length)
- int beg, length;
+void
+record_delete (beg, string)
+ int beg;
+ Lisp_Object string;
{
- Lisp_Object lbeg, lend, sbeg;
+ Lisp_Object sbeg;
int at_boundary;
if (EQ (current_buffer->undo_list, Qt))
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);
- at_boundary = (CONSP (current_buffer->undo_list)
- && NILP (XCONS (current_buffer->undo_list)->car));
+ 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;
- if (MODIFF <= current_buffer->save_modified)
+ 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 = 0;
+
+ if (MODIFF <= SAVE_MODIFF)
record_first_change ();
- if (point == beg + length)
+ if (PT == beg + XSTRING (string)->size)
XSETINT (sbeg, -beg);
else
- XFASTINT (sbeg) = beg;
- XFASTINT (lbeg) = beg;
- XFASTINT (lend) = beg + length;
+ 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)
+ /* 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);
current_buffer->undo_list
- = Fcons (Fcons (Fbuffer_substring (lbeg, lend), sbeg),
+ = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
+}
+
+/* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
+ This is done only when a marker points within text being deleted,
+ because that's the only case where an automatic marker adjustment
+ won't be inverted automatically by undoing the buffer modification. */
+
+void
+record_marker_adjustment (marker, adjustment)
+ Lisp_Object marker;
+ int adjustment;
+{
+ 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 (!BUFFERP (last_undo_buffer)
+ || current_buffer != XBUFFER (last_undo_buffer))
+ Fundo_boundary ();
+ XSETBUFFER (last_undo_buffer, current_buffer);
+
+ current_buffer->undo_list
+ = Fcons (Fcons (marker, make_number (adjustment)),
current_buffer->undo_list);
}
/* Record that a replacement is about to take place,
for LENGTH characters at location BEG.
- The replacement does not change the number of characters. */
+ The replacement must not change the number of characters. */
+void
record_change (beg, length)
int beg, length;
{
- record_delete (beg, length);
+ record_delete (beg, make_buffer_string (beg, beg + length, 1));
record_insert (beg, length);
}
\f
Record the file modification date so that when undoing this entry
we can tell whether it is obsolete because the file was saved again. */
+void
record_first_change ()
{
Lisp_Object high, low;
+ struct buffer *base_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);
- XFASTINT (high) = (current_buffer->modtime >> 16) & 0xffff;
- XFASTINT (low) = current_buffer->modtime & 0xffff;
+ if (base_buffer->base_buffer)
+ base_buffer = base_buffer->base_buffer;
+
+ XSETFASTINT (high, (base_buffer->modtime >> 16) & 0xffff);
+ XSETFASTINT (low, base_buffer->modtime & 0xffff);
current_buffer->undo_list = Fcons (Fcons (Qt, Fcons (high, low)), current_buffer->undo_list);
}
/* Record a change in property PROP (whose old value was VAL)
for LENGTH characters starting at position BEG in BUFFER. */
+void
record_property_change (beg, length, prop, value, buffer)
int beg, length;
Lisp_Object prop, value, buffer;
if (boundary)
Fundo_boundary ();
- if (MODIFF <= current_buffer->save_modified)
+ if (MODIFF <= SAVE_MODIFF)
record_first_change ();
XSETINT (lbeg, beg);
}
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;
}
Skip, skip, skip the undo, skip, skip, skip the undo,
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);
+ + XSTRING (XCAR (elt))->size);
}
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
if (CONSP (next))
last_boundary = prev;
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);
+ + XSTRING (XCAR (elt))->size);
}
/* 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 = BINDING_STACK_SIZE ();
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. */
Lisp_Object high, low;
int mod_time;
+ struct buffer *base_buffer = current_buffer;
high = Fcar (cdr);
low = Fcdr (cdr);
mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
+
+ if (current_buffer->base_buffer)
+ base_buffer = current_buffer->base_buffer;
+
/* If this records an obsolete save
(not matching the actual disk file)
then don't mark unmodified. */
- if (mod_time != current_buffer->modtime)
- break;
+ if (mod_time != base_buffer->modtime)
+ continue;
#ifdef CLASH_DETECTION
Funlock_buffer ();
#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)
error ("Changes to be undone are outside visible portion of buffer");
SET_PT (pos);
- /* Insert before markers so that if the mark is
- currently on the boundary of this deletion, it
- ends up on the other side of the now-undeleted
- text from point. Since undo doesn't even keep
- track of the mark, this isn't really necessary,
- but it may lead to better behavior in certain
- situations. */
- Finsert_before_markers (1, &membuf);
+ /* Now that we record marker adjustments
+ (caused by deletion) for undo,
+ we should always insert after markers,
+ so that undoing the marker adjustments
+ put the markers back in the right place. */
+ Finsert (1, &membuf);
SET_PT (pos);
}
}
+ else if (MARKERP (car) && INTEGERP (cdr))
+ {
+ /* (MARKER . INTEGER) means a marker MARKER
+ was adjusted by INTEGER. */
+ if (XMARKER (car)->buffer)
+ Fset_marker (car,
+ make_number (marker_position (car) - XINT (cdr)),
+ Fmarker_buffer (car));
+ }
}
}
arg--;
return unbind_to (count, list);
}
+void
syms_of_undo ()
{
Qinhibit_read_only = intern ("inhibit-read-only");