deps.mk: Update for recent changes: gnutls, gnulib imports, globals.h.
[emacs.git] / src / undo.c
blob933982ec30cae2b75c851406dbe8e6f3c3525a79
1 /* undo handling for GNU Emacs.
2 Copyright (C) 1990, 1993-1994, 2000-2011 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <setjmp.h>
22 #include "lisp.h"
23 #include "buffer.h"
24 #include "commands.h"
25 #include "window.h"
27 /* Last buffer for which undo information was recorded. */
28 /* BEWARE: This is not traced by the GC, so never dereference it! */
29 struct buffer *last_undo_buffer;
31 /* Position of point last time we inserted a boundary. */
32 struct buffer *last_boundary_buffer;
33 EMACS_INT last_boundary_position;
35 Lisp_Object Qinhibit_read_only;
37 /* Marker for function call undo list elements. */
39 Lisp_Object Qapply;
41 /* The first time a command records something for undo.
42 it also allocates the undo-boundary object
43 which will be added to the list at the end of the command.
44 This ensures we can't run out of space while trying to make
45 an undo-boundary. */
46 Lisp_Object pending_boundary;
48 /* Record point as it was at beginning of this command (if necessary)
49 and prepare the undo info for recording a change.
50 PT is the position of point that will naturally occur as a result of the
51 undo record that will be added just after this command terminates. */
53 static void
54 record_point (EMACS_INT pt)
56 int at_boundary;
58 /* Don't record position of pt when undo_inhibit_record_point holds. */
59 if (undo_inhibit_record_point)
60 return;
62 /* Allocate a cons cell to be the undo boundary after this command. */
63 if (NILP (pending_boundary))
64 pending_boundary = Fcons (Qnil, Qnil);
66 if ((current_buffer != last_undo_buffer)
67 /* Don't call Fundo_boundary for the first change. Otherwise we
68 risk overwriting last_boundary_position in Fundo_boundary with
69 PT of the current buffer and as a consequence not insert an
70 undo boundary because last_boundary_position will equal pt in
71 the test at the end of the present function (Bug#731). */
72 && (MODIFF > SAVE_MODIFF))
73 Fundo_boundary ();
74 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 && current_buffer == last_boundary_buffer
105 && last_boundary_position != pt)
106 current_buffer->undo_list
107 = Fcons (make_number (last_boundary_position), current_buffer->undo_list);
110 /* Record an insertion that just happened or is about to happen,
111 for LENGTH characters at position BEG.
112 (It is possible to record an insertion before or after the fact
113 because we don't need to record the contents.) */
115 void
116 record_insert (EMACS_INT beg, EMACS_INT length)
118 Lisp_Object lbeg, lend;
120 if (EQ (current_buffer->undo_list, Qt))
121 return;
123 record_point (beg);
125 /* If this is following another insertion and consecutive with it
126 in the buffer, combine the two. */
127 if (CONSP (current_buffer->undo_list))
129 Lisp_Object elt;
130 elt = XCAR (current_buffer->undo_list);
131 if (CONSP (elt)
132 && INTEGERP (XCAR (elt))
133 && INTEGERP (XCDR (elt))
134 && XINT (XCDR (elt)) == beg)
136 XSETCDR (elt, make_number (beg + length));
137 return;
141 XSETFASTINT (lbeg, beg);
142 XSETINT (lend, beg + length);
143 current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
144 current_buffer->undo_list);
147 /* Record that a deletion is about to take place,
148 of the characters in STRING, at location BEG. */
150 void
151 record_delete (EMACS_INT beg, Lisp_Object string)
153 Lisp_Object sbeg;
155 if (EQ (current_buffer->undo_list, Qt))
156 return;
158 if (PT == beg + SCHARS (string))
160 XSETINT (sbeg, -beg);
161 record_point (PT);
163 else
165 XSETFASTINT (sbeg, beg);
166 record_point (beg);
169 current_buffer->undo_list
170 = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
173 /* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
174 This is done only when a marker points within text being deleted,
175 because that's the only case where an automatic marker adjustment
176 won't be inverted automatically by undoing the buffer modification. */
178 void
179 record_marker_adjustment (Lisp_Object marker, EMACS_INT adjustment)
181 if (EQ (current_buffer->undo_list, Qt))
182 return;
184 /* Allocate a cons cell to be the undo boundary after this command. */
185 if (NILP (pending_boundary))
186 pending_boundary = Fcons (Qnil, Qnil);
188 if (current_buffer != last_undo_buffer)
189 Fundo_boundary ();
190 last_undo_buffer = current_buffer;
192 current_buffer->undo_list
193 = Fcons (Fcons (marker, make_number (adjustment)),
194 current_buffer->undo_list);
197 /* Record that a replacement is about to take place,
198 for LENGTH characters at location BEG.
199 The replacement must not change the number of characters. */
201 void
202 record_change (EMACS_INT beg, EMACS_INT length)
204 record_delete (beg, make_buffer_string (beg, beg + length, 1));
205 record_insert (beg, length);
208 /* Record that an unmodified buffer is about to be changed.
209 Record the file modification date so that when undoing this entry
210 we can tell whether it is obsolete because the file was saved again. */
212 void
213 record_first_change (void)
215 Lisp_Object high, low;
216 struct buffer *base_buffer = current_buffer;
218 if (EQ (current_buffer->undo_list, Qt))
219 return;
221 if (current_buffer != last_undo_buffer)
222 Fundo_boundary ();
223 last_undo_buffer = current_buffer;
225 if (base_buffer->base_buffer)
226 base_buffer = base_buffer->base_buffer;
228 XSETFASTINT (high, (base_buffer->modtime >> 16) & 0xffff);
229 XSETFASTINT (low, base_buffer->modtime & 0xffff);
230 current_buffer->undo_list = Fcons (Fcons (Qt, Fcons (high, low)), current_buffer->undo_list);
233 /* Record a change in property PROP (whose old value was VAL)
234 for LENGTH characters starting at position BEG in BUFFER. */
236 void
237 record_property_change (EMACS_INT beg, EMACS_INT length,
238 Lisp_Object prop, Lisp_Object value,
239 Lisp_Object buffer)
241 Lisp_Object lbeg, lend, entry;
242 struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
243 int boundary = 0;
245 if (EQ (buf->undo_list, Qt))
246 return;
248 /* Allocate a cons cell to be the undo boundary after this command. */
249 if (NILP (pending_boundary))
250 pending_boundary = Fcons (Qnil, Qnil);
252 if (buf != last_undo_buffer)
253 boundary = 1;
254 last_undo_buffer = buf;
256 /* Switch temporarily to the buffer that was changed. */
257 current_buffer = buf;
259 if (boundary)
260 Fundo_boundary ();
262 if (MODIFF <= SAVE_MODIFF)
263 record_first_change ();
265 XSETINT (lbeg, beg);
266 XSETINT (lend, beg + length);
267 entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
268 current_buffer->undo_list = Fcons (entry, current_buffer->undo_list);
270 current_buffer = obuf;
273 DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
274 doc: /* Mark a boundary between units of undo.
275 An undo command will stop at this point,
276 but another undo command will undo to the previous boundary. */)
277 (void)
279 Lisp_Object tem;
280 if (EQ (current_buffer->undo_list, Qt))
281 return Qnil;
282 tem = Fcar (current_buffer->undo_list);
283 if (!NILP (tem))
285 /* One way or another, cons nil onto the front of the undo list. */
286 if (!NILP (pending_boundary))
288 /* If we have preallocated the cons cell to use here,
289 use that one. */
290 XSETCDR (pending_boundary, current_buffer->undo_list);
291 current_buffer->undo_list = pending_boundary;
292 pending_boundary = Qnil;
294 else
295 current_buffer->undo_list = Fcons (Qnil, current_buffer->undo_list);
297 last_boundary_position = PT;
298 last_boundary_buffer = current_buffer;
299 return Qnil;
302 /* At garbage collection time, make an undo list shorter at the end,
303 returning the truncated list. How this is done depends on the
304 variables undo-limit, undo-strong-limit and undo-outer-limit.
305 In some cases this works by calling undo-outer-limit-function. */
307 void
308 truncate_undo_list (struct buffer *b)
310 Lisp_Object list;
311 Lisp_Object prev, next, last_boundary;
312 int size_so_far = 0;
314 /* Make sure that calling undo-outer-limit-function
315 won't cause another GC. */
316 int count = inhibit_garbage_collection ();
318 /* Make the buffer current to get its local values of variables such
319 as undo_limit. Also so that Vundo_outer_limit_function can
320 tell which buffer to operate on. */
321 record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
322 set_buffer_internal (b);
324 list = b->undo_list;
326 prev = Qnil;
327 next = list;
328 last_boundary = Qnil;
330 /* If the first element is an undo boundary, skip past it. */
331 if (CONSP (next) && NILP (XCAR (next)))
333 /* Add in the space occupied by this element and its chain link. */
334 size_so_far += sizeof (struct Lisp_Cons);
336 /* Advance to next element. */
337 prev = next;
338 next = XCDR (next);
341 /* Always preserve at least the most recent undo record
342 unless it is really horribly big.
344 Skip, skip, skip the undo, skip, skip, skip the undo,
345 Skip, skip, skip the undo, skip to the undo bound'ry. */
347 while (CONSP (next) && ! NILP (XCAR (next)))
349 Lisp_Object elt;
350 elt = XCAR (next);
352 /* Add in the space occupied by this element and its chain link. */
353 size_so_far += sizeof (struct Lisp_Cons);
354 if (CONSP (elt))
356 size_so_far += sizeof (struct Lisp_Cons);
357 if (STRINGP (XCAR (elt)))
358 size_so_far += (sizeof (struct Lisp_String) - 1
359 + SCHARS (XCAR (elt)));
362 /* Advance to next element. */
363 prev = next;
364 next = XCDR (next);
367 /* If by the first boundary we have already passed undo_outer_limit,
368 we're heading for memory full, so offer to clear out the list. */
369 if (INTEGERP (Vundo_outer_limit)
370 && size_so_far > XINT (Vundo_outer_limit)
371 && !NILP (Vundo_outer_limit_function))
373 Lisp_Object tem;
374 struct buffer *temp = last_undo_buffer;
376 /* Normally the function this calls is undo-outer-limit-truncate. */
377 tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
378 if (! NILP (tem))
380 /* The function is responsible for making
381 any desired changes in buffer-undo-list. */
382 unbind_to (count, Qnil);
383 return;
385 /* That function probably used the minibuffer, and if so, that
386 changed last_undo_buffer. Change it back so that we don't
387 force next change to make an undo boundary here. */
388 last_undo_buffer = temp;
391 if (CONSP (next))
392 last_boundary = prev;
394 /* Keep additional undo data, if it fits in the limits. */
395 while (CONSP (next))
397 Lisp_Object elt;
398 elt = XCAR (next);
400 /* When we get to a boundary, decide whether to truncate
401 either before or after it. The lower threshold, undo_limit,
402 tells us to truncate after it. If its size pushes past
403 the higher threshold undo_strong_limit, we truncate before it. */
404 if (NILP (elt))
406 if (size_so_far > undo_strong_limit)
407 break;
408 last_boundary = prev;
409 if (size_so_far > undo_limit)
410 break;
413 /* Add in the space occupied by this element and its chain link. */
414 size_so_far += sizeof (struct Lisp_Cons);
415 if (CONSP (elt))
417 size_so_far += sizeof (struct Lisp_Cons);
418 if (STRINGP (XCAR (elt)))
419 size_so_far += (sizeof (struct Lisp_String) - 1
420 + SCHARS (XCAR (elt)));
423 /* Advance to next element. */
424 prev = next;
425 next = XCDR (next);
428 /* If we scanned the whole list, it is short enough; don't change it. */
429 if (NILP (next))
431 /* Truncate at the boundary where we decided to truncate. */
432 else if (!NILP (last_boundary))
433 XSETCDR (last_boundary, Qnil);
434 /* There's nothing we decided to keep, so clear it out. */
435 else
436 b->undo_list = Qnil;
438 unbind_to (count, Qnil);
441 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
442 doc: /* Undo N records from the front of the list LIST.
443 Return what remains of the list. */)
444 (Lisp_Object n, Lisp_Object list)
446 struct gcpro gcpro1, gcpro2;
447 Lisp_Object next;
448 int count = SPECPDL_INDEX ();
449 register int arg;
450 Lisp_Object oldlist;
451 int did_apply = 0;
453 #if 0 /* This is a good feature, but would make undo-start
454 unable to do what is expected. */
455 Lisp_Object tem;
457 /* If the head of the list is a boundary, it is the boundary
458 preceding this command. Get rid of it and don't count it. */
459 tem = Fcar (list);
460 if (NILP (tem))
461 list = Fcdr (list);
462 #endif
464 CHECK_NUMBER (n);
465 arg = XINT (n);
466 next = Qnil;
467 GCPRO2 (next, list);
468 /* I don't think we need to gcpro oldlist, as we use it only
469 to check for EQ. ++kfs */
471 /* In a writable buffer, enable undoing read-only text that is so
472 because of text properties. */
473 if (NILP (current_buffer->read_only))
474 specbind (Qinhibit_read_only, Qt);
476 /* Don't let `intangible' properties interfere with undo. */
477 specbind (Qinhibit_point_motion_hooks, Qt);
479 oldlist = current_buffer->undo_list;
481 while (arg > 0)
483 while (CONSP (list))
485 next = XCAR (list);
486 list = XCDR (list);
487 /* Exit inner loop at undo boundary. */
488 if (NILP (next))
489 break;
490 /* Handle an integer by setting point to that value. */
491 if (INTEGERP (next))
492 SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
493 else if (CONSP (next))
495 Lisp_Object car, cdr;
497 car = XCAR (next);
498 cdr = XCDR (next);
499 if (EQ (car, Qt))
501 /* Element (t high . low) records previous modtime. */
502 Lisp_Object high, low;
503 int mod_time;
504 struct buffer *base_buffer = current_buffer;
506 high = Fcar (cdr);
507 low = Fcdr (cdr);
508 mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
510 if (current_buffer->base_buffer)
511 base_buffer = current_buffer->base_buffer;
513 /* If this records an obsolete save
514 (not matching the actual disk file)
515 then don't mark unmodified. */
516 if (mod_time != base_buffer->modtime)
517 continue;
518 #ifdef CLASH_DETECTION
519 Funlock_buffer ();
520 #endif /* CLASH_DETECTION */
521 Fset_buffer_modified_p (Qnil);
523 else if (EQ (car, Qnil))
525 /* Element (nil PROP VAL BEG . END) is property change. */
526 Lisp_Object beg, end, prop, val;
528 prop = Fcar (cdr);
529 cdr = Fcdr (cdr);
530 val = Fcar (cdr);
531 cdr = Fcdr (cdr);
532 beg = Fcar (cdr);
533 end = Fcdr (cdr);
535 if (XINT (beg) < BEGV || XINT (end) > ZV)
536 error ("Changes to be undone are outside visible portion of buffer");
537 Fput_text_property (beg, end, prop, val, Qnil);
539 else if (INTEGERP (car) && INTEGERP (cdr))
541 /* Element (BEG . END) means range was inserted. */
543 if (XINT (car) < BEGV
544 || XINT (cdr) > ZV)
545 error ("Changes to be undone are outside visible portion of buffer");
546 /* Set point first thing, so that undoing this undo
547 does not send point back to where it is now. */
548 Fgoto_char (car);
549 Fdelete_region (car, cdr);
551 else if (EQ (car, Qapply))
553 /* Element (apply FUN . ARGS) means call FUN to undo. */
554 struct buffer *save_buffer = current_buffer;
556 car = Fcar (cdr);
557 cdr = Fcdr (cdr);
558 if (INTEGERP (car))
560 /* Long format: (apply DELTA START END FUN . ARGS). */
561 Lisp_Object delta = car;
562 Lisp_Object start = Fcar (cdr);
563 Lisp_Object end = Fcar (Fcdr (cdr));
564 Lisp_Object start_mark = Fcopy_marker (start, Qnil);
565 Lisp_Object end_mark = Fcopy_marker (end, Qt);
567 cdr = Fcdr (Fcdr (cdr));
568 apply1 (Fcar (cdr), Fcdr (cdr));
570 /* Check that the function did what the entry said it
571 would do. */
572 if (!EQ (start, Fmarker_position (start_mark))
573 || (XINT (delta) + XINT (end)
574 != marker_position (end_mark)))
575 error ("Changes to be undone by function different than announced");
576 Fset_marker (start_mark, Qnil, Qnil);
577 Fset_marker (end_mark, Qnil, Qnil);
579 else
580 apply1 (car, cdr);
582 if (save_buffer != current_buffer)
583 error ("Undo function switched buffer");
584 did_apply = 1;
586 else if (STRINGP (car) && INTEGERP (cdr))
588 /* Element (STRING . POS) means STRING was deleted. */
589 Lisp_Object membuf;
590 EMACS_INT pos = XINT (cdr);
592 membuf = car;
593 if (pos < 0)
595 if (-pos < BEGV || -pos > ZV)
596 error ("Changes to be undone are outside visible portion of buffer");
597 SET_PT (-pos);
598 Finsert (1, &membuf);
600 else
602 if (pos < BEGV || pos > ZV)
603 error ("Changes to be undone are outside visible portion of buffer");
604 SET_PT (pos);
606 /* Now that we record marker adjustments
607 (caused by deletion) for undo,
608 we should always insert after markers,
609 so that undoing the marker adjustments
610 put the markers back in the right place. */
611 Finsert (1, &membuf);
612 SET_PT (pos);
615 else if (MARKERP (car) && INTEGERP (cdr))
617 /* (MARKER . INTEGER) means a marker MARKER
618 was adjusted by INTEGER. */
619 if (XMARKER (car)->buffer)
620 Fset_marker (car,
621 make_number (marker_position (car) - XINT (cdr)),
622 Fmarker_buffer (car));
626 arg--;
630 /* Make sure an apply entry produces at least one undo entry,
631 so the test in `undo' for continuing an undo series
632 will work right. */
633 if (did_apply
634 && EQ (oldlist, current_buffer->undo_list))
635 current_buffer->undo_list
636 = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
638 UNGCPRO;
639 return unbind_to (count, list);
642 void
643 syms_of_undo (void)
645 Qinhibit_read_only = intern_c_string ("inhibit-read-only");
646 staticpro (&Qinhibit_read_only);
648 Qapply = intern_c_string ("apply");
649 staticpro (&Qapply);
651 pending_boundary = Qnil;
652 staticpro (&pending_boundary);
654 last_undo_buffer = NULL;
655 last_boundary_buffer = NULL;
657 defsubr (&Sprimitive_undo);
658 defsubr (&Sundo_boundary);
660 DEFVAR_INT ("undo-limit", undo_limit,
661 doc: /* Keep no more undo information once it exceeds this size.
662 This limit is applied when garbage collection happens.
663 When a previous command increases the total undo list size past this
664 value, the earlier commands that came before it are forgotten.
666 The size is counted as the number of bytes occupied,
667 which includes both saved text and other data. */);
668 undo_limit = 80000;
670 DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
671 doc: /* Don't keep more than this much size of undo information.
672 This limit is applied when garbage collection happens.
673 When a previous command increases the total undo list size past this
674 value, that command and the earlier commands that came before it are forgotten.
675 However, the most recent buffer-modifying command's undo info
676 is never discarded for this reason.
678 The size is counted as the number of bytes occupied,
679 which includes both saved text and other data. */);
680 undo_strong_limit = 120000;
682 DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
683 doc: /* Outer limit on size of undo information for one command.
684 At garbage collection time, if the current command has produced
685 more than this much undo information, it discards the info and displays
686 a warning. This is a last-ditch limit to prevent memory overflow.
688 The size is counted as the number of bytes occupied, which includes
689 both saved text and other data. A value of nil means no limit. In
690 this case, accumulating one huge undo entry could make Emacs crash as
691 a result of memory overflow.
693 In fact, this calls the function which is the value of
694 `undo-outer-limit-function' with one argument, the size.
695 The text above describes the behavior of the function
696 that variable usually specifies. */);
697 Vundo_outer_limit = make_number (12000000);
699 DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
700 doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
701 This function is called with one argument, the current undo list size
702 for the most recent command (since the last undo boundary).
703 If the function returns t, that means truncation has been fully handled.
704 If it returns nil, the other forms of truncation are done.
706 Garbage collection is inhibited around the call to this function,
707 so it must make sure not to do a lot of consing. */);
708 Vundo_outer_limit_function = Qnil;
710 DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
711 doc: /* Non-nil means do not record `point' in `buffer-undo-list'. */);
712 undo_inhibit_record_point = 0;