src/undo.c

   1 /* undo handling for GNU Emacs.
   2    Copyright (C) 1990, 1993-1994, 2000-2011  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 struct buffer *last_undo_buffer;
  30
  31 /* Position of point last time we inserted a boundary.  */
  32 struct buffer *last_boundary_buffer;
  33 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 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 (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       && 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);
 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 (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 (current_buffer->undo_list))
 128     {
 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)
 135         {
 136           XSETCDR (elt, make_number (beg + length));
 137           return;
 138         }
 139     }
 140
 141   XSETFASTINT (lbeg, beg);
 142   XSETINT (lend, beg + length);
 143   current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
 144                                      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 (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   current_buffer->undo_list
 170     = Fcons (Fcons (string, sbeg), 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 (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   current_buffer->undo_list
 193     = Fcons (Fcons (marker, make_number (adjustment)),
 194              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   Lisp_Object high, low;
 216   struct buffer *base_buffer = current_buffer;
 217
 218   if (EQ (current_buffer->undo_list, Qt))
 219     return;
 220
 221   if (current_buffer != last_undo_buffer)
 222     Fundo_boundary ();
 223   last_undo_buffer = current_buffer;
 224
 225   if (base_buffer->base_buffer)
 226     base_buffer = base_buffer->base_buffer;
 227
 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);
 231 }
 232
 233 /* Record a change in property PROP (whose old value was VAL)
 234    for LENGTH characters starting at position BEG in BUFFER.  */
 235
 236 void
 237 record_property_change (EMACS_INT beg, EMACS_INT length,
 238                         Lisp_Object prop, Lisp_Object value,
 239                         Lisp_Object buffer)
 240 {
 241   Lisp_Object lbeg, lend, entry;
 242   struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
 243   int boundary = 0;
 244
 245   if (EQ (buf->undo_list, Qt))
 246     return;
 247
 248   /* Allocate a cons cell to be the undo boundary after this command.  */
 249   if (NILP (pending_boundary))
 250     pending_boundary = Fcons (Qnil, Qnil);
 251
 252   if (buf != last_undo_buffer)
 253     boundary = 1;
 254   last_undo_buffer = buf;
 255
 256   /* Switch temporarily to the buffer that was changed.  */
 257   current_buffer = buf;
 258
 259   if (boundary)
 260     Fundo_boundary ();
 261
 262   if (MODIFF <= SAVE_MODIFF)
 263     record_first_change ();
 264
 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);
 269
 270   current_buffer = obuf;
 271 }
 272
 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)
 278 {
 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))
 284     {
 285       /* One way or another, cons nil onto the front of the undo list.  */
 286       if (!NILP (pending_boundary))
 287         {
 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;
 293         }
 294       else
 295         current_buffer->undo_list = Fcons (Qnil, current_buffer->undo_list);
 296     }
 297   last_boundary_position = PT;
 298   last_boundary_buffer = current_buffer;
 299   return Qnil;
 300 }
 301
 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.  */
 306
 307 void
 308 truncate_undo_list (struct buffer *b)
 309 {
 310   Lisp_Object list;
 311   Lisp_Object prev, next, last_boundary;
 312   int size_so_far = 0;
 313
 314   /* Make sure that calling undo-outer-limit-function
 315      won't cause another GC.  */
 316   int count = inhibit_garbage_collection ();
 317
 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);
 323
 324   list = b->undo_list;
 325
 326   prev = Qnil;
 327   next = list;
 328   last_boundary = Qnil;
 329
 330   /* If the first element is an undo boundary, skip past it.  */
 331   if (CONSP (next) && NILP (XCAR (next)))
 332     {
 333       /* Add in the space occupied by this element and its chain link.  */
 334       size_so_far += sizeof (struct Lisp_Cons);
 335
 336       /* Advance to next element.  */
 337       prev = next;
 338       next = XCDR (next);
 339     }
 340
 341   /* Always preserve at least the most recent undo record
 342      unless it is really horribly big.
 343
 344      Skip, skip, skip the undo, skip, skip, skip the undo,
 345      Skip, skip, skip the undo, skip to the undo bound'ry.  */
 346
 347   while (CONSP (next) && ! NILP (XCAR (next)))
 348     {
 349       Lisp_Object elt;
 350       elt = XCAR (next);
 351
 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))
 355         {
 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)));
 360         }
 361
 362       /* Advance to next element.  */
 363       prev = next;
 364       next = XCDR (next);
 365     }
 366
 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))
 372     {
 373       Lisp_Object tem;
 374       struct buffer *temp = last_undo_buffer;
 375
 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))
 379         {
 380           /* The function is responsible for making
 381              any desired changes in buffer-undo-list.  */
 382           unbind_to (count, Qnil);
 383           return;
 384         }
 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;
 389     }
 390
 391   if (CONSP (next))
 392     last_boundary = prev;
 393
 394   /* Keep additional undo data, if it fits in the limits.  */
 395   while (CONSP (next))
 396     {
 397       Lisp_Object elt;
 398       elt = XCAR (next);
 399
 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))
 405         {
 406           if (size_so_far > undo_strong_limit)
 407             break;
 408           last_boundary = prev;
 409           if (size_so_far > undo_limit)
 410             break;
 411         }
 412
 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))
 416         {
 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)));
 421         }
 422
 423       /* Advance to next element.  */
 424       prev = next;
 425       next = XCDR (next);
 426     }
 427
 428   /* If we scanned the whole list, it is short enough; don't change it.  */
 429   if (NILP (next))
 430     ;
 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;
 437
 438   unbind_to (count, Qnil);
 439 }
 440 \f
 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)
 445 {
 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;
 452
 453 #if 0  /* This is a good feature, but would make undo-start
 454           unable to do what is expected.  */
 455   Lisp_Object tem;
 456
 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
 463
 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  */
 470
 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);
 475
 476   /* Don't let `intangible' properties interfere with undo.  */
 477   specbind (Qinhibit_point_motion_hooks, Qt);
 478
 479   oldlist = current_buffer->undo_list;
 480
 481   while (arg > 0)
 482     {
 483       while (CONSP (list))
 484         {
 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))
 494             {
 495               Lisp_Object car, cdr;
 496
 497               car = XCAR (next);
 498               cdr = XCDR (next);
 499               if (EQ (car, Qt))
 500                 {
 501                   /* Element (t high . low) records previous modtime.  */
 502                   Lisp_Object high, low;
 503                   int mod_time;
 504                   struct buffer *base_buffer = current_buffer;
 505
 506                   high = Fcar (cdr);
 507                   low = Fcdr (cdr);
 508                   mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
 509
 510                   if (current_buffer->base_buffer)
 511                     base_buffer = current_buffer->base_buffer;
 512
 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);
 522                 }
 523               else if (EQ (car, Qnil))
 524                 {
 525                   /* Element (nil PROP VAL BEG . END) is property change.  */
 526                   Lisp_Object beg, end, prop, val;
 527
 528                   prop = Fcar (cdr);
 529                   cdr = Fcdr (cdr);
 530                   val = Fcar (cdr);
 531                   cdr = Fcdr (cdr);
 532                   beg = Fcar (cdr);
 533                   end = Fcdr (cdr);
 534
 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);
 538                 }
 539               else if (INTEGERP (car) && INTEGERP (cdr))
 540                 {
 541                   /* Element (BEG . END) means range was inserted.  */
 542
 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);
 550                 }
 551               else if (EQ (car, Qapply))
 552                 {
 553                   /* Element (apply FUN . ARGS) means call FUN to undo.  */
 554                   struct buffer *save_buffer = current_buffer;
 555
 556                   car = Fcar (cdr);
 557                   cdr = Fcdr (cdr);
 558                   if (INTEGERP (car))
 559                     {
 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);
 566
 567                       cdr = Fcdr (Fcdr (cdr));
 568                       apply1 (Fcar (cdr), Fcdr (cdr));
 569
 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);
 578                     }
 579                   else
 580                     apply1 (car, cdr);
 581
 582                   if (save_buffer != current_buffer)
 583                     error ("Undo function switched buffer");
 584                   did_apply = 1;
 585                 }
 586               else if (STRINGP (car) && INTEGERP (cdr))
 587                 {
 588                   /* Element (STRING . POS) means STRING was deleted.  */
 589                   Lisp_Object membuf;
 590                   EMACS_INT pos = XINT (cdr);
 591
 592                   membuf = car;
 593                   if (pos < 0)
 594                     {
 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);
 599                     }
 600                   else
 601                     {
 602                       if (pos < BEGV || pos > ZV)
 603                         error ("Changes to be undone are outside visible portion of buffer");
 604                       SET_PT (pos);
 605
 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);
 613                     }
 614                 }
 615               else if (MARKERP (car) && INTEGERP (cdr))
 616                 {
 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));
 623                 }
 624             }
 625         }
 626       arg--;
 627     }
 628
 629
 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);
 637
 638   UNGCPRO;
 639   return unbind_to (count, list);
 640 }
 641 \f
 642 void
 643 syms_of_undo (void)
 644 {
 645   Qinhibit_read_only = intern_c_string ("inhibit-read-only");
 646   staticpro (&Qinhibit_read_only);
 647
 648   Qapply = intern_c_string ("apply");
 649   staticpro (&Qapply);
 650
 651   pending_boundary = Qnil;
 652   staticpro (&pending_boundary);
 653
 654   last_undo_buffer = NULL;
 655   last_boundary_buffer = NULL;
 656
 657   defsubr (&Sprimitive_undo);
 658   defsubr (&Sundo_boundary);
 659
 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.
 665
 666 The size is counted as the number of bytes occupied,
 667 which includes both saved text and other data.  */);
 668   undo_limit = 80000;
 669
 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.
 677
 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;
 681
 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.
 687
 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.
 692
 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);
 698
 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.
 705
 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;
 709
 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;
 713 }
 714