src/undo.c

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