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