src/undo.c

   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.
   4
   5 This file is part of GNU Emacs.
   6
   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 3, or (at your option)
  10 any later version.
  11
  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.
  16
  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.  */
  21
  22
  23 #include <config.h>
  24 #include "lisp.h"
  25 #include "buffer.h"
  26 #include "commands.h"
  27 #include "window.h"
  28
  29 /* Limits controlling how much undo information to keep.  */
  30
  31 EMACS_INT undo_limit;
  32 EMACS_INT undo_strong_limit;
  33
  34 Lisp_Object Vundo_outer_limit;
  35
  36 /* Function to call when undo_outer_limit is exceeded.  */
  37
  38 Lisp_Object Vundo_outer_limit_function;
  39
  40 /* Last buffer for which undo information was recorded.  */
  41 Lisp_Object last_undo_buffer;
  42
  43 Lisp_Object Qinhibit_read_only;
  44
  45 /* Marker for function call undo list elements.  */
  46
  47 Lisp_Object Qapply;
  48
  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;
  55
  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.  */
  60
  61 static void
  62 record_point (pt)
  63      int pt;
  64 {
  65   int at_boundary;
  66
  67   /* Allocate a cons cell to be the undo boundary after this command.  */
  68   if (NILP (pending_boundary))
  69     pending_boundary = Fcons (Qnil, Qnil);
  70
  71   if (!BUFFERP (last_undo_buffer)
  72       || current_buffer != XBUFFER (last_undo_buffer))
  73     Fundo_boundary ();
  74   XSETBUFFER (last_undo_buffer, current_buffer);
  75
  76   if (CONSP (current_buffer->undo_list))
  77     {
  78       /* Set AT_BOUNDARY to 1 only when we have nothing other than
  79          marker adjustment before undo boundary.  */
  80
  81       Lisp_Object tail = current_buffer->undo_list, elt;
  82
  83       while (1)
  84         {
  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);
  92         }
  93       at_boundary = NILP (elt);
  94     }
  95   else
  96     at_boundary = 1;
  97
  98   if (MODIFF <= SAVE_MODIFF)
  99     record_first_change ();
 100
 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))
 107     {
 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);
 112
 113       if (last_point_position != pt)
 114         current_buffer->undo_list
 115           = Fcons (make_number (last_point_position), current_buffer->undo_list);
 116     }
 117 }
 118
 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.)  */
 123
 124 void
 125 record_insert (beg, length)
 126      int beg, length;
 127 {
 128   Lisp_Object lbeg, lend;
 129
 130   if (EQ (current_buffer->undo_list, Qt))
 131     return;
 132
 133   record_point (beg);
 134
 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))
 138     {
 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)
 145         {
 146           XSETCDR (elt, make_number (beg + length));
 147           return;
 148         }
 149     }
 150
 151   XSETFASTINT (lbeg, beg);
 152   XSETINT (lend, beg + length);
 153   current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
 154                                      current_buffer->undo_list);
 155 }
 156
 157 /* Record that a deletion is about to take place,
 158    of the characters in STRING, at location BEG.  */
 159
 160 void
 161 record_delete (beg, string)
 162      int beg;
 163      Lisp_Object string;
 164 {
 165   Lisp_Object sbeg;
 166
 167   if (EQ (current_buffer->undo_list, Qt))
 168     return;
 169
 170   if (PT == beg + SCHARS (string))
 171     {
 172       XSETINT (sbeg, -beg);
 173       record_point (PT);
 174     }
 175   else
 176     {
 177       XSETFASTINT (sbeg, beg);
 178       record_point (beg);
 179     }
 180
 181   current_buffer->undo_list
 182     = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
 183 }
 184
 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.  */
 189
 190 void
 191 record_marker_adjustment (marker, adjustment)
 192      Lisp_Object marker;
 193      int adjustment;
 194 {
 195   if (EQ (current_buffer->undo_list, Qt))
 196     return;
 197
 198   /* Allocate a cons cell to be the undo boundary after this command.  */
 199   if (NILP (pending_boundary))
 200     pending_boundary = Fcons (Qnil, Qnil);
 201
 202   if (!BUFFERP (last_undo_buffer)
 203       || current_buffer != XBUFFER (last_undo_buffer))
 204     Fundo_boundary ();
 205   XSETBUFFER (last_undo_buffer, current_buffer);
 206
 207   current_buffer->undo_list
 208     = Fcons (Fcons (marker, make_number (adjustment)),
 209              current_buffer->undo_list);
 210 }
 211
 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.  */
 215
 216 void
 217 record_change (beg, length)
 218      int beg, length;
 219 {
 220   record_delete (beg, make_buffer_string (beg, beg + length, 1));
 221   record_insert (beg, length);
 222 }
 223 \f
 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.  */
 227
 228 void
 229 record_first_change ()
 230 {
 231   Lisp_Object high, low;
 232   struct buffer *base_buffer = current_buffer;
 233
 234   if (EQ (current_buffer->undo_list, Qt))
 235     return;
 236
 237   if (!BUFFERP (last_undo_buffer)
 238       || current_buffer != XBUFFER (last_undo_buffer))
 239     Fundo_boundary ();
 240   XSETBUFFER (last_undo_buffer, current_buffer);
 241
 242   if (base_buffer->base_buffer)
 243     base_buffer = base_buffer->base_buffer;
 244
 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);
 248 }
 249
 250 /* Record a change in property PROP (whose old value was VAL)
 251    for LENGTH characters starting at position BEG in BUFFER.  */
 252
 253 void
 254 record_property_change (beg, length, prop, value, buffer)
 255      int beg, length;
 256      Lisp_Object prop, value, buffer;
 257 {
 258   Lisp_Object lbeg, lend, entry;
 259   struct buffer *obuf = current_buffer;
 260   int boundary = 0;
 261
 262   if (EQ (XBUFFER (buffer)->undo_list, Qt))
 263     return;
 264
 265   /* Allocate a cons cell to be the undo boundary after this command.  */
 266   if (NILP (pending_boundary))
 267     pending_boundary = Fcons (Qnil, Qnil);
 268
 269   if (!EQ (buffer, last_undo_buffer))
 270     boundary = 1;
 271   last_undo_buffer = buffer;
 272
 273   /* Switch temporarily to the buffer that was changed.  */
 274   current_buffer = XBUFFER (buffer);
 275
 276   if (boundary)
 277     Fundo_boundary ();
 278
 279   if (MODIFF <= SAVE_MODIFF)
 280     record_first_change ();
 281
 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);
 286
 287   current_buffer = obuf;
 288 }
 289
 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.  */)
 294      ()
 295 {
 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))
 301     {
 302       /* One way or another, cons nil onto the front of the undo list.  */
 303       if (!NILP (pending_boundary))
 304         {
 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;
 310         }
 311       else
 312         current_buffer->undo_list = Fcons (Qnil, current_buffer->undo_list);
 313     }
 314   return Qnil;
 315 }
 316
 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.  */
 321
 322 void
 323 truncate_undo_list (b)
 324      struct buffer *b;
 325 {
 326   Lisp_Object list;
 327   Lisp_Object prev, next, last_boundary;
 328   int size_so_far = 0;
 329
 330   /* Make sure that calling undo-outer-limit-function
 331      won't cause another GC.  */
 332   int count = inhibit_garbage_collection ();
 333
 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);
 339
 340   list = b->undo_list;
 341
 342   prev = Qnil;
 343   next = list;
 344   last_boundary = Qnil;
 345
 346   /* If the first element is an undo boundary, skip past it.  */
 347   if (CONSP (next) && NILP (XCAR (next)))
 348     {
 349       /* Add in the space occupied by this element and its chain link.  */
 350       size_so_far += sizeof (struct Lisp_Cons);
 351
 352       /* Advance to next element.  */
 353       prev = next;
 354       next = XCDR (next);
 355     }
 356
 357   /* Always preserve at least the most recent undo record
 358      unless it is really horribly big.
 359
 360      Skip, skip, skip the undo, skip, skip, skip the undo,
 361      Skip, skip, skip the undo, skip to the undo bound'ry.  */
 362
 363   while (CONSP (next) && ! NILP (XCAR (next)))
 364     {
 365       Lisp_Object elt;
 366       elt = XCAR (next);
 367
 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))
 371         {
 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)));
 376         }
 377
 378       /* Advance to next element.  */
 379       prev = next;
 380       next = XCDR (next);
 381     }
 382
 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))
 388     {
 389       Lisp_Object temp = last_undo_buffer, tem;
 390
 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))
 394         {
 395           /* The function is responsible for making
 396              any desired changes in buffer-undo-list.  */
 397           unbind_to (count, Qnil);
 398           return;
 399         }
 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;
 404     }
 405
 406   if (CONSP (next))
 407     last_boundary = prev;
 408
 409   /* Keep additional undo data, if it fits in the limits.  */
 410   while (CONSP (next))
 411     {
 412       Lisp_Object elt;
 413       elt = XCAR (next);
 414
 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))
 420         {
 421           if (size_so_far > undo_strong_limit)
 422             break;
 423           last_boundary = prev;
 424           if (size_so_far > undo_limit)
 425             break;
 426         }
 427
 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))
 431         {
 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)));
 436         }
 437
 438       /* Advance to next element.  */
 439       prev = next;
 440       next = XCDR (next);
 441     }
 442
 443   /* If we scanned the whole list, it is short enough; don't change it.  */
 444   if (NILP (next))
 445     ;
 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;
 452
 453   unbind_to (count, Qnil);
 454 }
 455 \f
 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;
 461 {
 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;
 468
 469 #if 0  /* This is a good feature, but would make undo-start
 470           unable to do what is expected.  */
 471   Lisp_Object tem;
 472
 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
 479
 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  */
 486
 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);
 491
 492   /* Don't let `intangible' properties interfere with undo.  */
 493   specbind (Qinhibit_point_motion_hooks, Qt);
 494
 495   oldlist = current_buffer->undo_list;
 496
 497   while (arg > 0)
 498     {
 499       while (CONSP (list))
 500         {
 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))
 510             {
 511               Lisp_Object car, cdr;
 512
 513               car = XCAR (next);
 514               cdr = XCDR (next);
 515               if (EQ (car, Qt))
 516                 {
 517                   /* Element (t high . low) records previous modtime.  */
 518                   Lisp_Object high, low;
 519                   int mod_time;
 520                   struct buffer *base_buffer = current_buffer;
 521
 522                   high = Fcar (cdr);
 523                   low = Fcdr (cdr);
 524                   mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
 525
 526                   if (current_buffer->base_buffer)
 527                     base_buffer = current_buffer->base_buffer;
 528
 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);
 538                 }
 539               else if (EQ (car, Qnil))
 540                 {
 541                   /* Element (nil PROP VAL BEG . END) is property change.  */
 542                   Lisp_Object beg, end, prop, val;
 543
 544                   prop = Fcar (cdr);
 545                   cdr = Fcdr (cdr);
 546                   val = Fcar (cdr);
 547                   cdr = Fcdr (cdr);
 548                   beg = Fcar (cdr);
 549                   end = Fcdr (cdr);
 550
 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);
 554                 }
 555               else if (INTEGERP (car) && INTEGERP (cdr))
 556                 {
 557                   /* Element (BEG . END) means range was inserted.  */
 558
 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);
 566                 }
 567               else if (EQ (car, Qapply))
 568                 {
 569                   /* Element (apply FUN . ARGS) means call FUN to undo.  */
 570                   struct buffer *save_buffer = current_buffer;
 571
 572                   car = Fcar (cdr);
 573                   cdr = Fcdr (cdr);
 574                   if (INTEGERP (car))
 575                     {
 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);
 582
 583                       cdr = Fcdr (Fcdr (cdr));
 584                       apply1 (Fcar (cdr), Fcdr (cdr));
 585
 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);
 594                     }
 595                   else
 596                     apply1 (car, cdr);
 597
 598                   if (save_buffer != current_buffer)
 599                     error ("Undo function switched buffer");
 600                   did_apply = 1;
 601                 }
 602               else if (STRINGP (car) && INTEGERP (cdr))
 603                 {
 604                   /* Element (STRING . POS) means STRING was deleted.  */
 605                   Lisp_Object membuf;
 606                   int pos = XINT (cdr);
 607
 608                   membuf = car;
 609                   if (pos < 0)
 610                     {
 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);
 615                     }
 616                   else
 617                     {
 618                       if (pos < BEGV || pos > ZV)
 619                         error ("Changes to be undone are outside visible portion of buffer");
 620                       SET_PT (pos);
 621
 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);
 629                     }
 630                 }
 631               else if (MARKERP (car) && INTEGERP (cdr))
 632                 {
 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));
 639                 }
 640             }
 641         }
 642       arg--;
 643     }
 644
 645
 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);
 653
 654   UNGCPRO;
 655   return unbind_to (count, list);
 656 }
 657 \f
 658 void
 659 syms_of_undo ()
 660 {
 661   Qinhibit_read_only = intern ("inhibit-read-only");
 662   staticpro (&Qinhibit_read_only);
 663
 664   Qapply = intern ("apply");
 665   staticpro (&Qapply);
 666
 667   pending_boundary = Qnil;
 668   staticpro (&pending_boundary);
 669
 670   defsubr (&Sprimitive_undo);
 671   defsubr (&Sundo_boundary);
 672
 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.
 678
 679 The size is counted as the number of bytes occupied,
 680 which includes both saved text and other data.  */);
 681   undo_limit = 20000;
 682
 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.
 690
 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;
 694
 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.
 700
 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.
 705
 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);
 711
 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.
 718
 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;
 722 }
 723
 724 /* arch-tag: d546ee01-4aed-4ffb-bb8b-eefaae50d38a
 725    (do not change this comment) */