void
record_insert (ptrdiff_t beg, ptrdiff_t length)
{
Lisp_Object lbeg, lend;
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 (BVAR (current_buffer, undo_list)))
{
Lisp_Object elt;
elt = XCAR (BVAR (current_buffer, undo_list));
if (CONSP (elt)
&& INTEGERP (XCAR (elt))
&& INTEGERP (XCDR (elt))
&& XINT (XCDR (elt)) == beg)
{
XSETCDR (elt, make_number (beg + length));
return;
}
}
XSETFASTINT (lbeg, beg);
XSETINT (lend, beg + length);
bset_undo_list (current_buffer,
Fcons (Fcons (lbeg, lend), BVAR (current_buffer, undo_list)));
}
void
record_property_change (ptrdiff_t beg, ptrdiff_t length,
Lisp_Object prop, Lisp_Object value,
Lisp_Object buffer)
{
Lisp_Object lbeg, lend, entry;
struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
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);
/* Switch temporarily to the buffer that was changed. */
set_buffer_internal (buf);
run_undoable_change ();
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
XSETINT (lbeg, beg);
XSETINT (lend, beg + length);
entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
bset_undo_list (current_buffer,
Fcons (entry, BVAR (current_buffer, undo_list)));
/* Reset the buffer */
set_buffer_internal (obuf);
}
static void
record_point (ptrdiff_t pt)
{
bool at_boundary;
/* Don't record position of pt when undo_inhibit_record_point holds. */
if (undo_inhibit_record_point)
return;
/* Allocate a cons cell to be the undo boundary after this command. */
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
run_undoable_change ();
at_boundary = ! CONSP (BVAR (current_buffer, undo_list))
|| NILP (XCAR (BVAR (current_buffer, undo_list)));
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
/* If we are just after an undo boundary, and
point wasn't at start of deleted range, record where it was. */
if (at_boundary
&& current_buffer == last_boundary_buffer
&& last_boundary_position != pt)
bset_undo_list (current_buffer,
Fcons (make_number (last_boundary_position),
BVAR (current_buffer, undo_list)));
}
void
record_delete (ptrdiff_t beg, Lisp_Object string, bool record_markers)
{
Lisp_Object sbeg;
if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (PT == beg + SCHARS (string))
{
XSETINT (sbeg, -beg);
record_point (PT);
}
else
{
XSETFASTINT (sbeg, beg);
record_point (beg);
}
/* primitive-undo assumes marker adjustments are recorded
immediately before the deletion is recorded. See bug 16818
discussion. */
if (record_markers)
record_marker_adjustments (beg, beg + SCHARS (string));
bset_undo_list
(current_buffer,
Fcons (Fcons (string, sbeg), BVAR (current_buffer, undo_list)));
}
/* Record point, if necessary, as it was at beginning of this command.
BEG 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 (ptrdiff_t beg)
{
/* Don't record position of pt when undo_inhibit_record_point holds. */
if (undo_inhibit_record_point)
return;
bool at_boundary;
/* Check whether we are at a boundary now, in case we record the
first change. FIXME: This check is currently dependent on being
called before record_first_change, but could be made not to by
ignoring timestamp undo entries */
at_boundary = ! CONSP (BVAR (current_buffer, undo_list))
|| NILP (XCAR (BVAR (current_buffer, undo_list)));
/* If this is the first change since save, then record this.*/
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
/* We may need to record point if we are immediately after a
boundary, so that this will be restored correctly after undo. We
do not need to do this if point is at the start of a change
region since it will be restored there anyway, and we must not do
this if the buffer has changed since the last command, since the
value of point that we have will be for that buffer, not this.*/
if (at_boundary
&& point_before_last_command_or_undo != beg
&& buffer_before_last_command_or_undo == current_buffer )
bset_undo_list (current_buffer,
Fcons (make_number (point_before_last_command_or_undo),
BVAR (current_buffer, undo_list)));
}
void
record_first_change (void)
{
struct buffer *base_buffer = current_buffer;
if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (base_buffer->base_buffer)
base_buffer = base_buffer->base_buffer;
bset_undo_list (current_buffer,
Fcons (Fcons (Qt, Fvisited_file_modtime ()),
BVAR (current_buffer, undo_list)));
}
static void
record_marker_adjustments (ptrdiff_t from, ptrdiff_t to)
{
Lisp_Object marker;
register struct Lisp_Marker *m;
register ptrdiff_t charpos, adjustment;
/* Allocate a cons cell to be the undo boundary after this command. */
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
if (current_buffer != last_undo_buffer)
Fundo_boundary ();
last_undo_buffer = current_buffer;
for (m = BUF_MARKERS (current_buffer); m; m = m->next)
{
charpos = m->charpos;
eassert (charpos <= Z);
if (from <= charpos && charpos <= to)
{
/* insertion_type nil markers will end up at the beginning of
the re-inserted text after undoing a deletion, and must be
adjusted to move them to the correct place.
insertion_type t markers will automatically move forward
upon re-inserting the deleted text, so we have to arrange
for them to move backward to the correct position. */
adjustment = (m->insertion_type ? to : from) - charpos;
if (adjustment)
{
XSETMISC (marker, m);
bset_undo_list
(current_buffer,
Fcons (Fcons (marker, make_number (adjustment)),
BVAR (current_buffer, undo_list)));
}
}
}
}
/* Record point as it was at beginning of this command.
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 (ptrdiff_t pt)
{
/* Don't record position of pt when undo_inhibit_record_point holds. */
if (undo_inhibit_record_point)
return;
bool at_boundary;
at_boundary = ! CONSP (BVAR (current_buffer, undo_list))
|| NILP (XCAR (BVAR (current_buffer, undo_list)));
prepare_record ();
/* If we are just after an undo boundary, and
point wasn't at start of deleted range, record where it was. */
if (at_boundary)
bset_undo_list (current_buffer,
Fcons (make_number (pt),
BVAR (current_buffer, undo_list)));
}
void
record_property_change (ptrdiff_t beg, ptrdiff_t length,
Lisp_Object prop, Lisp_Object value,
Lisp_Object buffer)
{
Lisp_Object lbeg, lend, entry;
struct buffer *buf = XBUFFER (buffer);
if (EQ (BVAR (buf, undo_list), Qt))
return;
prepare_record();
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
XSETINT (lbeg, beg);
XSETINT (lend, beg + length);
entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
bset_undo_list (current_buffer,
Fcons (entry, BVAR (current_buffer, undo_list)));
}
static void
record_point (ptrdiff_t pt)
{
bool at_boundary;
/* Don't record position of pt when undo_inhibit_record_point holds. */
if (undo_inhibit_record_point)
return;
/* Allocate a cons cell to be the undo boundary after this command. */
if (NILP (pending_boundary))
pending_boundary = Fcons (Qnil, Qnil);
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 ();
last_undo_buffer = current_buffer;
at_boundary = ! CONSP (BVAR (current_buffer, undo_list))
|| NILP (XCAR (BVAR (current_buffer, undo_list)));
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
/* If we are just after an undo boundary, and
point wasn't at start of deleted range, record where it was. */
if (at_boundary
&& current_buffer == last_boundary_buffer
&& last_boundary_position != pt)
bset_undo_list (current_buffer,
Fcons (make_number (last_boundary_position),
BVAR (current_buffer, undo_list)));
}
