src/undo.c

   1 /* undo handling for GNU Emacs.
   2    Copyright (C) 1990, 1993-1994, 2000-2012  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   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.
  10
  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.
  15
  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/>.  */
  18
  19
  20 #include <config.h>
  21 #include <setjmp.h>
  22 #include "lisp.h"
  23 #include "buffer.h"
  24 #include "commands.h"
  25 #include "window.h"
  26
  27 /* Last buffer for which undo information was recorded.  */
  28 /* BEWARE: This is not traced by the GC, so never dereference it!  */
  29 static struct buffer *last_undo_buffer;
  30
  31 /* Position of point last time we inserted a boundary.  */
  32 static struct buffer *last_boundary_buffer;
  33 static EMACS_INT last_boundary_position;
  34
  35 Lisp_Object Qinhibit_read_only;
  36
  37 /* Marker for function call undo list elements.  */
  38
  39 Lisp_Object Qapply;
  40
  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 static Lisp_Object pending_boundary;
  47
  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.  */
  52
  53 static void
  54 record_point (EMACS_INT pt)
  55 {
  56   int at_boundary;
  57
  58   /* Don't record position of pt when undo_inhibit_record_point holds.  */
  59   if (undo_inhibit_record_point)
  60     return;
  61
  62   /* Allocate a cons cell to be the undo boundary after this command.  */
  63   if (NILP (pending_boundary))
  64     pending_boundary = Fcons (Qnil, Qnil);
  65
  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;
  75
  76   if (CONSP (BVAR (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 = BVAR (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       && current_buffer == last_boundary_buffer
 105       && last_boundary_position != pt)
 106     BVAR (current_buffer, undo_list)
 107       = Fcons (make_number (last_boundary_position), BVAR (current_buffer, undo_list));
 108 }
 109
 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.)  */
 114
 115 void
 116 record_insert (EMACS_INT beg, EMACS_INT length)
 117 {
 118   Lisp_Object lbeg, lend;
 119
 120   if (EQ (BVAR (current_buffer, undo_list), Qt))
 121     return;
 122
 123   record_point (beg);
 124
 125   /* If this is following another insertion and consecutive with it
 126      in the buffer, combine the two.  */
 127   if (CONSP (BVAR (current_buffer, undo_list)))
 128     {
 129       Lisp_Object elt;
 130       elt = XCAR (BVAR (current_buffer, undo_list));
 131       if (CONSP (elt)
 132           && INTEGERP (XCAR (elt))
 133           && INTEGERP (XCDR (elt))
 134           && XINT (XCDR (elt)) == beg)
 135         {
 136           XSETCDR (elt, make_number (beg + length));
 137           return;
 138         }
 139     }
 140
 141   XSETFASTINT (lbeg, beg);
 142   XSETINT (lend, beg + length);
 143   BVAR (current_buffer, undo_list) = Fcons (Fcons (lbeg, lend),
 144                                      BVAR (current_buffer, undo_list));
 145 }
 146
 147 /* Record that a deletion is about to take place,
 148    of the characters in STRING, at location BEG.  */
 149
 150 void
 151 record_delete (EMACS_INT beg, Lisp_Object string)
 152 {
 153   Lisp_Object sbeg;
 154
 155   if (EQ (BVAR (current_buffer, undo_list), Qt))
 156     return;
 157
 158   if (PT == beg + SCHARS (string))
 159     {
 160       XSETINT (sbeg, -beg);
 161       record_point (PT);
 162     }
 163   else
 164     {
 165       XSETFASTINT (sbeg, beg);
 166       record_point (beg);
 167     }
 168
 169   BVAR (current_buffer, undo_list)
 170     = Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list));
 171 }
 172
 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.  */
 177
 178 void
 179 record_marker_adjustment (Lisp_Object marker, EMACS_INT adjustment)
 180 {
 181   if (EQ (BVAR (current_buffer, undo_list), Qt))
 182     return;
 183
 184   /* Allocate a cons cell to be the undo boundary after this command.  */
 185   if (NILP (pending_boundary))
 186     pending_boundary = Fcons (Qnil, Qnil);
 187
 188   if (current_buffer != last_undo_buffer)
 189     Fundo_boundary ();
 190   last_undo_buffer = current_buffer;
 191
 192   BVAR (current_buffer, undo_list)
 193     = Fcons (Fcons (marker, make_number (adjustment)),
 194              BVAR (current_buffer, undo_list));
 195 }
 196
 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.  */
 200
 201 void
 202 record_change (EMACS_INT beg, EMACS_INT length)
 203 {
 204   record_delete (beg, make_buffer_string (beg, beg + length, 1));
 205   record_insert (beg, length);
 206 }
 207 \f
 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.  */
 211
 212 void
 213 record_first_change (void)
 214 {
 215   struct buffer *base_buffer = current_buffer;
 216
 217   if (EQ (BVAR (current_buffer, undo_list), Qt))
 218     return;
 219
 220   if (current_buffer != last_undo_buffer)
 221     Fundo_boundary ();
 222   last_undo_buffer = current_buffer;
 223
 224   if (base_buffer->base_buffer)
 225     base_buffer = base_buffer->base_buffer;
 226
 227   BVAR (current_buffer, undo_list) =
 228     Fcons (Fcons (Qt, INTEGER_TO_CONS (base_buffer->modtime)),
 229            BVAR (current_buffer, undo_list));
 230 }
 231
 232 /* Record a change in property PROP (whose old value was VAL)
 233    for LENGTH characters starting at position BEG in BUFFER.  */
 234
 235 void
 236 record_property_change (EMACS_INT beg, EMACS_INT length,
 237                         Lisp_Object prop, Lisp_Object value,
 238                         Lisp_Object buffer)
 239 {
 240   Lisp_Object lbeg, lend, entry;
 241   struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
 242   int boundary = 0;
 243
 244   if (EQ (BVAR (buf, undo_list), Qt))
 245     return;
 246
 247   /* Allocate a cons cell to be the undo boundary after this command.  */
 248   if (NILP (pending_boundary))
 249     pending_boundary = Fcons (Qnil, Qnil);
 250
 251   if (buf != last_undo_buffer)
 252     boundary = 1;
 253   last_undo_buffer = buf;
 254
 255   /* Switch temporarily to the buffer that was changed.  */
 256   current_buffer = buf;
 257
 258   if (boundary)
 259     Fundo_boundary ();
 260
 261   if (MODIFF <= SAVE_MODIFF)
 262     record_first_change ();
 263
 264   XSETINT (lbeg, beg);
 265   XSETINT (lend, beg + length);
 266   entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
 267   BVAR (current_buffer, undo_list) = Fcons (entry, BVAR (current_buffer, undo_list));
 268
 269   current_buffer = obuf;
 270 }
 271
 272 DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
 273        doc: /* Mark a boundary between units of undo.
 274 An undo command will stop at this point,
 275 but another undo command will undo to the previous boundary.  */)
 276   (void)
 277 {
 278   Lisp_Object tem;
 279   if (EQ (BVAR (current_buffer, undo_list), Qt))
 280     return Qnil;
 281   tem = Fcar (BVAR (current_buffer, undo_list));
 282   if (!NILP (tem))
 283     {
 284       /* One way or another, cons nil onto the front of the undo list.  */
 285       if (!NILP (pending_boundary))
 286         {
 287           /* If we have preallocated the cons cell to use here,
 288              use that one.  */
 289           XSETCDR (pending_boundary, BVAR (current_buffer, undo_list));
 290           BVAR (current_buffer, undo_list) = pending_boundary;
 291           pending_boundary = Qnil;
 292         }
 293       else
 294         BVAR (current_buffer, undo_list) = Fcons (Qnil, BVAR (current_buffer, undo_list));
 295     }
 296   last_boundary_position = PT;
 297   last_boundary_buffer = current_buffer;
 298   return Qnil;
 299 }
 300
 301 /* At garbage collection time, make an undo list shorter at the end,
 302    returning the truncated list.  How this is done depends on the
 303    variables undo-limit, undo-strong-limit and undo-outer-limit.
 304    In some cases this works by calling undo-outer-limit-function.  */
 305
 306 void
 307 truncate_undo_list (struct buffer *b)
 308 {
 309   Lisp_Object list;
 310   Lisp_Object prev, next, last_boundary;
 311   int size_so_far = 0;
 312
 313   /* Make sure that calling undo-outer-limit-function
 314      won't cause another GC.  */
 315   int count = inhibit_garbage_collection ();
 316
 317   /* Make the buffer current to get its local values of variables such
 318      as undo_limit.  Also so that Vundo_outer_limit_function can
 319      tell which buffer to operate on.  */
 320   record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
 321   set_buffer_internal (b);
 322
 323   list = BVAR (b, undo_list);
 324
 325   prev = Qnil;
 326   next = list;
 327   last_boundary = Qnil;
 328
 329   /* If the first element is an undo boundary, skip past it.  */
 330   if (CONSP (next) && NILP (XCAR (next)))
 331     {
 332       /* Add in the space occupied by this element and its chain link.  */
 333       size_so_far += sizeof (struct Lisp_Cons);
 334
 335       /* Advance to next element.  */
 336       prev = next;
 337       next = XCDR (next);
 338     }
 339
 340   /* Always preserve at least the most recent undo record
 341      unless it is really horribly big.
 342
 343      Skip, skip, skip the undo, skip, skip, skip the undo,
 344      Skip, skip, skip the undo, skip to the undo bound'ry.  */
 345
 346   while (CONSP (next) && ! NILP (XCAR (next)))
 347     {
 348       Lisp_Object elt;
 349       elt = XCAR (next);
 350
 351       /* Add in the space occupied by this element and its chain link.  */
 352       size_so_far += sizeof (struct Lisp_Cons);
 353       if (CONSP (elt))
 354         {
 355           size_so_far += sizeof (struct Lisp_Cons);
 356           if (STRINGP (XCAR (elt)))
 357             size_so_far += (sizeof (struct Lisp_String) - 1
 358                             + SCHARS (XCAR (elt)));
 359         }
 360
 361       /* Advance to next element.  */
 362       prev = next;
 363       next = XCDR (next);
 364     }
 365
 366   /* If by the first boundary we have already passed undo_outer_limit,
 367      we're heading for memory full, so offer to clear out the list.  */
 368   if (INTEGERP (Vundo_outer_limit)
 369       && size_so_far > XINT (Vundo_outer_limit)
 370       && !NILP (Vundo_outer_limit_function))
 371     {
 372       Lisp_Object tem;
 373       struct buffer *temp = last_undo_buffer;
 374
 375       /* Normally the function this calls is undo-outer-limit-truncate.  */
 376       tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
 377       if (! NILP (tem))
 378         {
 379           /* The function is responsible for making
 380              any desired changes in buffer-undo-list.  */
 381           unbind_to (count, Qnil);
 382           return;
 383         }
 384       /* That function probably used the minibuffer, and if so, that
 385          changed last_undo_buffer.  Change it back so that we don't
 386          force next change to make an undo boundary here.  */
 387       last_undo_buffer = temp;
 388     }
 389
 390   if (CONSP (next))
 391     last_boundary = prev;
 392
 393   /* Keep additional undo data, if it fits in the limits.  */
 394   while (CONSP (next))
 395     {
 396       Lisp_Object elt;
 397       elt = XCAR (next);
 398
 399       /* When we get to a boundary, decide whether to truncate
 400          either before or after it.  The lower threshold, undo_limit,
 401          tells us to truncate after it.  If its size pushes past
 402          the higher threshold undo_strong_limit, we truncate before it.  */
 403       if (NILP (elt))
 404         {
 405           if (size_so_far > undo_strong_limit)
 406             break;
 407           last_boundary = prev;
 408           if (size_so_far > undo_limit)
 409             break;
 410         }
 411
 412       /* Add in the space occupied by this element and its chain link.  */
 413       size_so_far += sizeof (struct Lisp_Cons);
 414       if (CONSP (elt))
 415         {
 416           size_so_far += sizeof (struct Lisp_Cons);
 417           if (STRINGP (XCAR (elt)))
 418             size_so_far += (sizeof (struct Lisp_String) - 1
 419                             + SCHARS (XCAR (elt)));
 420         }
 421
 422       /* Advance to next element.  */
 423       prev = next;
 424       next = XCDR (next);
 425     }
 426
 427   /* If we scanned the whole list, it is short enough; don't change it.  */
 428   if (NILP (next))
 429     ;
 430   /* Truncate at the boundary where we decided to truncate.  */
 431   else if (!NILP (last_boundary))
 432     XSETCDR (last_boundary, Qnil);
 433   /* There's nothing we decided to keep, so clear it out.  */
 434   else
 435     BVAR (b, undo_list) = Qnil;
 436
 437   unbind_to (count, Qnil);
 438 }
 439 \f
 440 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
 441        doc: /* Undo N records from the front of the list LIST.
 442 Return what remains of the list.  */)
 443   (Lisp_Object n, Lisp_Object list)
 444 {
 445   struct gcpro gcpro1, gcpro2;
 446   Lisp_Object next;
 447   int count = SPECPDL_INDEX ();
 448   register int arg;
 449   Lisp_Object oldlist;
 450   int did_apply = 0;
 451
 452 #if 0  /* This is a good feature, but would make undo-start
 453           unable to do what is expected.  */
 454   Lisp_Object tem;
 455
 456   /* If the head of the list is a boundary, it is the boundary
 457      preceding this command.  Get rid of it and don't count it.  */
 458   tem = Fcar (list);
 459   if (NILP (tem))
 460     list = Fcdr (list);
 461 #endif
 462
 463   CHECK_NUMBER (n);
 464   arg = XINT (n);
 465   next = Qnil;
 466   GCPRO2 (next, list);
 467   /* I don't think we need to gcpro oldlist, as we use it only
 468      to check for EQ.  ++kfs  */
 469
 470   /* In a writable buffer, enable undoing read-only text that is so
 471      because of text properties.  */
 472   if (NILP (BVAR (current_buffer, read_only)))
 473     specbind (Qinhibit_read_only, Qt);
 474
 475   /* Don't let `intangible' properties interfere with undo.  */
 476   specbind (Qinhibit_point_motion_hooks, Qt);
 477
 478   oldlist = BVAR (current_buffer, undo_list);
 479
 480   while (arg > 0)
 481     {
 482       while (CONSP (list))
 483         {
 484           next = XCAR (list);
 485           list = XCDR (list);
 486           /* Exit inner loop at undo boundary.  */
 487           if (NILP (next))
 488             break;
 489           /* Handle an integer by setting point to that value.  */
 490           if (INTEGERP (next))
 491             SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
 492           else if (CONSP (next))
 493             {
 494               Lisp_Object car, cdr;
 495
 496               car = XCAR (next);
 497               cdr = XCDR (next);
 498               if (EQ (car, Qt))
 499                 {
 500                   /* Element (t high . low) records previous modtime.  */
 501                   struct buffer *base_buffer = current_buffer;
 502                   time_t mod_time;
 503                   CONS_TO_INTEGER (cdr, time_t, mod_time);
 504
 505                   if (current_buffer->base_buffer)
 506                     base_buffer = current_buffer->base_buffer;
 507
 508                   /* If this records an obsolete save
 509                      (not matching the actual disk file)
 510                      then don't mark unmodified.  */
 511                   if (mod_time != base_buffer->modtime)
 512                     continue;
 513 #ifdef CLASH_DETECTION
 514                   Funlock_buffer ();
 515 #endif /* CLASH_DETECTION */
 516                   Fset_buffer_modified_p (Qnil);
 517                 }
 518               else if (EQ (car, Qnil))
 519                 {
 520                   /* Element (nil PROP VAL BEG . END) is property change.  */
 521                   Lisp_Object beg, end, prop, val;
 522
 523                   prop = Fcar (cdr);
 524                   cdr = Fcdr (cdr);
 525                   val = Fcar (cdr);
 526                   cdr = Fcdr (cdr);
 527                   beg = Fcar (cdr);
 528                   end = Fcdr (cdr);
 529
 530                   if (XINT (beg) < BEGV || XINT (end) > ZV)
 531                     error ("Changes to be undone are outside visible portion of buffer");
 532                   Fput_text_property (beg, end, prop, val, Qnil);
 533                 }
 534               else if (INTEGERP (car) && INTEGERP (cdr))
 535                 {
 536                   /* Element (BEG . END) means range was inserted.  */
 537
 538                   if (XINT (car) < BEGV
 539                       || XINT (cdr) > ZV)
 540                     error ("Changes to be undone are outside visible portion of buffer");
 541                   /* Set point first thing, so that undoing this undo
 542                      does not send point back to where it is now.  */
 543                   Fgoto_char (car);
 544                   Fdelete_region (car, cdr);
 545                 }
 546               else if (EQ (car, Qapply))
 547                 {
 548                   /* Element (apply FUN . ARGS) means call FUN to undo.  */
 549                   struct buffer *save_buffer = current_buffer;
 550
 551                   car = Fcar (cdr);
 552                   cdr = Fcdr (cdr);
 553                   if (INTEGERP (car))
 554                     {
 555                       /* Long format: (apply DELTA START END FUN . ARGS).  */
 556                       Lisp_Object delta = car;
 557                       Lisp_Object start = Fcar (cdr);
 558                       Lisp_Object end   = Fcar (Fcdr (cdr));
 559                       Lisp_Object start_mark = Fcopy_marker (start, Qnil);
 560                       Lisp_Object end_mark   = Fcopy_marker (end, Qt);
 561
 562                       cdr = Fcdr (Fcdr (cdr));
 563                       apply1 (Fcar (cdr), Fcdr (cdr));
 564
 565                       /* Check that the function did what the entry said it
 566                          would do.  */
 567                       if (!EQ (start, Fmarker_position (start_mark))
 568                           || (XINT (delta) + XINT (end)
 569                               != marker_position (end_mark)))
 570                         error ("Changes to be undone by function different than announced");
 571                       Fset_marker (start_mark, Qnil, Qnil);
 572                       Fset_marker (end_mark, Qnil, Qnil);
 573                     }
 574                   else
 575                     apply1 (car, cdr);
 576
 577                   if (save_buffer != current_buffer)
 578                     error ("Undo function switched buffer");
 579                   did_apply = 1;
 580                 }
 581               else if (STRINGP (car) && INTEGERP (cdr))
 582                 {
 583                   /* Element (STRING . POS) means STRING was deleted.  */
 584                   Lisp_Object membuf;
 585                   EMACS_INT pos = XINT (cdr);
 586
 587                   membuf = car;
 588                   if (pos < 0)
 589                     {
 590                       if (-pos < BEGV || -pos > ZV)
 591                         error ("Changes to be undone are outside visible portion of buffer");
 592                       SET_PT (-pos);
 593                       Finsert (1, &membuf);
 594                     }
 595                   else
 596                     {
 597                       if (pos < BEGV || pos > ZV)
 598                         error ("Changes to be undone are outside visible portion of buffer");
 599                       SET_PT (pos);
 600
 601                       /* Now that we record marker adjustments
 602                          (caused by deletion) for undo,
 603                          we should always insert after markers,
 604                          so that undoing the marker adjustments
 605                          put the markers back in the right place.  */
 606                       Finsert (1, &membuf);
 607                       SET_PT (pos);
 608                     }
 609                 }
 610               else if (MARKERP (car) && INTEGERP (cdr))
 611                 {
 612                   /* (MARKER . INTEGER) means a marker MARKER
 613                      was adjusted by INTEGER.  */
 614                   if (XMARKER (car)->buffer)
 615                     Fset_marker (car,
 616                                  make_number (marker_position (car) - XINT (cdr)),
 617                                  Fmarker_buffer (car));
 618                 }
 619             }
 620         }
 621       arg--;
 622     }
 623
 624
 625   /* Make sure an apply entry produces at least one undo entry,
 626      so the test in `undo' for continuing an undo series
 627      will work right.  */
 628   if (did_apply
 629       && EQ (oldlist, BVAR (current_buffer, undo_list)))
 630     BVAR (current_buffer, undo_list)
 631       = Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list));
 632
 633   UNGCPRO;
 634   return unbind_to (count, list);
 635 }
 636 \f
 637 void
 638 syms_of_undo (void)
 639 {
 640   DEFSYM (Qinhibit_read_only, "inhibit-read-only");
 641   DEFSYM (Qapply, "apply");
 642
 643   pending_boundary = Qnil;
 644   staticpro (&pending_boundary);
 645
 646   last_undo_buffer = NULL;
 647   last_boundary_buffer = NULL;
 648
 649   defsubr (&Sprimitive_undo);
 650   defsubr (&Sundo_boundary);
 651
 652   DEFVAR_INT ("undo-limit", undo_limit,
 653               doc: /* Keep no more undo information once it exceeds this size.
 654 This limit is applied when garbage collection happens.
 655 When a previous command increases the total undo list size past this
 656 value, the earlier commands that came before it are forgotten.
 657
 658 The size is counted as the number of bytes occupied,
 659 which includes both saved text and other data.  */);
 660   undo_limit = 80000;
 661
 662   DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
 663               doc: /* Don't keep more than this much size of undo information.
 664 This limit is applied when garbage collection happens.
 665 When a previous command increases the total undo list size past this
 666 value, that command and the earlier commands that came before it are forgotten.
 667 However, the most recent buffer-modifying command's undo info
 668 is never discarded for this reason.
 669
 670 The size is counted as the number of bytes occupied,
 671 which includes both saved text and other data.  */);
 672   undo_strong_limit = 120000;
 673
 674   DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
 675               doc: /* Outer limit on size of undo information for one command.
 676 At garbage collection time, if the current command has produced
 677 more than this much undo information, it discards the info and displays
 678 a warning.  This is a last-ditch limit to prevent memory overflow.
 679
 680 The size is counted as the number of bytes occupied, which includes
 681 both saved text and other data.  A value of nil means no limit.  In
 682 this case, accumulating one huge undo entry could make Emacs crash as
 683 a result of memory overflow.
 684
 685 In fact, this calls the function which is the value of
 686 `undo-outer-limit-function' with one argument, the size.
 687 The text above describes the behavior of the function
 688 that variable usually specifies.  */);
 689   Vundo_outer_limit = make_number (12000000);
 690
 691   DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
 692                doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
 693 This function is called with one argument, the current undo list size
 694 for the most recent command (since the last undo boundary).
 695 If the function returns t, that means truncation has been fully handled.
 696 If it returns nil, the other forms of truncation are done.
 697
 698 Garbage collection is inhibited around the call to this function,
 699 so it must make sure not to do a lot of consing.  */);
 700   Vundo_outer_limit_function = Qnil;
 701
 702   DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
 703                doc: /* Non-nil means do not record `point' in `buffer-undo-list'.  */);
 704   undo_inhibit_record_point = 0;
 705 }