(It is possible to record an insertion before or after the fact
because we don't need to record the contents.) */
+void
record_insert (beg, length)
int beg, length;
{
if (CONSP (current_buffer->undo_list))
{
Lisp_Object elt;
- elt = XCONS (current_buffer->undo_list)->car;
+ elt = XCAR (current_buffer->undo_list);
if (CONSP (elt)
- && INTEGERP (XCONS (elt)->car)
- && INTEGERP (XCONS (elt)->cdr)
- && XINT (XCONS (elt)->cdr) == beg)
+ && INTEGERP (XCAR (elt))
+ && INTEGERP (XCDR (elt))
+ && XINT (XCDR (elt)) == beg)
{
- XSETINT (XCONS (elt)->cdr, beg + length);
+ XSETINT (XCDR (elt), beg + length);
return;
}
}
}
/* Record that a deletion is about to take place,
- for LENGTH characters at location BEG. */
+ of the characters in STRING, at location BEG. */
-record_delete (beg, length)
- int beg, length;
+void
+record_delete (beg, string)
+ int beg;
+ Lisp_Object string;
{
- Lisp_Object lbeg, lend, sbeg;
+ Lisp_Object sbeg;
int at_boundary;
if (EQ (current_buffer->undo_list, Qt))
Fundo_boundary ();
XSETBUFFER (last_undo_buffer, current_buffer);
- at_boundary = (CONSP (current_buffer->undo_list)
- && NILP (XCONS (current_buffer->undo_list)->car));
+ if (CONSP (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;
+
+ while (1)
+ {
+ elt = XCAR (tail);
+ if (NILP (elt) || ! (CONSP (elt) && MARKERP (XCAR (elt))))
+ break;
+ tail = XCDR (tail);
+ }
+ at_boundary = NILP (elt);
+ }
+ else
+ at_boundary = 0;
if (MODIFF <= SAVE_MODIFF)
record_first_change ();
- if (PT == beg + length)
+ if (PT == beg + XSTRING (string)->size)
XSETINT (sbeg, -beg);
else
XSETFASTINT (sbeg, beg);
- XSETFASTINT (lbeg, beg);
- XSETFASTINT (lend, beg + length);
/* If we are just after an undo boundary, and
point wasn't at start of deleted range, record where it was. */
= Fcons (make_number (last_point_position), current_buffer->undo_list);
current_buffer->undo_list
- = Fcons (Fcons (Fbuffer_substring (lbeg, lend), sbeg),
- current_buffer->undo_list);
+ = Fcons (Fcons (string, sbeg), current_buffer->undo_list);
}
/* Record the fact that MARKER is about to be adjusted by ADJUSTMENT.
because that's the only case where an automatic marker adjustment
won't be inverted automatically by undoing the buffer modification. */
+void
record_marker_adjustment (marker, adjustment)
Lisp_Object marker;
int adjustment;
/* Record that a replacement is about to take place,
for LENGTH characters at location BEG.
- The replacement does not change the number of characters. */
+ The replacement must not change the number of characters. */
+void
record_change (beg, length)
int beg, length;
{
- record_delete (beg, length);
+ record_delete (beg, make_buffer_string (beg, beg + length, 1));
record_insert (beg, length);
}
\f
Record the file modification date so that when undoing this entry
we can tell whether it is obsolete because the file was saved again. */
+void
record_first_change ()
{
Lisp_Object high, low;
/* 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;
{
/* If we have preallocated the cons cell to use here,
use that one. */
- XCONS (pending_boundary)->cdr = current_buffer->undo_list;
+ XCDR (pending_boundary) = current_buffer->undo_list;
current_buffer->undo_list = pending_boundary;
pending_boundary = Qnil;
}
Skip, skip, skip the undo, skip, skip, skip the undo,
Skip, skip, skip the undo, skip to the undo bound'ry.
(Get it? "Skip to my Loo?") */
- if (CONSP (next) && NILP (XCONS (next)->car))
+ if (CONSP (next) && NILP (XCAR (next)))
{
/* Add in the space occupied by this element and its chain link. */
size_so_far += sizeof (struct Lisp_Cons);
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
- while (CONSP (next) && ! NILP (XCONS (next)->car))
+ while (CONSP (next) && ! NILP (XCAR (next)))
{
Lisp_Object elt;
- elt = XCONS (next)->car;
+ elt = XCAR (next);
/* Add in the space occupied by this element and its chain link. */
size_so_far += sizeof (struct Lisp_Cons);
if (CONSP (elt))
{
size_so_far += sizeof (struct Lisp_Cons);
- if (STRINGP (XCONS (elt)->car))
+ if (STRINGP (XCAR (elt)))
size_so_far += (sizeof (struct Lisp_String) - 1
- + XSTRING (XCONS (elt)->car)->size);
+ + XSTRING (XCAR (elt))->size);
}
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
if (CONSP (next))
last_boundary = prev;
while (CONSP (next))
{
Lisp_Object elt;
- elt = XCONS (next)->car;
+ elt = XCAR (next);
/* When we get to a boundary, decide whether to truncate
either before or after it. The lower threshold, MINSIZE,
if (CONSP (elt))
{
size_so_far += sizeof (struct Lisp_Cons);
- if (STRINGP (XCONS (elt)->car))
+ if (STRINGP (XCAR (elt)))
size_so_far += (sizeof (struct Lisp_String) - 1
- + XSTRING (XCONS (elt)->car)->size);
+ + XSTRING (XCAR (elt))->size);
}
/* Advance to next element. */
prev = next;
- next = XCONS (next)->cdr;
+ next = XCDR (next);
}
/* If we scanned the whole list, it is short enough; don't change it. */
/* Truncate at the boundary where we decided to truncate. */
if (!NILP (last_boundary))
{
- XCONS (last_boundary)->cdr = Qnil;
+ XCDR (last_boundary) = Qnil;
return list;
}
else
error ("Changes to be undone are outside visible portion of buffer");
SET_PT (pos);
- /* Insert before markers so that if the mark is
- currently on the boundary of this deletion, it
- ends up on the other side of the now-undeleted
- text from point. Since undo doesn't even keep
- track of the mark, this isn't really necessary,
- but it may lead to better behavior in certain
- situations. */
- Finsert_before_markers (1, &membuf);
+ /* Now that we record marker adjustments
+ (caused by deletion) for undo,
+ we should always insert after markers,
+ so that undoing the marker adjustments
+ put the markers back in the right place. */
+ Finsert (1, &membuf);
SET_PT (pos);
}
}
return unbind_to (count, list);
}
+void
syms_of_undo ()
{
Qinhibit_read_only = intern ("inhibit-read-only");
HCoop / bpt / emacs.git / blobdiff