Clarify potential drawback of previous change.
[emacs.git] / src / undo.c
blob7a6ba37d0f88e056b409f410a52f9a976c716db4
1 /* undo handling for GNU Emacs.
2 Copyright (C) 1990, 1993, 1994, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #include <config.h>
24 #include "lisp.h"
25 #include "buffer.h"
26 #include "commands.h"
27 #include "window.h"
29 /* Limits controlling how much undo information to keep. */
31 EMACS_INT undo_limit;
32 EMACS_INT undo_strong_limit;
34 Lisp_Object Vundo_outer_limit;
36 /* Function to call when undo_outer_limit is exceeded. */
38 Lisp_Object Vundo_outer_limit_function;
40 /* Last buffer for which undo information was recorded. */
41 Lisp_Object last_undo_buffer;
43 Lisp_Object Qinhibit_read_only;
45 /* Marker for function call undo list elements. */
47 Lisp_Object Qapply;
49 /* The first time a command records something for undo.
50 it also allocates the undo-boundary object
51 which will be added to the list at the end of the command.
52 This ensures we can't run out of space while trying to make
53 an undo-boundary. */
54 Lisp_Object pending_boundary;
56 /* Record point as it was at beginning of this command (if necessary)
57 And prepare the undo info for recording a change.
58 PT is the position of point that will naturally occur as a result of the
59 undo record that will be added just after this command terminates. */
61 static void
62 record_point (pt)
63 int pt;
65 int at_boundary;
67 /* Allocate a cons cell to be the undo boundary after this command. */
68 if (NILP (pending_boundary))
69 pending_boundary = Fcons (Qnil, Qnil);
71 if (!BUFFERP (last_undo_buffer)
72 || current_buffer != XBUFFER (last_undo_buffer))
73 Fundo_boundary ();
74 XSETBUFFER (last_undo_buffer, current_buffer);
76 if (CONSP (current_buffer->undo_list))
78 /* Set AT_BOUNDARY to 1 only when we have nothing other than
79 marker adjustment before undo boundary. */
81 Lisp_Object tail = current_buffer->undo_list, elt;
83 while (1)
85 if (NILP (tail))
86 elt = Qnil;
87 else
88 elt = XCAR (tail);
89 if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
90 break;
91 tail = XCDR (tail);
93 at_boundary = NILP (elt);
95 else
96 at_boundary = 1;
98 if (MODIFF <= SAVE_MODIFF)
99 record_first_change ();
101 /* If we are just after an undo boundary, and
102 point wasn't at start of deleted range, record where it was. */
103 if (at_boundary
104 && BUFFERP (last_point_position_buffer)
105 /* If we're called from batch mode, this could be nil. */
106 && current_buffer == XBUFFER (last_point_position_buffer))
108 /* If we have switched windows, use the point value
109 from the window we are in. */
110 if (! EQ (last_point_position_window, selected_window))
111 last_point_position = marker_position (XWINDOW (selected_window)->pointm);
113 if (last_point_position != pt)
114 current_buffer->undo_list
115 = Fcons (make_number (last_point_position), current_buffer->undo_list);
119 /* Record an insertion that just happened or is about to happen,
120 for LENGTH characters at position BEG.
121 (It is possible to record an insertion before or after the fact
122 because we don't need to record the contents.) */
124 void
125 record_insert (beg, length)
126 int beg, length;
128 Lisp_Object lbeg, lend;
130 if (EQ (current_buffer->undo_list, Qt))
131 return;
133 record_point (beg);
135 /* If this is following another insertion and consecutive with it
136 in the buffer, combine the two. */
137 if (CONSP (current_buffer->undo_list))
139 Lisp_Object elt;
140 elt = XCAR (current_buffer->undo_list);
141 if (CONSP (elt)
142 && INTEGERP (XCAR (elt))
143 && INTEGERP (XCDR (elt))
144 && XINT (XCDR (elt)) == beg)
146 XSETCDR (elt, make_number (beg + length));
147 return;
151 XSETFASTINT (lbeg, beg);
152 XSETINT (lend, beg + length);
153 current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
154 current_buffer->undo_list);
157 /* Record that a deletion is about to take place,
158 of the characters in STRING, at location BEG. */
160 void
161 record_delete (beg, string)
162 int beg;
163 Lisp_Object string;
165 Lisp_Object sbeg;
167 if (EQ (current_buffer->undo_list, Qt))
168 return;
170 if (PT == beg + SCHARS (string))
172 XSETINT (sbeg, -beg);
173 record_point (PT);
175 else
177 XSETFASTINT (sbeg, beg);
178 record_point (beg);
181 current_buffer->undo_list
182 = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
185 /* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
186 This is done only when a marker points within text being deleted,
187 because that's the only case where an automatic marker adjustment
188 won't be inverted automatically by undoing the buffer modification. */
190 void
191 record_marker_adjustment (marker, adjustment)
192 Lisp_Object marker;
193 int adjustment;
195 if (EQ (current_buffer->undo_list, Qt))
196 return;
198 /* Allocate a cons cell to be the undo boundary after this command. */
199 if (NILP (pending_boundary))
200 pending_boundary = Fcons (Qnil, Qnil);
202 if (!BUFFERP (last_undo_buffer)
203 || current_buffer != XBUFFER (last_undo_buffer))
204 Fundo_boundary ();
205 XSETBUFFER (last_undo_buffer, current_buffer);
207 current_buffer->undo_list
208 = Fcons (Fcons (marker, make_number (adjustment)),
209 current_buffer->undo_list);
212 /* Record that a replacement is about to take place,
213 for LENGTH characters at location BEG.
214 The replacement must not change the number of characters. */
216 void
217 record_change (beg, length)
218 int beg, length;
220 record_delete (beg, make_buffer_string (beg, beg + length, 1));
221 record_insert (beg, length);
224 /* Record that an unmodified buffer is about to be changed.
225 Record the file modification date so that when undoing this entry
226 we can tell whether it is obsolete because the file was saved again. */
228 void
229 record_first_change ()
231 Lisp_Object high, low;
232 struct buffer *base_buffer = current_buffer;
234 if (EQ (current_buffer->undo_list, Qt))
235 return;
237 if (!BUFFERP (last_undo_buffer)
238 || current_buffer != XBUFFER (last_undo_buffer))
239 Fundo_boundary ();
240 XSETBUFFER (last_undo_buffer, current_buffer);
242 if (base_buffer->base_buffer)
243 base_buffer = base_buffer->base_buffer;
245 XSETFASTINT (high, (base_buffer->modtime >> 16) & 0xffff);
246 XSETFASTINT (low, base_buffer->modtime & 0xffff);
247 current_buffer->undo_list = Fcons (Fcons (Qt, Fcons (high, low)), current_buffer->undo_list);
250 /* Record a change in property PROP (whose old value was VAL)
251 for LENGTH characters starting at position BEG in BUFFER. */
253 void
254 record_property_change (beg, length, prop, value, buffer)
255 int beg, length;
256 Lisp_Object prop, value, buffer;
258 Lisp_Object lbeg, lend, entry;
259 struct buffer *obuf = current_buffer;
260 int boundary = 0;
262 if (EQ (XBUFFER (buffer)->undo_list, Qt))
263 return;
265 /* Allocate a cons cell to be the undo boundary after this command. */
266 if (NILP (pending_boundary))
267 pending_boundary = Fcons (Qnil, Qnil);
269 if (!EQ (buffer, last_undo_buffer))
270 boundary = 1;
271 last_undo_buffer = buffer;
273 /* Switch temporarily to the buffer that was changed. */
274 current_buffer = XBUFFER (buffer);
276 if (boundary)
277 Fundo_boundary ();
279 if (MODIFF <= SAVE_MODIFF)
280 record_first_change ();
282 XSETINT (lbeg, beg);
283 XSETINT (lend, beg + length);
284 entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
285 current_buffer->undo_list = Fcons (entry, current_buffer->undo_list);
287 current_buffer = obuf;
290 DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
291 doc: /* Mark a boundary between units of undo.
292 An undo command will stop at this point,
293 but another undo command will undo to the previous boundary. */)
296 Lisp_Object tem;
297 if (EQ (current_buffer->undo_list, Qt))
298 return Qnil;
299 tem = Fcar (current_buffer->undo_list);
300 if (!NILP (tem))
302 /* One way or another, cons nil onto the front of the undo list. */
303 if (!NILP (pending_boundary))
305 /* If we have preallocated the cons cell to use here,
306 use that one. */
307 XSETCDR (pending_boundary, current_buffer->undo_list);
308 current_buffer->undo_list = pending_boundary;
309 pending_boundary = Qnil;
311 else
312 current_buffer->undo_list = Fcons (Qnil, current_buffer->undo_list);
314 return Qnil;
317 /* At garbage collection time, make an undo list shorter at the end,
318 returning the truncated list. How this is done depends on the
319 variables undo-limit, undo-strong-limit and undo-outer-limit.
320 In some cases this works by calling undo-outer-limit-function. */
322 void
323 truncate_undo_list (b)
324 struct buffer *b;
326 Lisp_Object list;
327 Lisp_Object prev, next, last_boundary;
328 int size_so_far = 0;
330 /* Make sure that calling undo-outer-limit-function
331 won't cause another GC. */
332 int count = inhibit_garbage_collection ();
334 /* Make the buffer current to get its local values of variables such
335 as undo_limit. Also so that Vundo_outer_limit_function can
336 tell which buffer to operate on. */
337 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
338 set_buffer_internal (b);
340 list = b->undo_list;
342 prev = Qnil;
343 next = list;
344 last_boundary = Qnil;
346 /* If the first element is an undo boundary, skip past it. */
347 if (CONSP (next) && NILP (XCAR (next)))
349 /* Add in the space occupied by this element and its chain link. */
350 size_so_far += sizeof (struct Lisp_Cons);
352 /* Advance to next element. */
353 prev = next;
354 next = XCDR (next);
357 /* Always preserve at least the most recent undo record
358 unless it is really horribly big.
360 Skip, skip, skip the undo, skip, skip, skip the undo,
361 Skip, skip, skip the undo, skip to the undo bound'ry. */
363 while (CONSP (next) && ! NILP (XCAR (next)))
365 Lisp_Object elt;
366 elt = XCAR (next);
368 /* Add in the space occupied by this element and its chain link. */
369 size_so_far += sizeof (struct Lisp_Cons);
370 if (CONSP (elt))
372 size_so_far += sizeof (struct Lisp_Cons);
373 if (STRINGP (XCAR (elt)))
374 size_so_far += (sizeof (struct Lisp_String) - 1
375 + SCHARS (XCAR (elt)));
378 /* Advance to next element. */
379 prev = next;
380 next = XCDR (next);
383 /* If by the first boundary we have already passed undo_outer_limit,
384 we're heading for memory full, so offer to clear out the list. */
385 if (INTEGERP (Vundo_outer_limit)
386 && size_so_far > XINT (Vundo_outer_limit)
387 && !NILP (Vundo_outer_limit_function))
389 Lisp_Object temp = last_undo_buffer, tem;
391 /* Normally the function this calls is undo-outer-limit-truncate. */
392 tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
393 if (! NILP (tem))
395 /* The function is responsible for making
396 any desired changes in buffer-undo-list. */
397 unbind_to (count, Qnil);
398 return;
400 /* That function probably used the minibuffer, and if so, that
401 changed last_undo_buffer. Change it back so that we don't
402 force next change to make an undo boundary here. */
403 last_undo_buffer = temp;
406 if (CONSP (next))
407 last_boundary = prev;
409 /* Keep additional undo data, if it fits in the limits. */
410 while (CONSP (next))
412 Lisp_Object elt;
413 elt = XCAR (next);
415 /* When we get to a boundary, decide whether to truncate
416 either before or after it. The lower threshold, undo_limit,
417 tells us to truncate after it. If its size pushes past
418 the higher threshold undo_strong_limit, we truncate before it. */
419 if (NILP (elt))
421 if (size_so_far > undo_strong_limit)
422 break;
423 last_boundary = prev;
424 if (size_so_far > undo_limit)
425 break;
428 /* Add in the space occupied by this element and its chain link. */
429 size_so_far += sizeof (struct Lisp_Cons);
430 if (CONSP (elt))
432 size_so_far += sizeof (struct Lisp_Cons);
433 if (STRINGP (XCAR (elt)))
434 size_so_far += (sizeof (struct Lisp_String) - 1
435 + SCHARS (XCAR (elt)));
438 /* Advance to next element. */
439 prev = next;
440 next = XCDR (next);
443 /* If we scanned the whole list, it is short enough; don't change it. */
444 if (NILP (next))
446 /* Truncate at the boundary where we decided to truncate. */
447 else if (!NILP (last_boundary))
448 XSETCDR (last_boundary, Qnil);
449 /* There's nothing we decided to keep, so clear it out. */
450 else
451 b->undo_list = Qnil;
453 unbind_to (count, Qnil);
456 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
457 doc: /* Undo N records from the front of the list LIST.
458 Return what remains of the list. */)
459 (n, list)
460 Lisp_Object n, list;
462 struct gcpro gcpro1, gcpro2;
463 Lisp_Object next;
464 int count = SPECPDL_INDEX ();
465 register int arg;
466 Lisp_Object oldlist;
467 int did_apply = 0;
469 #if 0 /* This is a good feature, but would make undo-start
470 unable to do what is expected. */
471 Lisp_Object tem;
473 /* If the head of the list is a boundary, it is the boundary
474 preceding this command. Get rid of it and don't count it. */
475 tem = Fcar (list);
476 if (NILP (tem))
477 list = Fcdr (list);
478 #endif
480 CHECK_NUMBER (n);
481 arg = XINT (n);
482 next = Qnil;
483 GCPRO2 (next, list);
484 /* I don't think we need to gcpro oldlist, as we use it only
485 to check for EQ. ++kfs */
487 /* In a writable buffer, enable undoing read-only text that is so
488 because of text properties. */
489 if (NILP (current_buffer->read_only))
490 specbind (Qinhibit_read_only, Qt);
492 /* Don't let `intangible' properties interfere with undo. */
493 specbind (Qinhibit_point_motion_hooks, Qt);
495 oldlist = current_buffer->undo_list;
497 while (arg > 0)
499 while (CONSP (list))
501 next = XCAR (list);
502 list = XCDR (list);
503 /* Exit inner loop at undo boundary. */
504 if (NILP (next))
505 break;
506 /* Handle an integer by setting point to that value. */
507 if (INTEGERP (next))
508 SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
509 else if (CONSP (next))
511 Lisp_Object car, cdr;
513 car = XCAR (next);
514 cdr = XCDR (next);
515 if (EQ (car, Qt))
517 /* Element (t high . low) records previous modtime. */
518 Lisp_Object high, low;
519 int mod_time;
520 struct buffer *base_buffer = current_buffer;
522 high = Fcar (cdr);
523 low = Fcdr (cdr);
524 mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
526 if (current_buffer->base_buffer)
527 base_buffer = current_buffer->base_buffer;
529 /* If this records an obsolete save
530 (not matching the actual disk file)
531 then don't mark unmodified. */
532 if (mod_time != base_buffer->modtime)
533 continue;
534 #ifdef CLASH_DETECTION
535 Funlock_buffer ();
536 #endif /* CLASH_DETECTION */
537 Fset_buffer_modified_p (Qnil);
539 else if (EQ (car, Qnil))
541 /* Element (nil PROP VAL BEG . END) is property change. */
542 Lisp_Object beg, end, prop, val;
544 prop = Fcar (cdr);
545 cdr = Fcdr (cdr);
546 val = Fcar (cdr);
547 cdr = Fcdr (cdr);
548 beg = Fcar (cdr);
549 end = Fcdr (cdr);
551 if (XINT (beg) < BEGV || XINT (end) > ZV)
552 error ("Changes to be undone are outside visible portion of buffer");
553 Fput_text_property (beg, end, prop, val, Qnil);
555 else if (INTEGERP (car) && INTEGERP (cdr))
557 /* Element (BEG . END) means range was inserted. */
559 if (XINT (car) < BEGV
560 || XINT (cdr) > ZV)
561 error ("Changes to be undone are outside visible portion of buffer");
562 /* Set point first thing, so that undoing this undo
563 does not send point back to where it is now. */
564 Fgoto_char (car);
565 Fdelete_region (car, cdr);
567 else if (EQ (car, Qapply))
569 /* Element (apply FUN . ARGS) means call FUN to undo. */
570 struct buffer *save_buffer = current_buffer;
572 car = Fcar (cdr);
573 cdr = Fcdr (cdr);
574 if (INTEGERP (car))
576 /* Long format: (apply DELTA START END FUN . ARGS). */
577 Lisp_Object delta = car;
578 Lisp_Object start = Fcar (cdr);
579 Lisp_Object end = Fcar (Fcdr (cdr));
580 Lisp_Object start_mark = Fcopy_marker (start, Qnil);
581 Lisp_Object end_mark = Fcopy_marker (end, Qt);
583 cdr = Fcdr (Fcdr (cdr));
584 apply1 (Fcar (cdr), Fcdr (cdr));
586 /* Check that the function did what the entry said it
587 would do. */
588 if (!EQ (start, Fmarker_position (start_mark))
589 || (XINT (delta) + XINT (end)
590 != marker_position (end_mark)))
591 error ("Changes to be undone by function different than announced");
592 Fset_marker (start_mark, Qnil, Qnil);
593 Fset_marker (end_mark, Qnil, Qnil);
595 else
596 apply1 (car, cdr);
598 if (save_buffer != current_buffer)
599 error ("Undo function switched buffer");
600 did_apply = 1;
602 else if (STRINGP (car) && INTEGERP (cdr))
604 /* Element (STRING . POS) means STRING was deleted. */
605 Lisp_Object membuf;
606 int pos = XINT (cdr);
608 membuf = car;
609 if (pos < 0)
611 if (-pos < BEGV || -pos > ZV)
612 error ("Changes to be undone are outside visible portion of buffer");
613 SET_PT (-pos);
614 Finsert (1, &membuf);
616 else
618 if (pos < BEGV || pos > ZV)
619 error ("Changes to be undone are outside visible portion of buffer");
620 SET_PT (pos);
622 /* Now that we record marker adjustments
623 (caused by deletion) for undo,
624 we should always insert after markers,
625 so that undoing the marker adjustments
626 put the markers back in the right place. */
627 Finsert (1, &membuf);
628 SET_PT (pos);
631 else if (MARKERP (car) && INTEGERP (cdr))
633 /* (MARKER . INTEGER) means a marker MARKER
634 was adjusted by INTEGER. */
635 if (XMARKER (car)->buffer)
636 Fset_marker (car,
637 make_number (marker_position (car) - XINT (cdr)),
638 Fmarker_buffer (car));
642 arg--;
646 /* Make sure an apply entry produces at least one undo entry,
647 so the test in `undo' for continuing an undo series
648 will work right. */
649 if (did_apply
650 && EQ (oldlist, current_buffer->undo_list))
651 current_buffer->undo_list
652 = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
654 UNGCPRO;
655 return unbind_to (count, list);
658 void
659 syms_of_undo ()
661 Qinhibit_read_only = intern ("inhibit-read-only");
662 staticpro (&Qinhibit_read_only);
664 Qapply = intern ("apply");
665 staticpro (&Qapply);
667 pending_boundary = Qnil;
668 staticpro (&pending_boundary);
670 defsubr (&Sprimitive_undo);
671 defsubr (&Sundo_boundary);
673 DEFVAR_INT ("undo-limit", &undo_limit,
674 doc: /* Keep no more undo information once it exceeds this size.
675 This limit is applied when garbage collection happens.
676 When a previous command increases the total undo list size past this
677 value, the earlier commands that came before it are forgotten.
679 The size is counted as the number of bytes occupied,
680 which includes both saved text and other data. */);
681 undo_limit = 20000;
683 DEFVAR_INT ("undo-strong-limit", &undo_strong_limit,
684 doc: /* Don't keep more than this much size of undo information.
685 This limit is applied when garbage collection happens.
686 When a previous command increases the total undo list size past this
687 value, that command and the earlier commands that came before it are forgotten.
688 However, the most recent buffer-modifying command's undo info
689 is never discarded for this reason.
691 The size is counted as the number of bytes occupied,
692 which includes both saved text and other data. */);
693 undo_strong_limit = 30000;
695 DEFVAR_LISP ("undo-outer-limit", &Vundo_outer_limit,
696 doc: /* Outer limit on size of undo information for one command.
697 At garbage collection time, if the current command has produced
698 more than this much undo information, it discards the info and displays
699 a warning. This is a last-ditch limit to prevent memory overflow.
701 The size is counted as the number of bytes occupied, which includes
702 both saved text and other data. A value of nil means no limit. In
703 this case, accumulating one huge undo entry could make Emacs crash as
704 a result of memory overflow.
706 In fact, this calls the function which is the value of
707 `undo-outer-limit-function' with one argument, the size.
708 The text above describes the behavior of the function
709 that variable usually specifies. */);
710 Vundo_outer_limit = make_number (3000000);
712 DEFVAR_LISP ("undo-outer-limit-function", &Vundo_outer_limit_function,
713 doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
714 This function is called with one argument, the current undo list size
715 for the most recent command (since the last undo boundary).
716 If the function returns t, that means truncation has been fully handled.
717 If it returns nil, the other forms of truncation are done.
719 Garbage collection is inhibited around the call to this function,
720 so it must make sure not to do a lot of consing. */);
721 Vundo_outer_limit_function = Qnil;
724 /* arch-tag: d546ee01-4aed-4ffb-bb8b-eefaae50d38a
725 (do not change this comment) */