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