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, make_lisp_time (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 _Noreturn void
 442 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 . TIME) records previous modtime.
 509                      Preserve any flag of NONEXISTENT_MODTIME_NSECS or
 510                      UNKNOWN_MODTIME_NSECS.  */
 511                   struct buffer *base_buffer = current_buffer;
 512                   EMACS_TIME mod_time;
 513
 514                   if (CONSP (cdr)
 515                       && CONSP (XCDR (cdr))
 516                       && CONSP (XCDR (XCDR (cdr)))
 517                       && CONSP (XCDR (XCDR (XCDR (cdr))))
 518                       && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr)))))
 519                       && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0)
 520                     mod_time =
 521                       (make_emacs_time
 522                        (0, XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000));
 523                   else
 524                     mod_time = lisp_time_argument (cdr);
 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 (EMACS_TIME_NE (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                     user_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                     user_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                         user_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                         user_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, BVAR (current_buffer, undo_list)))
 651     BVAR (current_buffer, undo_list)
 652       = Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (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   DEFSYM (Qinhibit_read_only, "inhibit-read-only");
 662   DEFSYM (Qapply, "apply");
 663
 664   pending_boundary = Qnil;
 665   staticpro (&pending_boundary);
 666
 667   last_undo_buffer = NULL;
 668   last_boundary_buffer = NULL;
 669
 670   defsubr (&Sprimitive_undo);
 671   defsubr (&Sundo_boundary);
 672
 673   DEFVAR_INT ("undo-limit", undo_limit,
 674               doc: /* Keep no more undo information once it exceeds this size.
 675 This limit is applied when garbage collection happens.
 676 When a previous command increases the total undo list size past this
 677 value, the earlier commands that came before it are forgotten.
 678
 679 The size is counted as the number of bytes occupied,
 680 which includes both saved text and other data.  */);
 681   undo_limit = 80000;
 682
 683   DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
 684               doc: /* Don't keep more than this much size of undo information.
 685 This limit is applied when garbage collection happens.
 686 When a previous command increases the total undo list size past this
 687 value, that command and the earlier commands that came before it are forgotten.
 688 However, the most recent buffer-modifying command's undo info
 689 is never discarded for this reason.
 690
 691 The size is counted as the number of bytes occupied,
 692 which includes both saved text and other data.  */);
 693   undo_strong_limit = 120000;
 694
 695   DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
 696               doc: /* Outer limit on size of undo information for one command.
 697 At garbage collection time, if the current command has produced
 698 more than this much undo information, it discards the info and displays
 699 a warning.  This is a last-ditch limit to prevent memory overflow.
 700
 701 The size is counted as the number of bytes occupied, which includes
 702 both saved text and other data.  A value of nil means no limit.  In
 703 this case, accumulating one huge undo entry could make Emacs crash as
 704 a result of memory overflow.
 705
 706 In fact, this calls the function which is the value of
 707 `undo-outer-limit-function' with one argument, the size.
 708 The text above describes the behavior of the function
 709 that variable usually specifies.  */);
 710   Vundo_outer_limit = make_number (12000000);
 711
 712   DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
 713                doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
 714 This function is called with one argument, the current undo list size
 715 for the most recent command (since the last undo boundary).
 716 If the function returns t, that means truncation has been fully handled.
 717 If it returns nil, the other forms of truncation are done.
 718
 719 Garbage collection is inhibited around the call to this function,
 720 so it must make sure not to do a lot of consing.  */);
 721   Vundo_outer_limit_function = Qnil;
 722
 723   DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
 724                doc: /* Non-nil means do not record `point' in `buffer-undo-list'.  */);
 725   undo_inhibit_record_point = 0;
 726 }