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 (EMACS_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 (EMACS_INT beg, EMACS_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 (EMACS_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, EMACS_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 (EMACS_INT beg, EMACS_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 (EMACS_INT beg, EMACS_INT length,
 254                         Lisp_Object prop, Lisp_Object value,
 255                         Lisp_Object 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   (void)
 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 (struct buffer *b)
 325 {
 326   Lisp_Object list;
 327   Lisp_Object prev, next, last_boundary;
 328   int size_so_far = 0;
 329
 330   /* Make sure that calling undo-outer-limit-function
 331      won't cause another GC.  */
 332   int count = inhibit_garbage_collection ();
 333
 334   /* Make the buffer current to get its local values of variables such
 335      as undo_limit.  Also so that Vundo_outer_limit_function can
 336      tell which buffer to operate on.  */
 337   record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
 338   set_buffer_internal (b);
 339
 340   list = b->undo_list;
 341
 342   prev = Qnil;
 343   next = list;
 344   last_boundary = Qnil;
 345
 346   /* If the first element is an undo boundary, skip past it.  */
 347   if (CONSP (next) && NILP (XCAR (next)))
 348     {
 349       /* Add in the space occupied by this element and its chain link.  */
 350       size_so_far += sizeof (struct Lisp_Cons);
 351
 352       /* Advance to next element.  */
 353       prev = next;
 354       next = XCDR (next);
 355     }
 356
 357   /* Always preserve at least the most recent undo record
 358      unless it is really horribly big.
 359
 360      Skip, skip, skip the undo, skip, skip, skip the undo,
 361      Skip, skip, skip the undo, skip to the undo bound'ry.  */
 362
 363   while (CONSP (next) && ! NILP (XCAR (next)))
 364     {
 365       Lisp_Object elt;
 366       elt = XCAR (next);
 367
 368       /* Add in the space occupied by this element and its chain link.  */
 369       size_so_far += sizeof (struct Lisp_Cons);
 370       if (CONSP (elt))
 371         {
 372           size_so_far += sizeof (struct Lisp_Cons);
 373           if (STRINGP (XCAR (elt)))
 374             size_so_far += (sizeof (struct Lisp_String) - 1
 375                             + SCHARS (XCAR (elt)));
 376         }
 377
 378       /* Advance to next element.  */
 379       prev = next;
 380       next = XCDR (next);
 381     }
 382
 383   /* If by the first boundary we have already passed undo_outer_limit,
 384      we're heading for memory full, so offer to clear out the list.  */
 385   if (INTEGERP (Vundo_outer_limit)
 386       && size_so_far > XINT (Vundo_outer_limit)
 387       && !NILP (Vundo_outer_limit_function))
 388     {
 389       Lisp_Object tem;
 390       struct buffer *temp = last_undo_buffer;
 391
 392       /* Normally the function this calls is undo-outer-limit-truncate.  */
 393       tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
 394       if (! NILP (tem))
 395         {
 396           /* The function is responsible for making
 397              any desired changes in buffer-undo-list.  */
 398           unbind_to (count, Qnil);
 399           return;
 400         }
 401       /* That function probably used the minibuffer, and if so, that
 402          changed last_undo_buffer.  Change it back so that we don't
 403          force next change to make an undo boundary here.  */
 404       last_undo_buffer = temp;
 405     }
 406
 407   if (CONSP (next))
 408     last_boundary = prev;
 409
 410   /* Keep additional undo data, if it fits in the limits.  */
 411   while (CONSP (next))
 412     {
 413       Lisp_Object elt;
 414       elt = XCAR (next);
 415
 416       /* When we get to a boundary, decide whether to truncate
 417          either before or after it.  The lower threshold, undo_limit,
 418          tells us to truncate after it.  If its size pushes past
 419          the higher threshold undo_strong_limit, we truncate before it.  */
 420       if (NILP (elt))
 421         {
 422           if (size_so_far > undo_strong_limit)
 423             break;
 424           last_boundary = prev;
 425           if (size_so_far > undo_limit)
 426             break;
 427         }
 428
 429       /* Add in the space occupied by this element and its chain link.  */
 430       size_so_far += sizeof (struct Lisp_Cons);
 431       if (CONSP (elt))
 432         {
 433           size_so_far += sizeof (struct Lisp_Cons);
 434           if (STRINGP (XCAR (elt)))
 435             size_so_far += (sizeof (struct Lisp_String) - 1
 436                             + SCHARS (XCAR (elt)));
 437         }
 438
 439       /* Advance to next element.  */
 440       prev = next;
 441       next = XCDR (next);
 442     }
 443
 444   /* If we scanned the whole list, it is short enough; don't change it.  */
 445   if (NILP (next))
 446     ;
 447   /* Truncate at the boundary where we decided to truncate.  */
 448   else if (!NILP (last_boundary))
 449     XSETCDR (last_boundary, Qnil);
 450   /* There's nothing we decided to keep, so clear it out.  */
 451   else
 452     b->undo_list = Qnil;
 453
 454   unbind_to (count, Qnil);
 455 }
 456 \f
 457 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
 458        doc: /* Undo N records from the front of the list LIST.
 459 Return what remains of the list.  */)
 460   (Lisp_Object n, Lisp_Object list)
 461 {
 462   struct gcpro gcpro1, gcpro2;
 463   Lisp_Object next;
 464   int count = SPECPDL_INDEX ();
 465   register int arg;
 466   Lisp_Object oldlist;
 467   int did_apply = 0;
 468
 469 #if 0  /* This is a good feature, but would make undo-start
 470           unable to do what is expected.  */
 471   Lisp_Object tem;
 472
 473   /* If the head of the list is a boundary, it is the boundary
 474      preceding this command.  Get rid of it and don't count it.  */
 475   tem = Fcar (list);
 476   if (NILP (tem))
 477     list = Fcdr (list);
 478 #endif
 479
 480   CHECK_NUMBER (n);
 481   arg = XINT (n);
 482   next = Qnil;
 483   GCPRO2 (next, list);
 484   /* I don't think we need to gcpro oldlist, as we use it only
 485      to check for EQ.  ++kfs  */
 486
 487   /* In a writable buffer, enable undoing read-only text that is so
 488      because of text properties.  */
 489   if (NILP (current_buffer->read_only))
 490     specbind (Qinhibit_read_only, Qt);
 491
 492   /* Don't let `intangible' properties interfere with undo.  */
 493   specbind (Qinhibit_point_motion_hooks, Qt);
 494
 495   oldlist = current_buffer->undo_list;
 496
 497   while (arg > 0)
 498     {
 499       while (CONSP (list))
 500         {
 501           next = XCAR (list);
 502           list = XCDR (list);
 503           /* Exit inner loop at undo boundary.  */
 504           if (NILP (next))
 505             break;
 506           /* Handle an integer by setting point to that value.  */
 507           if (INTEGERP (next))
 508             SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
 509           else if (CONSP (next))
 510             {
 511               Lisp_Object car, cdr;
 512
 513               car = XCAR (next);
 514               cdr = XCDR (next);
 515               if (EQ (car, Qt))
 516                 {
 517                   /* Element (t high . low) records previous modtime.  */
 518                   Lisp_Object high, low;
 519                   int mod_time;
 520                   struct buffer *base_buffer = current_buffer;
 521
 522                   high = Fcar (cdr);
 523                   low = Fcdr (cdr);
 524                   mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
 525
 526                   if (current_buffer->base_buffer)
 527                     base_buffer = current_buffer->base_buffer;
 528
 529                   /* If this records an obsolete save
 530                      (not matching the actual disk file)
 531                      then don't mark unmodified.  */
 532                   if (mod_time != base_buffer->modtime)
 533                     continue;
 534 #ifdef CLASH_DETECTION
 535                   Funlock_buffer ();
 536 #endif /* CLASH_DETECTION */
 537                   Fset_buffer_modified_p (Qnil);
 538                 }
 539               else if (EQ (car, Qnil))
 540                 {
 541                   /* Element (nil PROP VAL BEG . END) is property change.  */
 542                   Lisp_Object beg, end, prop, val;
 543
 544                   prop = Fcar (cdr);
 545                   cdr = Fcdr (cdr);
 546                   val = Fcar (cdr);
 547                   cdr = Fcdr (cdr);
 548                   beg = Fcar (cdr);
 549                   end = Fcdr (cdr);
 550
 551                   if (XINT (beg) < BEGV || XINT (end) > ZV)
 552                     error ("Changes to be undone are outside visible portion of buffer");
 553                   Fput_text_property (beg, end, prop, val, Qnil);
 554                 }
 555               else if (INTEGERP (car) && INTEGERP (cdr))
 556                 {
 557                   /* Element (BEG . END) means range was inserted.  */
 558
 559                   if (XINT (car) < BEGV
 560                       || XINT (cdr) > ZV)
 561                     error ("Changes to be undone are outside visible portion of buffer");
 562                   /* Set point first thing, so that undoing this undo
 563                      does not send point back to where it is now.  */
 564                   Fgoto_char (car);
 565                   Fdelete_region (car, cdr);
 566                 }
 567               else if (EQ (car, Qapply))
 568                 {
 569                   /* Element (apply FUN . ARGS) means call FUN to undo.  */
 570                   struct buffer *save_buffer = current_buffer;
 571
 572                   car = Fcar (cdr);
 573                   cdr = Fcdr (cdr);
 574                   if (INTEGERP (car))
 575                     {
 576                       /* Long format: (apply DELTA START END FUN . ARGS).  */
 577                       Lisp_Object delta = car;
 578                       Lisp_Object start = Fcar (cdr);
 579                       Lisp_Object end   = Fcar (Fcdr (cdr));
 580                       Lisp_Object start_mark = Fcopy_marker (start, Qnil);
 581                       Lisp_Object end_mark   = Fcopy_marker (end, Qt);
 582
 583                       cdr = Fcdr (Fcdr (cdr));
 584                       apply1 (Fcar (cdr), Fcdr (cdr));
 585
 586                       /* Check that the function did what the entry said it
 587                          would do.  */
 588                       if (!EQ (start, Fmarker_position (start_mark))
 589                           || (XINT (delta) + XINT (end)
 590                               != marker_position (end_mark)))
 591                         error ("Changes to be undone by function different than announced");
 592                       Fset_marker (start_mark, Qnil, Qnil);
 593                       Fset_marker (end_mark, Qnil, Qnil);
 594                     }
 595                   else
 596                     apply1 (car, cdr);
 597
 598                   if (save_buffer != current_buffer)
 599                     error ("Undo function switched buffer");
 600                   did_apply = 1;
 601                 }
 602               else if (STRINGP (car) && INTEGERP (cdr))
 603                 {
 604                   /* Element (STRING . POS) means STRING was deleted.  */
 605                   Lisp_Object membuf;
 606                   EMACS_INT pos = XINT (cdr);
 607
 608                   membuf = car;
 609                   if (pos < 0)
 610                     {
 611                       if (-pos < BEGV || -pos > ZV)
 612                         error ("Changes to be undone are outside visible portion of buffer");
 613                       SET_PT (-pos);
 614                       Finsert (1, &membuf);
 615                     }
 616                   else
 617                     {
 618                       if (pos < BEGV || pos > ZV)
 619                         error ("Changes to be undone are outside visible portion of buffer");
 620                       SET_PT (pos);
 621
 622                       /* Now that we record marker adjustments
 623                          (caused by deletion) for undo,
 624                          we should always insert after markers,
 625                          so that undoing the marker adjustments
 626                          put the markers back in the right place.  */
 627                       Finsert (1, &membuf);
 628                       SET_PT (pos);
 629                     }
 630                 }
 631               else if (MARKERP (car) && INTEGERP (cdr))
 632                 {
 633                   /* (MARKER . INTEGER) means a marker MARKER
 634                      was adjusted by INTEGER.  */
 635                   if (XMARKER (car)->buffer)
 636                     Fset_marker (car,
 637                                  make_number (marker_position (car) - XINT (cdr)),
 638                                  Fmarker_buffer (car));
 639                 }
 640             }
 641         }
 642       arg--;
 643     }
 644
 645
 646   /* Make sure an apply entry produces at least one undo entry,
 647      so the test in `undo' for continuing an undo series
 648      will work right.  */
 649   if (did_apply
 650       && EQ (oldlist, current_buffer->undo_list))
 651     current_buffer->undo_list
 652       = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
 653
 654   UNGCPRO;
 655   return unbind_to (count, list);
 656 }
 657 \f
 658 void
 659 syms_of_undo (void)
 660 {
 661   Qinhibit_read_only = intern_c_string ("inhibit-read-only");
 662   staticpro (&Qinhibit_read_only);
 663
 664   Qapply = intern_c_string ("apply");
 665   staticpro (&Qapply);
 666
 667   pending_boundary = Qnil;
 668   staticpro (&pending_boundary);
 669
 670   last_undo_buffer = NULL;
 671   last_boundary_buffer = NULL;
 672
 673   defsubr (&Sprimitive_undo);
 674   defsubr (&Sundo_boundary);
 675
 676   DEFVAR_INT ("undo-limit", &undo_limit,
 677               doc: /* Keep no more undo information once it exceeds this size.
 678 This limit is applied when garbage collection happens.
 679 When a previous command increases the total undo list size past this
 680 value, the earlier commands that came before it are forgotten.
 681
 682 The size is counted as the number of bytes occupied,
 683 which includes both saved text and other data.  */);
 684   undo_limit = 80000;
 685
 686   DEFVAR_INT ("undo-strong-limit", &undo_strong_limit,
 687               doc: /* Don't keep more than this much size of undo information.
 688 This limit is applied when garbage collection happens.
 689 When a previous command increases the total undo list size past this
 690 value, that command and the earlier commands that came before it are forgotten.
 691 However, the most recent buffer-modifying command's undo info
 692 is never discarded for this reason.
 693
 694 The size is counted as the number of bytes occupied,
 695 which includes both saved text and other data.  */);
 696   undo_strong_limit = 120000;
 697
 698   DEFVAR_LISP ("undo-outer-limit", &Vundo_outer_limit,
 699               doc: /* Outer limit on size of undo information for one command.
 700 At garbage collection time, if the current command has produced
 701 more than this much undo information, it discards the info and displays
 702 a warning.  This is a last-ditch limit to prevent memory overflow.
 703
 704 The size is counted as the number of bytes occupied, which includes
 705 both saved text and other data.  A value of nil means no limit.  In
 706 this case, accumulating one huge undo entry could make Emacs crash as
 707 a result of memory overflow.
 708
 709 In fact, this calls the function which is the value of
 710 `undo-outer-limit-function' with one argument, the size.
 711 The text above describes the behavior of the function
 712 that variable usually specifies.  */);
 713   Vundo_outer_limit = make_number (12000000);
 714
 715   DEFVAR_LISP ("undo-outer-limit-function", &Vundo_outer_limit_function,
 716                doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
 717 This function is called with one argument, the current undo list size
 718 for the most recent command (since the last undo boundary).
 719 If the function returns t, that means truncation has been fully handled.
 720 If it returns nil, the other forms of truncation are done.
 721
 722 Garbage collection is inhibited around the call to this function,
 723 so it must make sure not to do a lot of consing.  */);
 724   Vundo_outer_limit_function = Qnil;
 725
 726   DEFVAR_BOOL ("undo-inhibit-record-point", &undo_inhibit_record_point,
 727                doc: /* Non-nil means do not record `point' in `buffer-undo-list'.  */);
 728   undo_inhibit_record_point = 0;
 729 }
 730
 731 /* arch-tag: d546ee01-4aed-4ffb-bb8b-eefaae50d38a
 732    (do not change this comment) */