/* undo handling for GNU Emacs.
- Copyright (C) 1990, 1993-1994, 2000-2011 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1993-1994, 2000-2012 Free Software Foundation, Inc.
This file is part of GNU Emacs.
/* Last buffer for which undo information was recorded. */
/* BEWARE: This is not traced by the GC, so never dereference it! */
-struct buffer *last_undo_buffer;
+static struct buffer *last_undo_buffer;
/* Position of point last time we inserted a boundary. */
-struct buffer *last_boundary_buffer;
-EMACS_INT last_boundary_position;
+static struct buffer *last_boundary_buffer;
+static ptrdiff_t last_boundary_position;
Lisp_Object Qinhibit_read_only;
which will be added to the list at the end of the command.
This ensures we can't run out of space while trying to make
an undo-boundary. */
-Lisp_Object pending_boundary;
+static Lisp_Object pending_boundary;
/* Record point as it was at beginning of this command (if necessary)
and prepare the undo info for recording a change.
undo record that will be added just after this command terminates. */
static void
-record_point (EMACS_INT pt)
+record_point (ptrdiff_t pt)
{
int at_boundary;
Fundo_boundary ();
last_undo_buffer = current_buffer;
- if (CONSP (B_ (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 = B_ (current_buffer, undo_list), elt;
+ Lisp_Object tail = BVAR (current_buffer, undo_list), elt;
while (1)
{
if (at_boundary
&& current_buffer == last_boundary_buffer
&& last_boundary_position != pt)
- B_ (current_buffer, undo_list)
- = Fcons (make_number (last_boundary_position), B_ (current_buffer, undo_list));
+ 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 (EMACS_INT beg, EMACS_INT length)
+record_insert (ptrdiff_t beg, ptrdiff_t length)
{
Lisp_Object lbeg, lend;
- if (EQ (B_ (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 (B_ (current_buffer, undo_list)))
+ if (CONSP (BVAR (current_buffer, undo_list)))
{
Lisp_Object elt;
- elt = XCAR (B_ (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);
- B_ (current_buffer, undo_list) = Fcons (Fcons (lbeg, lend),
- B_ (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 (EMACS_INT beg, Lisp_Object string)
+record_delete (ptrdiff_t beg, Lisp_Object string)
{
Lisp_Object sbeg;
- if (EQ (B_ (current_buffer, undo_list), Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (PT == beg + SCHARS (string))
record_point (beg);
}
- B_ (current_buffer, undo_list)
- = Fcons (Fcons (string, sbeg), B_ (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 (Lisp_Object marker, EMACS_INT adjustment)
+record_marker_adjustment (Lisp_Object marker, ptrdiff_t adjustment)
{
- if (EQ (B_ (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. */
Fundo_boundary ();
last_undo_buffer = current_buffer;
- B_ (current_buffer, undo_list)
+ BVAR (current_buffer, undo_list)
= Fcons (Fcons (marker, make_number (adjustment)),
- B_ (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 (EMACS_INT beg, EMACS_INT length)
+record_change (ptrdiff_t beg, ptrdiff_t length)
{
record_delete (beg, make_buffer_string (beg, beg + length, 1));
record_insert (beg, length);
void
record_first_change (void)
{
- Lisp_Object high, low;
struct buffer *base_buffer = current_buffer;
- if (EQ (B_ (current_buffer, undo_list), Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return;
if (current_buffer != last_undo_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);
- B_ (current_buffer, undo_list) = Fcons (Fcons (Qt, Fcons (high, low)), B_ (current_buffer, undo_list));
+ BVAR (current_buffer, undo_list) =
+ Fcons (Fcons (Qt, INTEGER_TO_CONS (base_buffer->modtime)),
+ 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 (EMACS_INT beg, EMACS_INT length,
+record_property_change (ptrdiff_t beg, ptrdiff_t length,
Lisp_Object prop, Lisp_Object value,
Lisp_Object buffer)
{
struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
int boundary = 0;
- if (EQ (B_ (buf, undo_list), Qt))
+ if (EQ (BVAR (buf, undo_list), Qt))
return;
/* Allocate a cons cell to be the undo boundary after this command. */
XSETINT (lbeg, beg);
XSETINT (lend, beg + length);
entry = Fcons (Qnil, Fcons (prop, Fcons (value, Fcons (lbeg, lend))));
- B_ (current_buffer, undo_list) = Fcons (entry, B_ (current_buffer, undo_list));
+ BVAR (current_buffer, undo_list) = Fcons (entry, BVAR (current_buffer, undo_list));
current_buffer = obuf;
}
(void)
{
Lisp_Object tem;
- if (EQ (B_ (current_buffer, undo_list), Qt))
+ if (EQ (BVAR (current_buffer, undo_list), Qt))
return Qnil;
- tem = Fcar (B_ (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, B_ (current_buffer, undo_list));
- B_ (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
- B_ (current_buffer, undo_list) = Fcons (Qnil, B_ (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;
{
Lisp_Object list;
Lisp_Object prev, next, last_boundary;
- int size_so_far = 0;
+ EMACS_INT size_so_far = 0;
/* Make sure that calling undo-outer-limit-function
won't cause another GC. */
- int count = inhibit_garbage_collection ();
+ ptrdiff_t count = inhibit_garbage_collection ();
/* Make the buffer current to get its local values of variables such
as undo_limit. Also so that Vundo_outer_limit_function can
record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
set_buffer_internal (b);
- list = B_ (b, undo_list);
+ list = BVAR (b, undo_list);
prev = Qnil;
next = list;
XSETCDR (last_boundary, Qnil);
/* There's nothing we decided to keep, so clear it out. */
else
- B_ (b, undo_list) = Qnil;
+ BVAR (b, undo_list) = Qnil;
unbind_to (count, Qnil);
}
{
struct gcpro gcpro1, gcpro2;
Lisp_Object next;
- int count = SPECPDL_INDEX ();
- register int arg;
+ ptrdiff_t count = SPECPDL_INDEX ();
+ register EMACS_INT arg;
Lisp_Object oldlist;
int did_apply = 0;
/* In a writable buffer, enable undoing read-only text that is so
because of text properties. */
- if (NILP (B_ (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 = B_ (current_buffer, undo_list);
+ oldlist = BVAR (current_buffer, undo_list);
while (arg > 0)
{
if (EQ (car, Qt))
{
/* Element (t high . low) records previous modtime. */
- Lisp_Object high, low;
- int mod_time;
struct buffer *base_buffer = current_buffer;
-
- high = Fcar (cdr);
- low = Fcdr (cdr);
- mod_time = (XFASTINT (high) << 16) + XFASTINT (low);
+ time_t mod_time;
+ CONS_TO_INTEGER (cdr, time_t, mod_time);
if (current_buffer->base_buffer)
base_buffer = current_buffer->base_buffer;
so the test in `undo' for continuing an undo series
will work right. */
if (did_apply
- && EQ (oldlist, B_ (current_buffer, undo_list)))
- B_ (current_buffer, undo_list)
- = Fcons (list3 (Qapply, Qcdr, Qnil), B_ (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);
void
syms_of_undo (void)
{
- Qinhibit_read_only = intern_c_string ("inhibit-read-only");
- staticpro (&Qinhibit_read_only);
-
- Qapply = intern_c_string ("apply");
- staticpro (&Qapply);
+ DEFSYM (Qinhibit_read_only, "inhibit-read-only");
+ DEFSYM (Qapply, "apply");
pending_boundary = Qnil;
staticpro (&pending_boundary);
doc: /* Non-nil means do not record `point' in `buffer-undo-list'. */);
undo_inhibit_record_point = 0;
}
-
HCoop / bpt / emacs.git / blobdiff