* eshell/em-cmpl.el (eshell-pcomplete): More thoroughly imitate pcomplete.
[emacs.git] / src / undo.c
blobe878ef4dcf90af6e5b19cdc8fed3a49f0d28b50e
1 /* undo handling for GNU Emacs.
2 Copyright (C) 1990, 1993-1994, 2000-2012 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>
22 #include "lisp.h"
23 #include "character.h"
24 #include "buffer.h"
25 #include "commands.h"
26 #include "window.h"
28 /* Last buffer for which undo information was recorded. */
29 /* BEWARE: This is not traced by the GC, so never dereference it! */
30 static struct buffer *last_undo_buffer;
32 /* Position of point last time we inserted a boundary. */
33 static struct buffer *last_boundary_buffer;
34 static ptrdiff_t last_boundary_position;
36 Lisp_Object Qinhibit_read_only;
38 /* Marker for function call undo list elements. */
40 Lisp_Object Qapply;
42 /* The first time a command records something for undo.
43 it also allocates the undo-boundary object
44 which will be added to the list at the end of the command.
45 This ensures we can't run out of space while trying to make
46 an undo-boundary. */
47 static Lisp_Object pending_boundary;
49 /* Record point as it was at beginning of this command (if necessary)
50 and prepare the undo info for recording a change.
51 PT is the position of point that will naturally occur as a result of the
52 undo record that will be added just after this command terminates. */
54 static void
55 record_point (ptrdiff_t pt)
57 int at_boundary;
59 /* Don't record position of pt when undo_inhibit_record_point holds. */
60 if (undo_inhibit_record_point)
61 return;
63 /* Allocate a cons cell to be the undo boundary after this command. */
64 if (NILP (pending_boundary))
65 pending_boundary = Fcons (Qnil, Qnil);
67 if ((current_buffer != last_undo_buffer)
68 /* Don't call Fundo_boundary for the first change. Otherwise we
69 risk overwriting last_boundary_position in Fundo_boundary with
70 PT of the current buffer and as a consequence not insert an
71 undo boundary because last_boundary_position will equal pt in
72 the test at the end of the present function (Bug#731). */
73 && (MODIFF > SAVE_MODIFF))
74 Fundo_boundary ();
75 last_undo_buffer = current_buffer;
77 if (CONSP (BVAR (current_buffer, undo_list)))
79 /* Set AT_BOUNDARY to 1 only when we have nothing other than
80 marker adjustment before undo boundary. */
82 Lisp_Object tail = BVAR (current_buffer, undo_list), elt;
84 while (1)
86 if (NILP (tail))
87 elt = Qnil;
88 else
89 elt = XCAR (tail);
90 if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
91 break;
92 tail = XCDR (tail);
94 at_boundary = NILP (elt);
96 else
97 at_boundary = 1;
99 if (MODIFF <= SAVE_MODIFF)
100 record_first_change ();
102 /* If we are just after an undo boundary, and
103 point wasn't at start of deleted range, record where it was. */
104 if (at_boundary
105 && current_buffer == last_boundary_buffer
106 && last_boundary_position != pt)
107 bset_undo_list (current_buffer,
108 Fcons (make_number (last_boundary_position),
109 BVAR (current_buffer, undo_list)));
112 /* Record an insertion that just happened or is about to happen,
113 for LENGTH characters at position BEG.
114 (It is possible to record an insertion before or after the fact
115 because we don't need to record the contents.) */
117 void
118 record_insert (ptrdiff_t beg, ptrdiff_t length)
120 Lisp_Object lbeg, lend;
122 if (EQ (BVAR (current_buffer, undo_list), Qt))
123 return;
125 record_point (beg);
127 /* If this is following another insertion and consecutive with it
128 in the buffer, combine the two. */
129 if (CONSP (BVAR (current_buffer, undo_list)))
131 Lisp_Object elt;
132 elt = XCAR (BVAR (current_buffer, undo_list));
133 if (CONSP (elt)
134 && INTEGERP (XCAR (elt))
135 && INTEGERP (XCDR (elt))
136 && XINT (XCDR (elt)) == beg)
138 XSETCDR (elt, make_number (beg + length));
139 return;
143 XSETFASTINT (lbeg, beg);
144 XSETINT (lend, beg + length);
145 bset_undo_list (current_buffer,
146 Fcons (Fcons (lbeg, lend), BVAR (current_buffer, undo_list)));
149 /* Record that a deletion is about to take place,
150 of the characters in STRING, at location BEG. */
152 void
153 record_delete (ptrdiff_t beg, Lisp_Object string)
155 Lisp_Object sbeg;
157 if (EQ (BVAR (current_buffer, undo_list), Qt))
158 return;
160 if (PT == beg + SCHARS (string))
162 XSETINT (sbeg, -beg);
163 record_point (PT);
165 else
167 XSETFASTINT (sbeg, beg);
168 record_point (beg);
171 bset_undo_list
172 (current_buffer,
173 Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list)));
176 /* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
177 This is done only when a marker points within text being deleted,
178 because that's the only case where an automatic marker adjustment
179 won't be inverted automatically by undoing the buffer modification. */
181 void
182 record_marker_adjustment (Lisp_Object marker, ptrdiff_t adjustment)
184 if (EQ (BVAR (current_buffer, undo_list), Qt))
185 return;
187 /* Allocate a cons cell to be the undo boundary after this command. */
188 if (NILP (pending_boundary))
189 pending_boundary = Fcons (Qnil, Qnil);
191 if (current_buffer != last_undo_buffer)
192 Fundo_boundary ();
193 last_undo_buffer = current_buffer;
195 bset_undo_list
196 (current_buffer,
197 Fcons (Fcons (marker, make_number (adjustment)),
198 BVAR (current_buffer, undo_list)));
201 /* Record that a replacement is about to take place,
202 for LENGTH characters at location BEG.
203 The replacement must not change the number of characters. */
205 void
206 record_change (ptrdiff_t beg, ptrdiff_t length)
208 record_delete (beg, make_buffer_string (beg, beg + length, 1));
209 record_insert (beg, length);
212 /* Record that an unmodified buffer is about to be changed.
213 Record the file modification date so that when undoing this entry
214 we can tell whether it is obsolete because the file was saved again. */
216 void
217 record_first_change (void)
219 struct buffer *base_buffer = current_buffer;
221 if (EQ (BVAR (current_buffer, undo_list), Qt))
222 return;
224 if (current_buffer != last_undo_buffer)
225 Fundo_boundary ();
226 last_undo_buffer = current_buffer;
228 if (base_buffer->base_buffer)
229 base_buffer = base_buffer->base_buffer;
231 bset_undo_list
232 (current_buffer,
233 Fcons (Fcons (Qt, make_lisp_time (base_buffer->modtime)),
234 BVAR (current_buffer, undo_list)));
237 /* Record a change in property PROP (whose old value was VAL)
238 for LENGTH characters starting at position BEG in BUFFER. */
240 void
241 record_property_change (ptrdiff_t beg, ptrdiff_t length,
242 Lisp_Object prop, Lisp_Object value,
243 Lisp_Object buffer)
245 Lisp_Object lbeg, lend, entry;
246 struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
247 int boundary = 0;
249 if (EQ (BVAR (buf, undo_list), Qt))
250 return;
252 /* Allocate a cons cell to be the undo boundary after this command. */
253 if (NILP (pending_boundary))
254 pending_boundary = Fcons (Qnil, Qnil);
256 if (buf != last_undo_buffer)
257 boundary = 1;
258 last_undo_buffer = buf;
260 /* Switch temporarily to the buffer that was changed. */
261 current_buffer = buf;
263 if (boundary)
264 Fundo_boundary ();
266 if (MODIFF <= SAVE_MODIFF)
267 record_first_change ();
269 XSETINT (lbeg, beg);
270 XSETINT (lend, beg + length);
271 entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
272 bset_undo_list (current_buffer,
273 Fcons (entry, BVAR (current_buffer, undo_list)));
275 current_buffer = obuf;
278 DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
279 doc: /* Mark a boundary between units of undo.
280 An undo command will stop at this point,
281 but another undo command will undo to the previous boundary. */)
282 (void)
284 Lisp_Object tem;
285 if (EQ (BVAR (current_buffer, undo_list), Qt))
286 return Qnil;
287 tem = Fcar (BVAR (current_buffer, undo_list));
288 if (!NILP (tem))
290 /* One way or another, cons nil onto the front of the undo list. */
291 if (!NILP (pending_boundary))
293 /* If we have preallocated the cons cell to use here,
294 use that one. */
295 XSETCDR (pending_boundary, BVAR (current_buffer, undo_list));
296 bset_undo_list (current_buffer, pending_boundary);
297 pending_boundary = Qnil;
299 else
300 bset_undo_list (current_buffer,
301 Fcons (Qnil, BVAR (current_buffer, undo_list)));
303 last_boundary_position = PT;
304 last_boundary_buffer = current_buffer;
305 return Qnil;
308 /* At garbage collection time, make an undo list shorter at the end,
309 returning the truncated list. How this is done depends on the
310 variables undo-limit, undo-strong-limit and undo-outer-limit.
311 In some cases this works by calling undo-outer-limit-function. */
313 void
314 truncate_undo_list (struct buffer *b)
316 Lisp_Object list;
317 Lisp_Object prev, next, last_boundary;
318 EMACS_INT size_so_far = 0;
320 /* Make sure that calling undo-outer-limit-function
321 won't cause another GC. */
322 ptrdiff_t count = inhibit_garbage_collection ();
324 /* Make the buffer current to get its local values of variables such
325 as undo_limit. Also so that Vundo_outer_limit_function can
326 tell which buffer to operate on. */
327 record_unwind_current_buffer ();
328 set_buffer_internal (b);
330 list = BVAR (b, undo_list);
332 prev = Qnil;
333 next = list;
334 last_boundary = Qnil;
336 /* If the first element is an undo boundary, skip past it. */
337 if (CONSP (next) && NILP (XCAR (next)))
339 /* Add in the space occupied by this element and its chain link. */
340 size_so_far += sizeof (struct Lisp_Cons);
342 /* Advance to next element. */
343 prev = next;
344 next = XCDR (next);
347 /* Always preserve at least the most recent undo record
348 unless it is really horribly big.
350 Skip, skip, skip the undo, skip, skip, skip the undo,
351 Skip, skip, skip the undo, skip to the undo bound'ry. */
353 while (CONSP (next) && ! NILP (XCAR (next)))
355 Lisp_Object elt;
356 elt = XCAR (next);
358 /* Add in the space occupied by this element and its chain link. */
359 size_so_far += sizeof (struct Lisp_Cons);
360 if (CONSP (elt))
362 size_so_far += sizeof (struct Lisp_Cons);
363 if (STRINGP (XCAR (elt)))
364 size_so_far += (sizeof (struct Lisp_String) - 1
365 + SCHARS (XCAR (elt)));
368 /* Advance to next element. */
369 prev = next;
370 next = XCDR (next);
373 /* If by the first boundary we have already passed undo_outer_limit,
374 we're heading for memory full, so offer to clear out the list. */
375 if (INTEGERP (Vundo_outer_limit)
376 && size_so_far > XINT (Vundo_outer_limit)
377 && !NILP (Vundo_outer_limit_function))
379 Lisp_Object tem;
380 struct buffer *temp = last_undo_buffer;
382 /* Normally the function this calls is undo-outer-limit-truncate. */
383 tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
384 if (! NILP (tem))
386 /* The function is responsible for making
387 any desired changes in buffer-undo-list. */
388 unbind_to (count, Qnil);
389 return;
391 /* That function probably used the minibuffer, and if so, that
392 changed last_undo_buffer. Change it back so that we don't
393 force next change to make an undo boundary here. */
394 last_undo_buffer = temp;
397 if (CONSP (next))
398 last_boundary = prev;
400 /* Keep additional undo data, if it fits in the limits. */
401 while (CONSP (next))
403 Lisp_Object elt;
404 elt = XCAR (next);
406 /* When we get to a boundary, decide whether to truncate
407 either before or after it. The lower threshold, undo_limit,
408 tells us to truncate after it. If its size pushes past
409 the higher threshold undo_strong_limit, we truncate before it. */
410 if (NILP (elt))
412 if (size_so_far > undo_strong_limit)
413 break;
414 last_boundary = prev;
415 if (size_so_far > undo_limit)
416 break;
419 /* Add in the space occupied by this element and its chain link. */
420 size_so_far += sizeof (struct Lisp_Cons);
421 if (CONSP (elt))
423 size_so_far += sizeof (struct Lisp_Cons);
424 if (STRINGP (XCAR (elt)))
425 size_so_far += (sizeof (struct Lisp_String) - 1
426 + SCHARS (XCAR (elt)));
429 /* Advance to next element. */
430 prev = next;
431 next = XCDR (next);
434 /* If we scanned the whole list, it is short enough; don't change it. */
435 if (NILP (next))
437 /* Truncate at the boundary where we decided to truncate. */
438 else if (!NILP (last_boundary))
439 XSETCDR (last_boundary, Qnil);
440 /* There's nothing we decided to keep, so clear it out. */
441 else
442 bset_undo_list (b, Qnil);
444 unbind_to (count, Qnil);
447 static _Noreturn void
448 user_error (const char *msg)
450 xsignal1 (Quser_error, build_string (msg));
454 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
455 doc: /* Undo N records from the front of the list LIST.
456 Return what remains of the list. */)
457 (Lisp_Object n, Lisp_Object list)
459 struct gcpro gcpro1, gcpro2;
460 Lisp_Object next;
461 ptrdiff_t count = SPECPDL_INDEX ();
462 register EMACS_INT arg;
463 Lisp_Object oldlist;
464 int did_apply = 0;
466 #if 0 /* This is a good feature, but would make undo-start
467 unable to do what is expected. */
468 Lisp_Object tem;
470 /* If the head of the list is a boundary, it is the boundary
471 preceding this command. Get rid of it and don't count it. */
472 tem = Fcar (list);
473 if (NILP (tem))
474 list = Fcdr (list);
475 #endif
477 CHECK_NUMBER (n);
478 arg = XINT (n);
479 next = Qnil;
480 GCPRO2 (next, list);
481 /* I don't think we need to gcpro oldlist, as we use it only
482 to check for EQ. ++kfs */
484 /* In a writable buffer, enable undoing read-only text that is so
485 because of text properties. */
486 if (NILP (BVAR (current_buffer, read_only)))
487 specbind (Qinhibit_read_only, Qt);
489 /* Don't let `intangible' properties interfere with undo. */
490 specbind (Qinhibit_point_motion_hooks, Qt);
492 oldlist = BVAR (current_buffer, undo_list);
494 while (arg > 0)
496 while (CONSP (list))
498 next = XCAR (list);
499 list = XCDR (list);
500 /* Exit inner loop at undo boundary. */
501 if (NILP (next))
502 break;
503 /* Handle an integer by setting point to that value. */
504 if (INTEGERP (next))
505 SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
506 else if (CONSP (next))
508 Lisp_Object car, cdr;
510 car = XCAR (next);
511 cdr = XCDR (next);
512 if (EQ (car, Qt))
514 /* Element (t . TIME) records previous modtime.
515 Preserve any flag of NONEXISTENT_MODTIME_NSECS or
516 UNKNOWN_MODTIME_NSECS. */
517 struct buffer *base_buffer = current_buffer;
518 EMACS_TIME mod_time;
520 if (CONSP (cdr)
521 && CONSP (XCDR (cdr))
522 && CONSP (XCDR (XCDR (cdr)))
523 && CONSP (XCDR (XCDR (XCDR (cdr))))
524 && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr)))))
525 && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0)
526 mod_time =
527 (make_emacs_time
528 (0, XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000));
529 else
530 mod_time = lisp_time_argument (cdr);
532 if (current_buffer->base_buffer)
533 base_buffer = current_buffer->base_buffer;
535 /* If this records an obsolete save
536 (not matching the actual disk file)
537 then don't mark unmodified. */
538 if (EMACS_TIME_NE (mod_time, base_buffer->modtime))
539 continue;
540 #ifdef CLASH_DETECTION
541 Funlock_buffer ();
542 #endif /* CLASH_DETECTION */
543 Fset_buffer_modified_p (Qnil);
545 else if (EQ (car, Qnil))
547 /* Element (nil PROP VAL BEG . END) is property change. */
548 Lisp_Object beg, end, prop, val;
550 prop = Fcar (cdr);
551 cdr = Fcdr (cdr);
552 val = Fcar (cdr);
553 cdr = Fcdr (cdr);
554 beg = Fcar (cdr);
555 end = Fcdr (cdr);
557 if (XINT (beg) < BEGV || XINT (end) > ZV)
558 user_error ("Changes to be undone are outside visible portion of buffer");
559 Fput_text_property (beg, end, prop, val, Qnil);
561 else if (INTEGERP (car) && INTEGERP (cdr))
563 /* Element (BEG . END) means range was inserted. */
565 if (XINT (car) < BEGV
566 || XINT (cdr) > ZV)
567 user_error ("Changes to be undone are outside visible portion of buffer");
568 /* Set point first thing, so that undoing this undo
569 does not send point back to where it is now. */
570 Fgoto_char (car);
571 Fdelete_region (car, cdr);
573 else if (EQ (car, Qapply))
575 /* Element (apply FUN . ARGS) means call FUN to undo. */
576 struct buffer *save_buffer = current_buffer;
578 car = Fcar (cdr);
579 cdr = Fcdr (cdr);
580 if (INTEGERP (car))
582 /* Long format: (apply DELTA START END FUN . ARGS). */
583 Lisp_Object delta = car;
584 Lisp_Object start = Fcar (cdr);
585 Lisp_Object end = Fcar (Fcdr (cdr));
586 Lisp_Object start_mark = Fcopy_marker (start, Qnil);
587 Lisp_Object end_mark = Fcopy_marker (end, Qt);
589 cdr = Fcdr (Fcdr (cdr));
590 apply1 (Fcar (cdr), Fcdr (cdr));
592 /* Check that the function did what the entry said it
593 would do. */
594 if (!EQ (start, Fmarker_position (start_mark))
595 || (XINT (delta) + XINT (end)
596 != marker_position (end_mark)))
597 error ("Changes to be undone by function different than announced");
598 Fset_marker (start_mark, Qnil, Qnil);
599 Fset_marker (end_mark, Qnil, Qnil);
601 else
602 apply1 (car, cdr);
604 if (save_buffer != current_buffer)
605 error ("Undo function switched buffer");
606 did_apply = 1;
608 else if (STRINGP (car) && INTEGERP (cdr))
610 /* Element (STRING . POS) means STRING was deleted. */
611 Lisp_Object membuf;
612 EMACS_INT pos = XINT (cdr);
614 membuf = car;
615 if (pos < 0)
617 if (-pos < BEGV || -pos > ZV)
618 user_error ("Changes to be undone are outside visible portion of buffer");
619 SET_PT (-pos);
620 Finsert (1, &membuf);
622 else
624 if (pos < BEGV || pos > ZV)
625 user_error ("Changes to be undone are outside visible portion of buffer");
626 SET_PT (pos);
628 /* Now that we record marker adjustments
629 (caused by deletion) for undo,
630 we should always insert after markers,
631 so that undoing the marker adjustments
632 put the markers back in the right place. */
633 Finsert (1, &membuf);
634 SET_PT (pos);
637 else if (MARKERP (car) && INTEGERP (cdr))
639 /* (MARKER . INTEGER) means a marker MARKER
640 was adjusted by INTEGER. */
641 if (XMARKER (car)->buffer)
642 Fset_marker (car,
643 make_number (marker_position (car) - XINT (cdr)),
644 Fmarker_buffer (car));
648 arg--;
652 /* Make sure an apply entry produces at least one undo entry,
653 so the test in `undo' for continuing an undo series
654 will work right. */
655 if (did_apply
656 && EQ (oldlist, BVAR (current_buffer, undo_list)))
657 bset_undo_list
658 (current_buffer,
659 Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list)));
661 UNGCPRO;
662 return unbind_to (count, list);
665 void
666 syms_of_undo (void)
668 DEFSYM (Qinhibit_read_only, "inhibit-read-only");
669 DEFSYM (Qapply, "apply");
671 pending_boundary = Qnil;
672 staticpro (&pending_boundary);
674 last_undo_buffer = NULL;
675 last_boundary_buffer = NULL;
677 defsubr (&Sprimitive_undo);
678 defsubr (&Sundo_boundary);
680 DEFVAR_INT ("undo-limit", undo_limit,
681 doc: /* Keep no more undo information once it exceeds this size.
682 This limit is applied when garbage collection happens.
683 When a previous command increases the total undo list size past this
684 value, the earlier commands that came before it are forgotten.
686 The size is counted as the number of bytes occupied,
687 which includes both saved text and other data. */);
688 undo_limit = 80000;
690 DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
691 doc: /* Don't keep more than this much size of undo information.
692 This limit is applied when garbage collection happens.
693 When a previous command increases the total undo list size past this
694 value, that command and the earlier commands that came before it are forgotten.
695 However, the most recent buffer-modifying command's undo info
696 is never discarded for this reason.
698 The size is counted as the number of bytes occupied,
699 which includes both saved text and other data. */);
700 undo_strong_limit = 120000;
702 DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
703 doc: /* Outer limit on size of undo information for one command.
704 At garbage collection time, if the current command has produced
705 more than this much undo information, it discards the info and displays
706 a warning. This is a last-ditch limit to prevent memory overflow.
708 The size is counted as the number of bytes occupied, which includes
709 both saved text and other data. A value of nil means no limit. In
710 this case, accumulating one huge undo entry could make Emacs crash as
711 a result of memory overflow.
713 In fact, this calls the function which is the value of
714 `undo-outer-limit-function' with one argument, the size.
715 The text above describes the behavior of the function
716 that variable usually specifies. */);
717 Vundo_outer_limit = make_number (12000000);
719 DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
720 doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
721 This function is called with one argument, the current undo list size
722 for the most recent command (since the last undo boundary).
723 If the function returns t, that means truncation has been fully handled.
724 If it returns nil, the other forms of truncation are done.
726 Garbage collection is inhibited around the call to this function,
727 so it must make sure not to do a lot of consing. */);
728 Vundo_outer_limit_function = Qnil;
730 DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
731 doc: /* Non-nil means do not record `point' in `buffer-undo-list'. */);
732 undo_inhibit_record_point = 0;