src/undo.c

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