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
 440 static void user_error (const char*) NO_RETURN;
 441 static void user_error (const char *msg)
 442 {
 443   xsignal1 (Quser_error, build_string (msg));
 444 }
 445
 446 \f
 447 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
 448        doc: /* Undo N records from the front of the list LIST.
 449 Return what remains of the list.  */)
 450   (Lisp_Object n, Lisp_Object list)
 451 {
 452   struct gcpro gcpro1, gcpro2;
 453   Lisp_Object next;
 454   int count = SPECPDL_INDEX ();
 455   register int arg;
 456   Lisp_Object oldlist;
 457   int did_apply = 0;
 458
 459 #if 0  /* This is a good feature, but would make undo-start
 460           unable to do what is expected.  */
 461   Lisp_Object tem;
 462
 463   /* If the head of the list is a boundary, it is the boundary
 464      preceding this command.  Get rid of it and don't count it.  */
 465   tem = Fcar (list);
 466   if (NILP (tem))
 467     list = Fcdr (list);
 468 #endif
 469
 470   CHECK_NUMBER (n);
 471   arg = XINT (n);
 472   next = Qnil;
 473   GCPRO2 (next, list);
 474   /* I don't think we need to gcpro oldlist, as we use it only
 475      to check for EQ.  ++kfs  */
 476
 477   /* In a writable buffer, enable undoing read-only text that is so
 478      because of text properties.  */
 479   if (NILP (BVAR (current_buffer, read_only)))
 480     specbind (Qinhibit_read_only, Qt);
 481
 482   /* Don't let `intangible' properties interfere with undo.  */
 483   specbind (Qinhibit_point_motion_hooks, Qt);
 484
 485   oldlist = BVAR (current_buffer, undo_list);
 486
 487   while (arg > 0)
 488     {
 489       while (CONSP (list))
 490         {
 491           next = XCAR (list);
 492           list = XCDR (list);
 493           /* Exit inner loop at undo boundary.  */
 494           if (NILP (next))
 495             break;
 496           /* Handle an integer by setting point to that value.  */
 497           if (INTEGERP (next))
 498             SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
 499           else if (CONSP (next))
 500             {
 501               Lisp_Object car, cdr;
 502
 503               car = XCAR (next);
 504               cdr = XCDR (next);
 505               if (EQ (car, Qt))
 506                 {
 507                   /* Element (t high . low) records previous modtime.  */
 508                   struct buffer *base_buffer = current_buffer;
 509                   time_t mod_time;
 510                   CONS_TO_INTEGER (cdr, time_t, mod_time);
 511
 512                   if (current_buffer->base_buffer)
 513                     base_buffer = current_buffer->base_buffer;
 514
 515                   /* If this records an obsolete save
 516                      (not matching the actual disk file)
 517                      then don't mark unmodified.  */
 518                   if (mod_time != base_buffer->modtime)
 519                     continue;
 520 #ifdef CLASH_DETECTION
 521                   Funlock_buffer ();
 522 #endif /* CLASH_DETECTION */
 523                   Fset_buffer_modified_p (Qnil);
 524                 }
 525               else if (EQ (car, Qnil))
 526                 {
 527                   /* Element (nil PROP VAL BEG . END) is property change.  */
 528                   Lisp_Object beg, end, prop, val;
 529
 530                   prop = Fcar (cdr);
 531                   cdr = Fcdr (cdr);
 532                   val = Fcar (cdr);
 533                   cdr = Fcdr (cdr);
 534                   beg = Fcar (cdr);
 535                   end = Fcdr (cdr);
 536
 537                   if (XINT (beg) < BEGV || XINT (end) > ZV)
 538                     user_error ("Changes to be undone are outside visible portion of buffer");
 539                   Fput_text_property (beg, end, prop, val, Qnil);
 540                 }
 541               else if (INTEGERP (car) && INTEGERP (cdr))
 542                 {
 543                   /* Element (BEG . END) means range was inserted.  */
 544
 545                   if (XINT (car) < BEGV
 546                       || XINT (cdr) > ZV)
 547                     user_error ("Changes to be undone are outside visible portion of buffer");
 548                   /* Set point first thing, so that undoing this undo
 549                      does not send point back to where it is now.  */
 550                   Fgoto_char (car);
 551                   Fdelete_region (car, cdr);
 552                 }
 553               else if (EQ (car, Qapply))
 554                 {
 555                   /* Element (apply FUN . ARGS) means call FUN to undo.  */
 556                   struct buffer *save_buffer = current_buffer;
 557
 558                   car = Fcar (cdr);
 559                   cdr = Fcdr (cdr);
 560                   if (INTEGERP (car))
 561                     {
 562                       /* Long format: (apply DELTA START END FUN . ARGS).  */
 563                       Lisp_Object delta = car;
 564                       Lisp_Object start = Fcar (cdr);
 565                       Lisp_Object end   = Fcar (Fcdr (cdr));
 566                       Lisp_Object start_mark = Fcopy_marker (start, Qnil);
 567                       Lisp_Object end_mark   = Fcopy_marker (end, Qt);
 568
 569                       cdr = Fcdr (Fcdr (cdr));
 570                       apply1 (Fcar (cdr), Fcdr (cdr));
 571
 572                       /* Check that the function did what the entry said it
 573                          would do.  */
 574                       if (!EQ (start, Fmarker_position (start_mark))
 575                           || (XINT (delta) + XINT (end)
 576                               != marker_position (end_mark)))
 577                         error ("Changes to be undone by function different than announced");
 578                       Fset_marker (start_mark, Qnil, Qnil);
 579                       Fset_marker (end_mark, Qnil, Qnil);
 580                     }
 581                   else
 582                     apply1 (car, cdr);
 583
 584                   if (save_buffer != current_buffer)
 585                     error ("Undo function switched buffer");
 586                   did_apply = 1;
 587                 }
 588               else if (STRINGP (car) && INTEGERP (cdr))
 589                 {
 590                   /* Element (STRING . POS) means STRING was deleted.  */
 591                   Lisp_Object membuf;
 592                   EMACS_INT pos = XINT (cdr);
 593
 594                   membuf = car;
 595                   if (pos < 0)
 596                     {
 597                       if (-pos < BEGV || -pos > ZV)
 598                         user_error ("Changes to be undone are outside visible portion of buffer");
 599                       SET_PT (-pos);
 600                       Finsert (1, &membuf);
 601                     }
 602                   else
 603                     {
 604                       if (pos < BEGV || pos > ZV)
 605                         user_error ("Changes to be undone are outside visible portion of buffer");
 606                       SET_PT (pos);
 607
 608                       /* Now that we record marker adjustments
 609                          (caused by deletion) for undo,
 610                          we should always insert after markers,
 611                          so that undoing the marker adjustments
 612                          put the markers back in the right place.  */
 613                       Finsert (1, &membuf);
 614                       SET_PT (pos);
 615                     }
 616                 }
 617               else if (MARKERP (car) && INTEGERP (cdr))
 618                 {
 619                   /* (MARKER . INTEGER) means a marker MARKER
 620                      was adjusted by INTEGER.  */
 621                   if (XMARKER (car)->buffer)
 622                     Fset_marker (car,
 623                                  make_number (marker_position (car) - XINT (cdr)),
 624                                  Fmarker_buffer (car));
 625                 }
 626             }
 627         }
 628       arg--;
 629     }
 630
 631
 632   /* Make sure an apply entry produces at least one undo entry,
 633      so the test in `undo' for continuing an undo series
 634      will work right.  */
 635   if (did_apply
 636       && EQ (oldlist, BVAR (current_buffer, undo_list)))
 637     BVAR (current_buffer, undo_list)
 638       = Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list));
 639
 640   UNGCPRO;
 641   return unbind_to (count, list);
 642 }
 643 \f
 644 void
 645 syms_of_undo (void)
 646 {
 647   DEFSYM (Qinhibit_read_only, "inhibit-read-only");
 648   DEFSYM (Qapply, "apply");
 649
 650   pending_boundary = Qnil;
 651   staticpro (&pending_boundary);
 652
 653   last_undo_buffer = NULL;
 654   last_boundary_buffer = NULL;
 655
 656   defsubr (&Sprimitive_undo);
 657   defsubr (&Sundo_boundary);
 658
 659   DEFVAR_INT ("undo-limit", undo_limit,
 660               doc: /* Keep no more undo information once it exceeds this size.
 661 This limit is applied when garbage collection happens.
 662 When a previous command increases the total undo list size past this
 663 value, the earlier commands that came before it are forgotten.
 664
 665 The size is counted as the number of bytes occupied,
 666 which includes both saved text and other data.  */);
 667   undo_limit = 80000;
 668
 669   DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
 670               doc: /* Don't keep more than this much size of undo information.
 671 This limit is applied when garbage collection happens.
 672 When a previous command increases the total undo list size past this
 673 value, that command and the earlier commands that came before it are forgotten.
 674 However, the most recent buffer-modifying command's undo info
 675 is never discarded for this reason.
 676
 677 The size is counted as the number of bytes occupied,
 678 which includes both saved text and other data.  */);
 679   undo_strong_limit = 120000;
 680
 681   DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
 682               doc: /* Outer limit on size of undo information for one command.
 683 At garbage collection time, if the current command has produced
 684 more than this much undo information, it discards the info and displays
 685 a warning.  This is a last-ditch limit to prevent memory overflow.
 686
 687 The size is counted as the number of bytes occupied, which includes
 688 both saved text and other data.  A value of nil means no limit.  In
 689 this case, accumulating one huge undo entry could make Emacs crash as
 690 a result of memory overflow.
 691
 692 In fact, this calls the function which is the value of
 693 `undo-outer-limit-function' with one argument, the size.
 694 The text above describes the behavior of the function
 695 that variable usually specifies.  */);
 696   Vundo_outer_limit = make_number (12000000);
 697
 698   DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
 699                doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
 700 This function is called with one argument, the current undo list size
 701 for the most recent command (since the last undo boundary).
 702 If the function returns t, that means truncation has been fully handled.
 703 If it returns nil, the other forms of truncation are done.
 704
 705 Garbage collection is inhibited around the call to this function,
 706 so it must make sure not to do a lot of consing.  */);
 707   Vundo_outer_limit_function = Qnil;
 708
 709   DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
 710                doc: /* Non-nil means do not record `point' in `buffer-undo-list'.  */);
 711   undo_inhibit_record_point = 0;
 712 }