/* undo handling for GNU Emacs.
- Copyright (C) 1990, 1993, 1994, 2000, 2001, 2002, 2003, 2004,
- 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1993-1994, 2000-2011 Free Software Foundation, Inc.
This file is part of GNU Emacs.
-GNU Emacs is free software; you can redistribute it and/or modify
+GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 3, or (at your option)
-any later version.
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA. */
+along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
+#include <setjmp.h>
#include "lisp.h"
#include "buffer.h"
#include "commands.h"
#include "window.h"
-/* Limits controlling how much undo information to keep. */
-
-EMACS_INT undo_limit;
-EMACS_INT undo_strong_limit;
-
-Lisp_Object Vundo_outer_limit;
-
-/* Function to call when undo_outer_limit is exceeded. */
-
-Lisp_Object Vundo_outer_limit_function;
-
/* Last buffer for which undo information was recorded. */
-Lisp_Object last_undo_buffer;
+/* BEWARE: This is not traced by the GC, so never dereference it! */
+struct buffer *last_undo_buffer;
+
+/* Position of point last time we inserted a boundary. */
+struct buffer *last_boundary_buffer;
+EMACS_INT last_boundary_position;
Lisp_Object Qinhibit_read_only;
an undo-boundary. */
Lisp_Object pending_boundary;
-/* Nonzero means do not record point in record_point. */
-
-int undo_inhibit_record_point;
-
/* Record point as it was at beginning of this command (if necessary)
and prepare the undo info for recording a change.
PT is the position of point that will naturally occur as a result of the
undo record that will be added just after this command terminates. */
static void
-record_point (pt)
- int pt;
+record_point (EMACS_INT pt)
{
int at_boundary;
- /* Don't record position of pt when undo_inhibit_record_point holds.
- Needed to avoid inserting a position record in buffer-undo-list
- when last_point_position has not been set up correctly by
- command_loop_1, for example, when running a repeat-repeat-char
- event. */
+ /* Don't record position of pt when undo_inhibit_record_point holds. */
if (undo_inhibit_record_point)
return;
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
- if (!BUFFERP (last_undo_buffer)
- || current_buffer != XBUFFER (last_undo_buffer))
+ if ((current_buffer != last_undo_buffer)
+ /* Don't call Fundo_boundary for the first change. Otherwise we
+ risk overwriting last_boundary_position in Fundo_boundary with
+ PT of the current buffer and as a consequence not insert an
+ undo boundary because last_boundary_position will equal pt in
+ the test at the end of the present function (Bug#731). */
+ && (MODIFF > SAVE_MODIFF))
Fundo_boundary ();
- XSETBUFFER (last_undo_buffer, current_buffer);
+ last_undo_buffer = current_buffer;
- if (CONSP (current_buffer->undo_list))
+ if (CONSP (BVAR (current_buffer, undo_list)))
{
/* Set AT_BOUNDARY to 1 only when we have nothing other than
marker adjustment before undo boundary. */
- Lisp_Object tail = current_buffer->undo_list, elt;
+ Lisp_Object tail = BVAR (current_buffer, undo_list), elt;
while (1)
{
/* If we are just after an undo boundary, and
point wasn't at start of deleted range, record where it was. */
if (at_boundary
- && BUFFERP (last_point_position_buffer)
- /* If we're called from batch mode, this could be nil. */
- && current_buffer == XBUFFER (last_point_position_buffer))
- {
- /* If we have switched windows, use the point value
- from the window we are in. */
- if (! EQ (last_point_position_window, selected_window))
- last_point_position = marker_position (XWINDOW (selected_window)->pointm);
-
- if (last_point_position != pt)
- current_buffer->undo_list
- = Fcons (make_number (last_point_position), current_buffer->undo_list);
- }
+ && current_buffer == last_boundary_buffer
+ && last_boundary_position != pt)
+ BVAR (current_buffer, undo_list)
+ = Fcons (make_number (last_boundary_position), BVAR (current_buffer, undo_list));
}
/* Record an insertion that just happened or is about to happen,
because we don't need to record the contents.) */
void
-record_insert (beg, length)
- int beg, length;
+record_insert (EMACS_INT beg, EMACS_INT length)
{
Lisp_Object lbeg, lend;
- if (EQ (current_buffer->undo_list, Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
record_point (beg);
/* If this is following another insertion and consecutive with it
in the buffer, combine the two. */
- if (CONSP (current_buffer->undo_list))
+ if (CONSP (BVAR (current_buffer, undo_list)))
{
Lisp_Object elt;
- elt = XCAR (current_buffer->undo_list);
+ elt = XCAR (BVAR (current_buffer, undo_list));
if (CONSP (elt)
&& INTEGERP (XCAR (elt))
&& INTEGERP (XCDR (elt))
XSETFASTINT (lbeg, beg);
XSETINT (lend, beg + length);
- current_buffer->undo_list = Fcons (Fcons (lbeg, lend),
- current_buffer->undo_list);
+ BVAR (current_buffer, undo_list) = Fcons (Fcons (lbeg, lend),
+ BVAR (current_buffer, undo_list));
}
/* Record that a deletion is about to take place,
of the characters in STRING, at location BEG. */
void
-record_delete (beg, string)
- int beg;
- Lisp_Object string;
+record_delete (EMACS_INT beg, Lisp_Object string)
{
Lisp_Object sbeg;
- if (EQ (current_buffer->undo_list, Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (PT == beg + SCHARS (string))
record_point (beg);
}
- current_buffer->undo_list
- = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
+ BVAR (current_buffer, undo_list)
+ = Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list));
}
/* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
won't be inverted automatically by undoing the buffer modification. */
void
-record_marker_adjustment (marker, adjustment)
- Lisp_Object marker;
- int adjustment;
+record_marker_adjustment (Lisp_Object marker, EMACS_INT adjustment)
{
- if (EQ (current_buffer->undo_list, Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
/* Allocate a cons cell to be the undo boundary after this command. */
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
- if (!BUFFERP (last_undo_buffer)
- || current_buffer != XBUFFER (last_undo_buffer))
+ if (current_buffer != last_undo_buffer)
Fundo_boundary ();
- XSETBUFFER (last_undo_buffer, current_buffer);
+ last_undo_buffer = current_buffer;
- current_buffer->undo_list
+ BVAR (current_buffer, undo_list)
= Fcons (Fcons (marker, make_number (adjustment)),
- current_buffer->undo_list);
+ BVAR (current_buffer, undo_list));
}
/* Record that a replacement is about to take place,
The replacement must not change the number of characters. */
void
-record_change (beg, length)
- int beg, length;
+record_change (EMACS_INT beg, EMACS_INT length)
{
record_delete (beg, make_buffer_string (beg, beg + length, 1));
record_insert (beg, length);
we can tell whether it is obsolete because the file was saved again. */
void
-record_first_change ()
+record_first_change (void)
{
Lisp_Object high, low;
struct buffer *base_buffer = current_buffer;
- if (EQ (current_buffer->undo_list, Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
- if (!BUFFERP (last_undo_buffer)
- || current_buffer != XBUFFER (last_undo_buffer))
+ if (current_buffer != last_undo_buffer)
Fundo_boundary ();
- XSETBUFFER (last_undo_buffer, current_buffer);
+ last_undo_buffer = current_buffer;
if (base_buffer->base_buffer)
base_buffer = base_buffer->base_buffer;
XSETFASTINT (high, (base_buffer->modtime >> 16) & 0xffff);
XSETFASTINT (low, base_buffer->modtime & 0xffff);
- current_buffer->undo_list = Fcons (Fcons (Qt, Fcons (high, low)), current_buffer->undo_list);
+ BVAR (current_buffer, undo_list) = Fcons (Fcons (Qt, Fcons (high, low)), BVAR (current_buffer, undo_list));
}
/* Record a change in property PROP (whose old value was VAL)
for LENGTH characters starting at position BEG in BUFFER. */
void
-record_property_change (beg, length, prop, value, buffer)
- int beg, length;
- Lisp_Object prop, value, buffer;
+record_property_change (EMACS_INT beg, EMACS_INT length,
+ Lisp_Object prop, Lisp_Object value,
+ Lisp_Object buffer)
{
Lisp_Object lbeg, lend, entry;
- struct buffer *obuf = current_buffer;
+ struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
int boundary = 0;
- if (EQ (XBUFFER (buffer)->undo_list, Qt))
+ if (EQ (BVAR (buf, undo_list), Qt))
return;
/* Allocate a cons cell to be the undo boundary after this command. */
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
- if (!EQ (buffer, last_undo_buffer))
+ if (buf != last_undo_buffer)
boundary = 1;
- last_undo_buffer = buffer;
+ last_undo_buffer = buf;
/* Switch temporarily to the buffer that was changed. */
- current_buffer = XBUFFER (buffer);
+ current_buffer = buf;
if (boundary)
Fundo_boundary ();
XSETINT (lbeg, beg);
XSETINT (lend, beg + length);
entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
- current_buffer->undo_list = Fcons (entry, current_buffer->undo_list);
+ BVAR (current_buffer, undo_list) = Fcons (entry, BVAR (current_buffer, undo_list));
current_buffer = obuf;
}
-DEFUN ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
+DEFUE ("undo-boundary", Fundo_boundary, Sundo_boundary, 0, 0, 0,
doc: /* Mark a boundary between units of undo.
An undo command will stop at this point,
but another undo command will undo to the previous boundary. */)
- ()
+ (void)
{
Lisp_Object tem;
- if (EQ (current_buffer->undo_list, Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return Qnil;
- tem = Fcar (current_buffer->undo_list);
+ tem = Fcar (BVAR (current_buffer, undo_list));
if (!NILP (tem))
{
/* One way or another, cons nil onto the front of the undo list. */
{
/* If we have preallocated the cons cell to use here,
use that one. */
- XSETCDR (pending_boundary, current_buffer->undo_list);
- current_buffer->undo_list = pending_boundary;
+ XSETCDR (pending_boundary, BVAR (current_buffer, undo_list));
+ BVAR (current_buffer, undo_list) = pending_boundary;
pending_boundary = Qnil;
}
else
- current_buffer->undo_list = Fcons (Qnil, current_buffer->undo_list);
+ BVAR (current_buffer, undo_list) = Fcons (Qnil, BVAR (current_buffer, undo_list));
}
+ last_boundary_position = PT;
+ last_boundary_buffer = current_buffer;
return Qnil;
}
In some cases this works by calling undo-outer-limit-function. */
void
-truncate_undo_list (b)
- struct buffer *b;
+truncate_undo_list (struct buffer *b)
{
Lisp_Object list;
Lisp_Object prev, next, last_boundary;
record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
set_buffer_internal (b);
- list = b->undo_list;
+ list = BVAR (b, undo_list);
prev = Qnil;
next = list;
&& size_so_far > XINT (Vundo_outer_limit)
&& !NILP (Vundo_outer_limit_function))
{
- Lisp_Object temp = last_undo_buffer, tem;
+ Lisp_Object tem;
+ struct buffer *temp = last_undo_buffer;
/* Normally the function this calls is undo-outer-limit-truncate. */
tem = call1 (Vundo_outer_limit_function, make_number (size_so_far));
XSETCDR (last_boundary, Qnil);
/* There's nothing we decided to keep, so clear it out. */
else
- b->undo_list = Qnil;
+ BVAR (b, undo_list) = Qnil;
unbind_to (count, Qnil);
}
DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
doc: /* Undo N records from the front of the list LIST.
Return what remains of the list. */)
- (n, list)
- Lisp_Object n, list;
+ (Lisp_Object n, Lisp_Object list)
{
struct gcpro gcpro1, gcpro2;
Lisp_Object next;
/* In a writable buffer, enable undoing read-only text that is so
because of text properties. */
- if (NILP (current_buffer->read_only))
+ if (NILP (BVAR (current_buffer, read_only)))
specbind (Qinhibit_read_only, Qt);
/* Don't let `intangible' properties interfere with undo. */
specbind (Qinhibit_point_motion_hooks, Qt);
- oldlist = current_buffer->undo_list;
+ oldlist = BVAR (current_buffer, undo_list);
while (arg > 0)
{
{
/* Element (STRING . POS) means STRING was deleted. */
Lisp_Object membuf;
- int pos = XINT (cdr);
+ EMACS_INT pos = XINT (cdr);
membuf = car;
if (pos < 0)
so the test in `undo' for continuing an undo series
will work right. */
if (did_apply
- && EQ (oldlist, current_buffer->undo_list))
- current_buffer->undo_list
- = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
+ && EQ (oldlist, BVAR (current_buffer, undo_list)))
+ BVAR (current_buffer, undo_list)
+ = Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list));
UNGCPRO;
return unbind_to (count, list);
}
\f
void
-syms_of_undo ()
+syms_of_undo (void)
{
- Qinhibit_read_only = intern ("inhibit-read-only");
+ Qinhibit_read_only = intern_c_string ("inhibit-read-only");
staticpro (&Qinhibit_read_only);
- Qapply = intern ("apply");
+ Qapply = intern_c_string ("apply");
staticpro (&Qapply);
pending_boundary = Qnil;
staticpro (&pending_boundary);
+ last_undo_buffer = NULL;
+ last_boundary_buffer = NULL;
+
defsubr (&Sprimitive_undo);
defsubr (&Sundo_boundary);
- DEFVAR_INT ("undo-limit", &undo_limit,
+ DEFVAR_INT ("undo-limit", undo_limit,
doc: /* Keep no more undo information once it exceeds this size.
This limit is applied when garbage collection happens.
When a previous command increases the total undo list size past this
The size is counted as the number of bytes occupied,
which includes both saved text and other data. */);
- undo_limit = 20000;
+ undo_limit = 80000;
- DEFVAR_INT ("undo-strong-limit", &undo_strong_limit,
+ DEFVAR_INT ("undo-strong-limit", undo_strong_limit,
doc: /* Don't keep more than this much size of undo information.
This limit is applied when garbage collection happens.
When a previous command increases the total undo list size past this
The size is counted as the number of bytes occupied,
which includes both saved text and other data. */);
- undo_strong_limit = 30000;
+ undo_strong_limit = 120000;
- DEFVAR_LISP ("undo-outer-limit", &Vundo_outer_limit,
+ DEFVAR_LISP ("undo-outer-limit", Vundo_outer_limit,
doc: /* Outer limit on size of undo information for one command.
At garbage collection time, if the current command has produced
more than this much undo information, it discards the info and displays
`undo-outer-limit-function' with one argument, the size.
The text above describes the behavior of the function
that variable usually specifies. */);
- Vundo_outer_limit = make_number (3000000);
+ Vundo_outer_limit = make_number (12000000);
- DEFVAR_LISP ("undo-outer-limit-function", &Vundo_outer_limit_function,
+ DEFVAR_LISP ("undo-outer-limit-function", Vundo_outer_limit_function,
doc: /* Function to call when an undo list exceeds `undo-outer-limit'.
This function is called with one argument, the current undo list size
for the most recent command (since the last undo boundary).
so it must make sure not to do a lot of consing. */);
Vundo_outer_limit_function = Qnil;
- DEFVAR_BOOL ("undo-inhibit-record-point", &undo_inhibit_record_point,
+ DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
doc: /* Non-nil means do not record `point' in `buffer-undo-list'. */);
undo_inhibit_record_point = 0;
}
-
-/* arch-tag: d546ee01-4aed-4ffb-bb8b-eefaae50d38a
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff