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