X-Git-Url: https://code.delx.au/gnu-emacs/blobdiff_plain/552bdbcf7114b65201f8a6c169837dcfb255f892..b3561514f631090ea1af4b6a04aaa8790654595d:/src/undo.c diff --git a/src/undo.c b/src/undo.c index be6d506242..ec6f9d6b1d 100644 --- a/src/undo.c +++ b/src/undo.c @@ -1,22 +1,22 @@ /* 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 @@ -41,8 +41,9 @@ Lisp_Object pending_boundary; (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; @@ -53,11 +54,12 @@ record_insert (beg, length) 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 @@ -65,30 +67,32 @@ record_insert (beg, length) 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)) @@ -98,44 +102,91 @@ record_delete (beg, length) 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); } @@ -143,25 +194,32 @@ record_change (beg, length) 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; @@ -187,7 +245,7 @@ record_property_change (beg, length, prop, value, buffer) if (boundary) Fundo_boundary (); - if (MODIFF <= current_buffer->save_modified) + if (MODIFF <= SAVE_MODIFF) record_first_change (); XSETINT (lbeg, beg); @@ -199,10 +257,10 @@ record_property_change (beg, length, prop, value, 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)) @@ -215,7 +273,7 @@ but another undo command will undo to the previous boundary.") { /* 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; } @@ -249,33 +307,33 @@ truncate_undo_list (list, minsize, maxsize) 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; @@ -283,7 +341,7 @@ truncate_undo_list (list, minsize, maxsize) 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, @@ -303,14 +361,14 @@ truncate_undo_list (list, minsize, maxsize) 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. */ @@ -320,7 +378,7 @@ truncate_undo_list (list, minsize, maxsize) /* 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 @@ -328,15 +386,16 @@ truncate_undo_list (list, minsize, maxsize) } 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; @@ -348,21 +407,25 @@ Return what remains of the list.") 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; @@ -373,28 +436,32 @@ Return what remains of the list.") { 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. */ @@ -409,11 +476,9 @@ Return what remains of the list.") 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) @@ -443,17 +508,24 @@ Return what remains of the list.") 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--; @@ -463,6 +535,7 @@ Return what remains of the list.") return unbind_to (count, list); } +void syms_of_undo () { Qinhibit_read_only = intern ("inhibit-read-only");