diff --git a/configure.ac b/configure.ac
index b7651ed..2674806 100644
--- a/configure.ac
+++ b/configure.ac
@@ -378,12 +378,6 @@ AC_DEFUN
OPTION_DEFAULT_OFF([xwidgets],
[enable use of some gtk widgets in Emacs buffers (requires gtk3)])
-OPTION_DEFAULT_OFF([new_overlays],
- [Use AA-tree for overlays])
-
-OPTION_DEFAULT_OFF([both_overlays],
- [Use both overlays and a lot of assertions])
-
## For the times when you want to build Emacs but don't have
## a suitable makeinfo, and can live without the manuals.
dnl http://lists.gnu.org/archive/html/emacs-devel/2008-04/msg01844.html
@@ -2648,35 +2642,6 @@ AC_DEFUN
CFLAGS=$OLD_CFLAGS
LIBS=$OLD_LIBS
-
-BOTH_OVERLAYS=no
-NEW_OVERLAYS=no
-OVERLAYS_OBJ=
-OVERLAYS_H=
-if test "$with_new_overlays" != "no"; then
- if test "$with_both_overlays" != "no"; then
- AS_ECHO([both? ${BOTH_OVERLAYS} $with_new_overlays $with_both_overlays])
- AC_MSG_ERROR([Can't have both new-overlays and both-overlays.])
- fi
- NEW_OVERLAYS=yes
- AC_DEFINE([NEW_OVERLAYS], 1, [Use new overlays.])
- OVERLAYS_OBJ=overlays.o
- OVERLAYS_H=overlays.h
-fi
-
-if test "$with_both_overlays" != "no"; then
- if test "x$ac_enable_checking" == "x" ; then
- AC_MSG_ERROR([with-both_overlays only makes sense with enable-checking])
- fi
- BOTH_OVERLAYS=yes
- AC_DEFINE([BOTH_OVERLAYS], 1, [Use both overlays.])
- OVERLAYS_OBJ=overlays.o
- OVERLAYS_H=overlays.h
-fi
-AC_SUBST(OVERLAYS_OBJ)
-AC_SUBST(OVERLAYS_H)
-
-
dnl D-Bus has been tested under GNU/Linux only. Must be adapted for
dnl other platforms.
HAVE_DBUS=no
@@ -5319,8 +5284,6 @@ AC_DEFUN
Does Emacs have dynamic modules support? ${HAVE_MODULES}
Does Emacs use toolkit scroll bars? ${USE_TOOLKIT_SCROLL_BARS}
Does Emacs support Xwidgets (requires gtk3)? ${HAVE_XWIDGETS}
- Does Emacs use both overlay structures? ${BOTH_OVERLAYS}
- Does Emacs use AA-tree for overlays? ${NEW_OVERLAYS}
"])
if test -n "${EMACSDATA}"; then
diff --git a/src/Makefile.in b/src/Makefile.in
index 89c0c2a..8639eff 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -156,8 +156,6 @@ DBUS_OBJ =
## xwidgets.o if HAVE_XWIDGETS, else empty.
XWIDGETS_OBJ = @XWIDGETS_OBJ@
-OVERLAYS_OBJ = @OVERLAYS_OBJ@
-
address@hidden@
SETTINGS_CFLAGS = @SETTINGS_CFLAGS@
@@ -398,7 +396,7 @@ base_obj =
$(CM_OBJ) term.o terminal.o xfaces.o $(XOBJ) $(GTK_OBJ) $(DBUS_OBJ) \
emacs.o keyboard.o macros.o keymap.o sysdep.o \
buffer.o filelock.o insdel.o marker.o \
- minibuf.o fileio.o dired.o $(OVERLAYS_OBJ) \
+ minibuf.o fileio.o dired.o \
cmds.o casetab.o casefiddle.o indent.o search.o regex.o undo.o \
alloc.o data.o doc.o editfns.o callint.o \
eval.o floatfns.o fns.o font.o print.o lread.o $(MODULES_OBJ) \
diff --git a/src/alloc.c b/src/alloc.c
index 2ec7dae..5f9d6ad 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3799,18 +3799,6 @@ build_overlay (Lisp_Object start, Lisp_Object end, Lisp_Object plist)
OVERLAY_END (overlay) = end;
set_overlay_plist (overlay, plist);
XOVERLAY (overlay)->next = NULL;
-
-#ifdef NEW_OVERLAYS
- XOVERLAY (overlay)->left = NULL;
- XOVERLAY (overlay)->right = NULL;
- ptrdiff_t char_start = XINT (Fmarker_position (start));
- XOVERLAY (overlay)->char_start = char_start;
- XOVERLAY (overlay)->byte_start = CHAR_TO_BYTE(char_start);
- ptrdiff_t char_end = XINT (Fmarker_position(end));
- XOVERLAY (overlay)->char_end = char_end;
- XOVERLAY (overlay)->byte_end = CHAR_TO_BYTE(char_end);
-#endif
-
return overlay;
}
diff --git a/src/buffer.c b/src/buffer.c
index cca91c7..8756cbb 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -43,10 +43,6 @@ along with GNU Emacs. If not, see . */
#include "frame.h"
#include "xwidget.h"
-#if defined (NEW_OVERLAYS) || defined (BOTH_OVERLAYS)
-#include "overlays.h"
-#endif
-
#ifdef WINDOWSNT
#include "w32heap.h" /* for mmap_* */
#endif
@@ -125,7 +121,7 @@ static Lisp_Object QSFundamental; /* A string "Fundamental". */
static void alloc_buffer_text (struct buffer *, ptrdiff_t);
static void free_buffer_text (struct buffer *b);
static struct Lisp_Overlay * copy_overlays (struct buffer *, struct Lisp_Overlay *);
-void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
+static void modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
static Lisp_Object buffer_lisp_local_variables (struct buffer *, bool);
static void
@@ -596,23 +592,6 @@ even if it is dead. The return value is never nil. */)
return buffer;
}
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
-static void INLINE
-insert_overlay_in_buffer_tree (struct buffer *b, Lisp_Object overlay)
-{
- struct Lisp_Overlay *o = XOVERLAY (overlay);
- if (b->overlays_root == OVERLAY_SENTINEL)
- {
- overlay_tree_insert (&b->overlays_root, o);
- eassert (b->overlays_root == o);
- XSETBUFFER(b->overlays_root->parent, b);
- }
- else
- {
- overlay_tree_insert (&b->overlays_root, o);
- }
-}
-#endif
/* Return a list of overlays which is a copy of the overlay list
LIST, but for buffer B. */
@@ -646,7 +625,7 @@ copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
return result;
}
-#ifndef NEW_OVERLAYS
+
/* Set an appropriate overlay of B. */
static void
@@ -660,7 +639,6 @@ set_buffer_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
{
b->overlays_after = o;
}
-#endif
/* Clone per-buffer values of buffer FROM.
@@ -882,7 +860,6 @@ CLONE nil means the indirect buffer's state is reset to default values. */)
return buf;
}
-#ifndef NEW_OVERLAYS
/* Mark OV as no longer associated with B. */
static void
@@ -895,14 +872,12 @@ drop_overlay (struct buffer *b, struct Lisp_Overlay *ov)
unchain_marker (XMARKER (ov->end));
}
-#endif
/* Delete all overlays of B and reset it's overlay lists. */
void
delete_all_overlays (struct buffer *b)
{
-#ifndef NEW_OVERLAYS
struct Lisp_Overlay *ov, *next;
/* FIXME: Since each drop_overlay will scan BUF_MARKERS to unlink its
@@ -923,9 +898,6 @@ delete_all_overlays (struct buffer *b)
set_buffer_overlays_before (b, NULL);
set_buffer_overlays_after (b, NULL);
-#else
- overlay_tree_drop_all (b);
-#endif
}
/* Reinitialize everything about a buffer except its name and contents
@@ -953,11 +925,9 @@ reset_buffer (register struct buffer *b)
b->auto_save_failure_time = 0;
bset_auto_save_file_name (b, Qnil);
bset_read_only (b, Qnil);
-#ifndef NEW_OVERLAYS
set_buffer_overlays_before (b, NULL);
set_buffer_overlays_after (b, NULL);
b->overlay_center = BEG;
-#endif
bset_mark_active (b, Qnil);
bset_point_before_scroll (b, Qnil);
bset_file_format (b, Qnil);
@@ -971,9 +941,6 @@ reset_buffer (register struct buffer *b)
bset_extra_line_spacing (b, BVAR (&buffer_defaults, extra_line_spacing));
b->display_error_modiff = 0;
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- b->overlays_root = OVERLAY_SENTINEL;
-#endif
}
/* Reset buffer B's local variables info.
@@ -2788,7 +2755,6 @@ overlays_at (EMACS_INT pos, bool extend, Lisp_Object **vec_ptr,
ptrdiff_t *len_ptr,
ptrdiff_t *next_ptr, ptrdiff_t *prev_ptr, bool change_req)
{
-#ifndef NEW_OVERLAYS
Lisp_Object overlay, start, end;
struct Lisp_Overlay *tail;
ptrdiff_t idx = 0;
@@ -2895,52 +2861,7 @@ overlays_at (EMACS_INT pos, bool extend, Lisp_Object **vec_ptr,
*next_ptr = next;
if (prev_ptr)
*prev_ptr = prev;
-
-#ifdef BOTH_OVERLAYS
- ptrdiff_t check_next, check_prev, check_len = 20, check_idx;
- Lisp_Object *check_vec;
-
- check_vec = xnmalloc(check_len, sizeof *check_vec);
-
- check_idx = overlay_tree_at (current_buffer->overlays_root,
- pos, &check_next, &check_prev,
- &check_len, &check_vec,
- change_req);
-
- /* Same amount of overlays returned. */
- /* eassert (check_idx == idx); */
- /* Same NEXT_PTR. */
- if (next_ptr)
- eassert (*next_ptr == check_next);
- /* Same PREV_PTR. */
- if (prev_ptr)
- eassert (*prev_ptr == check_prev);
-
- /* Finally check that all overlays in *VEC_PTR are also in
- CHECK_VEC. */
- ptrdiff_t i, j;
- bool found;
- for (i = 0; i < idx; i++)
- {
- found = false;
- struct Lisp_Overlay *o1 = XOVERLAY ((*vec_ptr)[i]);
- for (j = 0; j < idx; j++)
- {
- struct Lisp_Overlay *o2 = XOVERLAY (check_vec[j]);
- if (o1 == o2)
- found = true;
- }
- if (!found)
- eassert (false);
- }
-
-#endif /* BOTH_OVERLAYS */
return idx;
-#else /* if NEW_OVERLAYS */
- return overlay_tree_at (current_buffer->overlays_root, pos,
- next_ptr, prev_ptr, len_ptr, vec_ptr,
- change_req)
-#endif /* ifndef NEW_OVERLAYS */
}
/* Find all the overlays in the current buffer that overlap the range
@@ -3206,14 +3127,8 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
overlay = overlay_vec[i];
if (OVERLAYP (overlay)
-#ifndef NEW_OVERLAYS
&& OVERLAY_POSITION (OVERLAY_START (overlay)) > 0
- && OVERLAY_POSITION (OVERLAY_END (overlay)) > 0
-#else
- && XOVERLAY (overlay)->char_start > 0
- && XOVERLAY (overlay)->char_end > 0
-#endif
- )
+ && OVERLAY_POSITION (OVERLAY_END (overlay)) > 0)
{
/* If we're interested in a specific window, then ignore
overlays that are limited to some other window. */
@@ -3228,17 +3143,8 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
/* This overlay is good and counts: put it into sortvec. */
sortvec[j].overlay = overlay;
-#ifndef NEW_OVERLAYS
sortvec[j].beg = OVERLAY_POSITION (OVERLAY_START (overlay));
sortvec[j].end = OVERLAY_POSITION (OVERLAY_END (overlay));
-#ifdef BOTH_OVERLAYS
- eassert (sortvec[j].beg == XOVERLAY (overlay)->char_start);
- eassert (sortvec[j].end == XOVERLAY (overlay)->char_end);
-#endif
-#else
- sortvec[j].beg = XOVERLAY (overlay)->char_start;
- sortvec[j].end = XOVERLAY (overlay)->char_end;
-#endif
tem = Foverlay_get (overlay, Qpriority);
if (NILP (tem))
{
@@ -3488,7 +3394,6 @@ overlay_strings (ptrdiff_t pos, struct window *w, unsigned char **pstr)
return 0;
}
-#ifndef NEW_OVERLAYS
/* Shift overlays in BUF's overlay lists, to center the lists at POS. */
void
@@ -3637,7 +3542,7 @@ adjust_overlays_for_delete (ptrdiff_t pos, ptrdiff_t length)
and also update the center point. */
recenter_overlay_lists (current_buffer, pos);
}
-#endif
+
/* Fix up overlays that were garbled as a result of permuting markers
in the range START through END. Any overlay with at least one
endpoint in this range will need to be unlinked from the overlay
@@ -3912,7 +3817,6 @@ for the rear of the overlay advance when text is inserted there
b = XBUFFER (buffer);
-#ifndef NEW_OVERLAYS
beg = Fset_marker (Fmake_marker (), beg, buffer);
end = Fset_marker (Fmake_marker (), end, buffer);
@@ -3920,20 +3824,9 @@ for the rear of the overlay advance when text is inserted there
XMARKER (beg)->insertion_type = 1;
if (!NILP (rear_advance))
XMARKER (end)->insertion_type = 1;
-#endif
overlay = build_overlay (beg, end, Qnil);
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- XOVERLAY (overlay)->start_insertion_type = !NILP (front_advance);
- XOVERLAY (overlay)->end_insertion_type = !NILP (rear_advance);
-
- insert_overlay_in_buffer_tree(b, overlay);
-#ifdef BOTH_OVERLAYS
- /* Check coherence */
-#endif /* BOTH_OVERLAYS */
-#endif /* NEW_OVERLAYS or BOTH_OVERLAYS */
-#ifndef NEW_OVERLAYS
/* Put the new overlay on the wrong list. */
end = OVERLAY_END (overlay);
if (OVERLAY_POSITION (end) < b->overlay_center)
@@ -3953,13 +3846,13 @@ for the rear of the overlay advance when text is inserted there
/* We don't need to redisplay the region covered by the overlay, because
the overlay has no properties at the moment. */
-#endif
+
return overlay;
}
/* Mark a section of BUF as needing redisplay because of overlays changes. */
-void
+static void
modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
{
if (start > end)
@@ -3976,7 +3869,6 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
++BUF_OVERLAY_MODIFF (buf);
}
-#ifndef NEW_OVERLAYS
/* Remove OVERLAY from LIST. */
static struct Lisp_Overlay *
@@ -4005,7 +3897,6 @@ unchain_both (struct buffer *b, Lisp_Object overlay)
set_buffer_overlays_after (b, unchain_overlay (b->overlays_after, ov));
eassert (XOVERLAY (overlay)->next == NULL);
}
-#endif
DEFUN ("move-overlay", Fmove_overlay, Smove_overlay, 3, 4, 0,
doc: /* Set the endpoints of OVERLAY to BEG and END in BUFFER.
@@ -4019,23 +3910,10 @@ buffer. */)
ptrdiff_t count = SPECPDL_INDEX ();
ptrdiff_t n_beg, n_end;
ptrdiff_t o_beg UNINIT, o_end UNINIT;
-#if defined(NEW_OVERLAYS ) || defined(BOTH_OVERLAYS)
- ptrdiff_t old_start UNINIT, old_end UNINIT;
-#endif
+
CHECK_OVERLAY (overlay);
if (NILP (buffer))
- {
-#ifndef NEW_OVERLAYS
- buffer = Fmarker_buffer (OVERLAY_START (overlay));
-#ifdef BOTH_OVERLAYS
- struct buffer *b1 = XBUFFER (buffer);
- struct buffer *b2 = XBUFFER (buffer_of_overlay (overlay));
- eassert (b1 == b2);
-#endif
-#else /* NEW_OVERLAYS */
- buffer = buffer_of_overlay (overlay);
-#endif
- }
+ buffer = Fmarker_buffer (OVERLAY_START (overlay));
if (NILP (buffer))
XSETBUFFER (buffer, current_buffer);
CHECK_BUFFER (buffer);
@@ -4059,68 +3937,33 @@ buffer. */)
specbind (Qinhibit_quit, Qt);
-#ifndef NEW_OVERLAYS
obuffer = Fmarker_buffer (OVERLAY_START (overlay));
-#ifdef BOTH_OVERLAYS
- Lisp_Object obuffer2 = buffer_of_overlay (overlay);
- struct buffer *ob1 = XBUFFER (obuffer);
- struct buffer *ob2 = XBUFFER (obuffer2);
- eassert (ob1 == ob2);
-#endif
-#else
- obuffer = buffer_of_overlay (overlay);
-#endif
b = XBUFFER (buffer);
if (!NILP (obuffer))
{
ob = XBUFFER (obuffer);
-#ifndef NEW_OVERLAYS
+
o_beg = OVERLAY_POSITION (OVERLAY_START (overlay));
o_end = OVERLAY_POSITION (OVERLAY_END (overlay));
unchain_both (ob, overlay);
-#endif
-
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- old_start = XOVERLAY (overlay)->char_start;
- old_end = XOVERLAY (overlay)->char_end;
- overlay_tree_delete(&ob->overlays_root, XOVERLAY (overlay));
-#ifdef BOTH_OVERLAYS
- eassert (o_beg == old_start);
- eassert (o_end == old_end);
-#endif
-#endif
}
-#ifndef NEW_OVERLAYS
+
/* Set the overlay boundaries, which may clip them. */
Fset_marker (OVERLAY_START (overlay), beg, buffer);
Fset_marker (OVERLAY_END (overlay), end, buffer);
n_beg = marker_position (OVERLAY_START (overlay));
n_end = marker_position (OVERLAY_END (overlay));
-#endif
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- ptrdiff_t new_start = clip_to_bounds (BUF_BEG (b), XINT (beg),
- BUF_Z (b));
- ptrdiff_t new_end = clip_to_bounds(BUF_BEG (b), XINT (end),
- BUF_Z (b));
-#ifdef BOTH_OVERLAYS
- eassert (n_beg == new_start);
- eassert (n_end == new_end);
-#endif /* BPTH_OVERLAYS */
- XOVERLAY (overlay)->char_start = new_start;
- XOVERLAY (overlay)->char_end = new_end;
-#endif /* NEW_OVERLAYS || BOTH_OVERLAYS */
-
-#ifndef NEW_OVERLAYS
/* If the overlay has changed buffers, do a thorough redisplay. */
if (!EQ (buffer, obuffer))
{
/* Redisplay where the overlay was. */
if (ob)
modify_overlay (ob, o_beg, o_end);
+
/* Redisplay where the overlay is going to be. */
modify_overlay (b, n_beg, n_end);
}
@@ -4139,35 +3982,7 @@ buffer. */)
evaporate property. */
if (n_beg == n_end && !NILP (Foverlay_get (overlay, Qevaporate)))
return unbind_to (count, Fdelete_overlay (overlay));
-#else
- /* If the overlay has changed buffers, do a thorough redisplay. */
- if (!EQ (buffer, obuffer))
- {
- /* Redisplay where the overlay was. */
- if (ob)
- modify_overlay (ob, old_start, old_end);
- /* Redisplay where the overlay is going to be. */
- modify_overlay (b, new_start, new_end);
- }
- else
- /* Redisplay the area the overlay has just left, or just enclosed. */
- {
- if (old_start == new_start)
- modify_overlay (b, old_end, new_end);
- else if (old_end == new_end)
- modify_overlay (b, old_start, new_start);
- else
- modify_overlay (b, min (old_start, new_start),
- max (old_end, new_end));
- }
- /* Delete the overlay if it is empty after clipping and has the
- evaporate property. */
- if (new_start == new_end && !NILP (Foverlay_get (overlay, Qevaporate)))
- return unbind_to (count, Fdelete_overlay (overlay));
-#endif
-
-#ifndef NEW_OVERLAYS
/* Put the overlay into the new buffer's overlay lists, first on the
wrong list. */
if (n_end < b->overlay_center)
@@ -4183,9 +3998,7 @@ buffer. */)
/* This puts it in the right list, and in the right order. */
recenter_overlay_lists (b, b->overlay_center);
-#else
- insert_overlay_in_buffer_tree(b, overlay);
-#endif
+
return unbind_to (count, overlay);
}
@@ -4198,28 +4011,16 @@ DEFUN ("delete-overlay", Fdelete_overlay, Sdelete_overlay, 1, 1, 0,
ptrdiff_t count = SPECPDL_INDEX ();
CHECK_OVERLAY (overlay);
-#ifndef NEW_OVERLAYS
+
buffer = Fmarker_buffer (OVERLAY_START (overlay));
-#ifdef BOTH_OVERLAYS
- struct buffer *b1 = XBUFFER (buffer);
- struct buffer *b2 = XBUFFER (buffer_of_overlay (overlay));
- eassert (b1 == b2);
-#endif /* ifdef BOTH_OVERLAYS */
-#else
- buffer = buffer_of_overlay (overlay);
-#endif
if (NILP (buffer))
return Qnil;
b = XBUFFER (buffer);
specbind (Qinhibit_quit, Qt);
-#ifndef NEW_OVERLAYS
unchain_both (b, overlay);
drop_overlay (b, XOVERLAY (overlay));
-#else
- overlay_tree_delete(&b->overlays_root, XOVERLAY (overlay));
-#endif
/* When deleting an overlay with before or after strings, turn off
display optimizations for the affected buffer, on the basis that
@@ -4251,17 +4052,7 @@ DEFUN ("overlay-start", Foverlay_start, Soverlay_start, 1, 1, 0,
{
CHECK_OVERLAY (overlay);
-#ifdef NEW_OVERLAYS
- return make_number (XOVERLAY (overlay)->char_start);
-#else
-#ifdef BOTH_OVERLAYS
- Lisp_Object a[2];
- a[0] = make_number(XOVERLAY (overlay)->char_start);
- a[1] = Fmarker_position (OVERLAY_START (overlay));
- eassert (Feqlsign (2, a));
-#endif
- return Fmarker_position (OVERLAY_START (overlay));
-#endif
+ return (Fmarker_position (OVERLAY_START (overlay)));
}
DEFUN ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
@@ -4270,17 +4061,7 @@ DEFUN ("overlay-end", Foverlay_end, Soverlay_end, 1, 1, 0,
{
CHECK_OVERLAY (overlay);
-#ifdef NEW_OVERLAYS
- return make_number (XOVERLAY (overlay)->char_end);
-#else
-#ifdef BOTH_OVERLAYS
- Lisp_Object a[2];
- a[0] = make_number(XOVERLAY (overlay)->char_end);
- a[1] = Fmarker_position (OVERLAY_END (overlay));
- eassert (Feqlsign (2, a));
-#endif
- return Fmarker_position (OVERLAY_END (overlay));
-#endif
+ return (Fmarker_position (OVERLAY_END (overlay)));
}
DEFUN ("overlay-buffer", Foverlay_buffer, Soverlay_buffer, 1, 1, 0,
@@ -4290,17 +4071,7 @@ Return nil if OVERLAY has been deleted. */)
{
CHECK_OVERLAY (overlay);
-#ifdef NEW_OVERLAYS
- return buffer_of_overlay (overlay);
-#else
-#ifdef BOTH_OVERLAYS
- struct buffer *b1, *b2;
- b1 = XBUFFER (buffer_of_overlay (overlay));
- b2 = XBUFFER (Fmarker_buffer(OVERLAY_START (overlay)));
- eassert (b1 == b2);
-#endif
return Fmarker_buffer (OVERLAY_START (overlay));
-#endif
}
DEFUN ("overlay-properties", Foverlay_properties, Soverlay_properties, 1, 1, 0,
@@ -4470,7 +4241,6 @@ The lists you get are copies, so that changing them has no effect.
However, the overlays you get are the real objects that the buffer uses. */)
(void)
{
-#ifndef NEW_OVERLAYS
struct Lisp_Overlay *ol;
Lisp_Object before = Qnil, after = Qnil, tmp;
@@ -4486,9 +4256,6 @@ However, the overlays you get are the real objects that the buffer uses. */)
}
return Fcons (Fnreverse (before), Fnreverse (after));
-#else
- return Qnil;
-#endif
}
DEFUN ("overlay-recenter", Foverlay_recenter, Soverlay_recenter, 1, 1, 0,
@@ -4497,13 +4264,11 @@ That makes overlay lookup faster for positions near POS (but perhaps slower
for positions far away from POS). */)
(Lisp_Object pos)
{
-#ifndef NEW_OVERLAYS
ptrdiff_t p;
CHECK_NUMBER_COERCE_MARKER (pos);
p = clip_to_bounds (PTRDIFF_MIN, XINT (pos), PTRDIFF_MAX);
recenter_overlay_lists (current_buffer, p);
-#endif
return Qnil;
}
@@ -5376,13 +5141,9 @@ init_buffer_once (void)
bset_mark_active (&buffer_defaults, Qnil);
bset_file_format (&buffer_defaults, Qnil);
bset_auto_save_file_format (&buffer_defaults, Qt);
-#ifndef NEW_OVERLAYS
set_buffer_overlays_before (&buffer_defaults, NULL);
set_buffer_overlays_after (&buffer_defaults, NULL);
buffer_defaults.overlay_center = BEG;
-#else
- buffer_defaults.overlays_root = OVERLAYS_SENTINEL;
-#endif
XSETFASTINT (BVAR (&buffer_defaults, tab_width), 8);
bset_truncate_lines (&buffer_defaults, Qnil);
diff --git a/src/buffer.h b/src/buffer.h
index 9b2d887..87b7cee 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -27,10 +27,6 @@ along with GNU Emacs. If not, see . */
#include "character.h"
#include "lisp.h"
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
-extern struct Lisp_Overlay *OVERLAY_SENTINEL;
-#endif
-
INLINE_HEADER_BEGIN
/* Accessing the parameters of the current buffer. */
@@ -866,7 +862,6 @@ struct buffer
/* Non-zero whenever the narrowing is changed in this buffer. */
bool_bf clip_changed : 1;
-#ifndef NEW_OVERLAYS
/* List of overlays that end at or before the current center,
in order of end-position. */
struct Lisp_Overlay *overlays_before;
@@ -877,11 +872,7 @@ struct buffer
/* Position where the overlay lists are centered. */
ptrdiff_t overlay_center;
-#endif
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- struct Lisp_Overlay *overlays_root;
-#endif
/* Changes in the buffer are recorded here for undo, and t means
don't record anything. This information belongs to the base
buffer of an indirect buffer. But we can't store it in the
@@ -1186,17 +1177,7 @@ set_buffer_intervals (struct buffer *b, INTERVAL i)
INLINE bool
buffer_has_overlays (void)
{
-#ifdef NEW_OVERLAYS
- bool ret = current_buffer->overlays_root != OVERLAY_SENTINEL;
-#else
- bool ret = current_buffer->overlays_before ||
- current_buffer->overlays_after;
-#ifdef BOTH_OVERLAYS
- eassert (ret == (current_buffer->overlays_root !=
- OVERLAY_SENTINEL));
-#endif
-#endif
- return ret;
+ return current_buffer->overlays_before || current_buffer->overlays_after;
}
/* Return character code of multi-byte form at byte position POS. If POS
@@ -1245,7 +1226,6 @@ buffer_window_count (struct buffer *b)
return b->window_count;
}
-#ifndef NEW_OVERLAYS
/* Overlays */
/* Return the marker that stands for where OV starts in the buffer. */
@@ -1266,7 +1246,6 @@ buffer_window_count (struct buffer *b)
#define OVERLAY_POSITION(P) \
(MARKERP (P) ? marker_position (P) : (emacs_abort (), 0))
-#endif
/***********************************************************************
Buffer-local Variables
diff --git a/src/deps.mk b/src/deps.mk
index c6469e6..72f68ca 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -40,8 +40,7 @@ bidi.o:
globals.h $(config_h)
buffer.o: buffer.c buffer.h region-cache.h commands.h window.h \
$(INTERVALS_H) blockinput.h atimer.h systime.h character.h ../lib/unistd.h \
- indent.h keyboard.h coding.h keymap.h frame.h lisp.h globals.h
- $(config_h) $(OVERLAYS_H)
+ indent.h keyboard.h coding.h keymap.h frame.h lisp.h globals.h $(config_h)
callint.o: callint.c window.h commands.h buffer.h keymap.h globals.h msdos.h \
keyboard.h dispextern.h systime.h coding.h composite.h lisp.h \
character.h $(config_h)
diff --git a/src/emacs.c b/src/emacs.c
index 9a85213..bb85733 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1425,7 +1425,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
syms_of_floatfns ();
syms_of_buffer ();
- syms_of_overlays ();
syms_of_bytecode ();
syms_of_callint ();
syms_of_casefiddle ();
diff --git a/src/insdel.c b/src/insdel.c
index e844274..4ad1074 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -27,7 +27,6 @@ along with GNU Emacs. If not, see . */
#include "intervals.h"
#include "character.h"
#include "buffer.h"
-#include "overlays.h"
#include "window.h"
#include "region-cache.h"
@@ -841,10 +840,6 @@ insert_1_both (const char *string,
PT + nchars, PT_BYTE + nbytes,
before_markers);
- overlay_tree_adjust_for_insert(current_buffer->overlays_root, PT, PT
- + nchars, PT_BYTE, PT_BYTE + nbytes,
- before_markers);
-
offset_intervals (current_buffer, PT, nchars);
if (!inherit && buffer_intervals (current_buffer))
@@ -971,12 +966,6 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
PT_BYTE + outgoing_nbytes,
before_markers);
- overlay_tree_adjust_for_insert(current_buffer->overlays_root, PT,
- PT + nchars, PT_BYTE,
- PT_BYTE + outgoing_nbytes,
- before_markers);
-
-
offset_intervals (current_buffer, PT, nchars);
intervals = string_intervals (string);
@@ -1031,12 +1020,6 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes, bool text_at_gap_tail)
adjust_markers_for_insert (ins_charpos, ins_bytepos,
ins_charpos + nchars, ins_bytepos + nbytes, 0);
- overlay_tree_adjust_for_insert(current_buffer->overlays_root,
- ins_charpos, ins_charpos + nchars
- , ins_bytepos, ins_bytepos + nbytes,
- 0);
-
-
if (buffer_intervals (current_buffer))
{
offset_intervals (current_buffer, ins_charpos, nchars);
@@ -1180,11 +1163,6 @@ insert_from_buffer_1 (struct buffer *buf,
PT_BYTE + outgoing_nbytes,
0);
- overlay_tree_adjust_for_insert(current_buffer->overlays_root, PT, PT
- + nchars, PT_BYTE,
- PT_BYTE + outgoing_nbytes, 0);
-
-
offset_intervals (current_buffer, PT, nchars);
/* Get the intervals for the part of the string we are inserting. */
@@ -1235,22 +1213,11 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
if (GAP_SIZE > 0) *(GPT_ADDR) = 0; /* Put an anchor. */
if (nchars_del > 0)
- {
- adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
- len, len_byte);
- overlay_tree_adjust_for_replace(current_buffer->overlays_root,
- from, from_byte, nchars_del,
- nbytes_del, len, len_byte);
- }
+ adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
+ len, len_byte);
else
- {
- adjust_markers_for_insert (from, from_byte,
- from + len, from_byte + len_byte, 0);
- overlay_tree_adjust_for_insert(current_buffer->overlays_root,
- from, from + len, from_byte,
- from_byte + len_byte, 0);
- }
-
+ adjust_markers_for_insert (from, from_byte,
+ from + len, from_byte + len_byte, 0);
if (nchars_del > 0)
record_delete (from, prev_text, false);
@@ -1428,14 +1395,8 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
/* Adjust markers for the deletion and the insertion. */
if (markers)
- {
- adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
- inschars, outgoing_insbytes);
- overlay_tree_adjust_for_replace (current_buffer->overlays_root,
- from, from_byte, nchars_del,
- nbytes_del, inschars,
- outgoing_insbytes);
- }
+ adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
+ inschars, outgoing_insbytes);
/* Adjust the overlay center as needed. This must be done after
adjusting the markers that bound the overlays. */
@@ -1549,15 +1510,9 @@ replace_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
/* Adjust markers for the deletion and the insertion. */
if (markers
- && ! (nchars_del == 1 && inschars == 1 && nbytes_del ==
- insbytes))
- {
- adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
- inschars, insbytes);
- overlay_tree_adjust_for_replace (current_buffer->overlays_root,
- from, from_byte, nchars_del,
- nbytes_del, inschars, insbytes);
- }
+ && ! (nchars_del == 1 && inschars == 1 && nbytes_del == insbytes))
+ adjust_markers_for_replace (from, from_byte, nchars_del, nbytes_del,
+ inschars, insbytes);
/* Adjust the overlay center as needed. This must be done after
adjusting the markers that bound the overlays. */
@@ -1759,8 +1714,6 @@ del_range_2 (ptrdiff_t from, ptrdiff_t from_byte,
/* Relocate all markers pointing into the new, larger gap to point
at the end of the text before the gap. */
adjust_markers_for_delete (from, from_byte, to, to_byte);
- overlay_tree_adjust_for_delete(current_buffer->overlays_root, from,
- from_byte, to, to_byte);
MODIFF++;
CHARS_MODIFF = MODIFF;
diff --git a/src/lisp.h b/src/lisp.h
index d5cbec6..e0eb52a 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2112,30 +2112,11 @@ struct Lisp_Overlay
{
ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Overlay */
bool_bf gcmarkbit : 1;
-
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- bool_bf start_insertion_type : 1;
- bool_bf end_insertion_type : 1;
- unsigned spacer : 13;
-#else
unsigned spacer : 15;
-#endif
-
struct Lisp_Overlay *next;
Lisp_Object start;
Lisp_Object end;
Lisp_Object plist;
-
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
- ptrdiff_t char_start, char_end;
- ptrdiff_t byte_start, byte_end;
- ptrdiff_t max;
-
- /* For the tree. */
- Lisp_Object parent; /* buffer or parent node */
- struct Lisp_Overlay *left, *right;
- unsigned level;
-#endif
};
/* Types of data which may be saved in a Lisp_Save_Value. */
@@ -3984,10 +3965,7 @@ extern void adjust_overlays_for_insert (ptrdiff_t, ptrdiff_t);
extern void adjust_overlays_for_delete (ptrdiff_t, ptrdiff_t);
extern void fix_start_end_in_overlays (ptrdiff_t, ptrdiff_t);
extern void report_overlay_modification (Lisp_Object, Lisp_Object, bool,
- Lisp_Object, Lisp_Object,
- Lisp_Object);
-
-
+ Lisp_Object, Lisp_Object, Lisp_Object);
extern bool overlay_touches_p (ptrdiff_t);
extern Lisp_Object other_buffer_safely (Lisp_Object);
extern Lisp_Object get_truename_buffer (Lisp_Object);
@@ -3996,10 +3974,6 @@ extern void init_buffer (int);
extern void syms_of_buffer (void);
extern void keys_of_buffer (void);
-/* Defined in overlay.c */
-
-extern void syms_of_overlays(void);
-
/* Defined in marker.c. */
extern ptrdiff_t marker_position (Lisp_Object);
diff --git a/src/overlays.c b/src/overlays.c
deleted file mode 100644
index c60a887..0000000
--- a/src/overlays.c
+++ /dev/null
@@ -1,800 +0,0 @@
-/*
- * Copyright (C) 2016 Joakim Jalap
- *
- * This program 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 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-
-/* This file implements an Arne Andersson-tree (AA-tree) for buffer
- overlays. It is an augmented interval tree. Basically each node
- has an interval and a 'max' value, which is the largest upper
- interval bound which appears in the subtree rooted in the node.
-
- The implementation of the tree functions is written as closely as
- possible to the one presented in Anderssons paper (REF)[1], but with a
- few differences. The code in [1] is written in Pascal, which has
- proper pass by reference. Unfortunately C doesn't really have this;
- this is the reason for passing around pointers to pointers.
-
- Also this tree has parent references, and the code in the delete
- routine is a bit more complicated because we need to delete the
- actual memory area, so as to not trip up the GC.
-
- The fact that this is an augmented tree also makes the rebalancing
- operation (split and skew) a bit more complex.
- */
-#include "overlays.h"
-#include "buffer.h"
-
-extern void
-modify_overlay (struct buffer *, ptrdiff_t, ptrdiff_t);
-
-/* Return the max of a, b and c. */
-static inline ptrdiff_t
-overlay_max (ptrdiff_t a, ptrdiff_t b, ptrdiff_t c)
-{
- ptrdiff_t bc_max = max(b, c);
- return max(a, bc_max);
-}
-
-/* Find what the max value should be for X. */
-static inline ptrdiff_t
-overlay_find_max (struct Lisp_Overlay *x)
-{
- return overlay_max(x->left->max, x->right->max, x->char_end);
-}
-
-/* The sentinel node. This indicates the bottom of the tree. It is
- basically a way to avoid having to check for NULL pointers all the
- time. */
-struct Lisp_Overlay OVERLAY_SENTINEL_NODE =
- {
- Lisp_Misc_Overlay, /* type */
- 1, /* gcmarkbit */
- 0, /* start_insertion_type */
- 0, /* end_insertion_type */
- 0, /* spacer */
- NULL, /* next */
- 0, /* start */
- 0, /* end */
- 0, /* plist */
- 0, /* char_start */
- 0, /* char_end */
- 0, /* byte_start */
- 0, /* byte_end */
- 0, /* max */
- 0, /* parent */
- &OVERLAY_SENTINEL_NODE, /* left */
- &OVERLAY_SENTINEL_NODE, /* right */
- 0 /* level */
- };
-
-struct Lisp_Overlay * OVERLAY_SENTINEL = &OVERLAY_SENTINEL_NODE;
-
-/* This function determines where overlays are inserted in the tree.
- FIXME: I didn't think too hard about this...
-*/
-static inline bool
-overlay_lt (struct Lisp_Overlay *a, struct Lisp_Overlay *b)
-{
- if (a->char_start < b->char_start)
- return true;
- else if (a->char_start > b->char_start)
- return false;
-
- if (a->char_end < b->char_end)
- return true;
- else if (a->char_end > b->char_end)
- return false;
-
- return false;
-}
-
-/* Rebalancing. See Andersson's paper for a good explaination. This
- is a bit more complicated than his code, since we need to maintain
- parent pointer and max field.
-*/
-inline static void
-overlay_skew (struct Lisp_Overlay **tt)
-{
- struct Lisp_Overlay *t = *tt;
- if (t->left->level == t->level && t != OVERLAY_SENTINEL)
- {
- struct Lisp_Overlay *tmp = t;
- t = *tt = t->left;
- tmp->left = t->right;
- t->right = tmp;
-
- tmp->max = overlay_find_max(tmp);
- t->max = overlay_find_max(t);
-
- t->parent = tmp->parent;
- XSETMISC (tmp->parent, t);
- if (tmp->left != OVERLAY_SENTINEL)
- XSETMISC (tmp->left->parent, tmp);
- }
-}
-
-/* Rebalancing. See Andersson's paper for a good explaination. This
- is a bit more complicated than his code, since we need to maintain
- parent pointer and max field.
-*/
-inline static void
-overlay_split (struct Lisp_Overlay **tt)
-{
- struct Lisp_Overlay *t = *tt;
- if (t->level == t->right->right->level && t != OVERLAY_SENTINEL)
- {
- struct Lisp_Overlay *tmp = t;
- t = *tt = t->right;
- tmp->right = t->left;
- t->left = tmp;
- t->level++;
-
- tmp->max = overlay_find_max(tmp);
- t->max = overlay_find_max(t);
-
- t->parent = tmp->parent;
- XSETMISC (tmp->parent, t);
- }
-}
-
-/* Insert NODE in TREE. When it is inserted, set its parent to
- PARENT. On the way up after the insertion, adjust the max field of
- each node if needed.
- */
-static ptrdiff_t
-overlay_tree_insert_internal (struct Lisp_Overlay **tree,
- struct Lisp_Overlay *parent,
- struct Lisp_Overlay *node)
-{
- struct Lisp_Overlay *t = *tree;
- if (t == OVERLAY_SENTINEL)
- {
- node->left = node->right = OVERLAY_SENTINEL;
- node->level = 1;
- node->max = node->char_end;
- XSETMISC (node->parent, parent);
- *tree = node;
- return node->max;
- }
- else
- {
- struct Lisp_Overlay **dir = overlay_lt (node, t) ?
- &t->left : &t->right;
-
- ptrdiff_t child_max = overlay_tree_insert_internal(dir, t, node);
- if (child_max > t->max)
- t->max = child_max;
- }
- overlay_skew (&t);
- overlay_split (&t);
- return t->max;
-}
-
-/* Insert NODE into TREE.
- */
-void
-overlay_tree_insert (struct Lisp_Overlay **tree,
- struct Lisp_Overlay *node)
-{
- overlay_tree_insert_internal(tree, *tree, node);
-}
-
-/* Delete NODE from TREE.
- */
-void
-overlay_tree_delete (struct Lisp_Overlay **tree,
- struct Lisp_Overlay *node)
-{
- struct Lisp_Overlay *t = *tree;
- static __thread struct Lisp_Overlay *last, *deleted;
-
- if (t == OVERLAY_SENTINEL)
- return;
-
- last = t;
- if (overlay_lt(node, t))
- overlay_tree_delete (&t->left, node);
- else
- {
- deleted = t;
- overlay_tree_delete (&t->right, node);
- }
-
-
- if (t == last &&
- deleted != OVERLAY_SENTINEL &&
- node == deleted)
- {
- last->left = deleted->left;
- last->right = deleted->right;
-
- if (BUFFERP (deleted->parent))
- {
- struct buffer *b = XBUFFER (deleted->parent);
- if (last == deleted)
- {
- b->overlays_root = OVERLAY_SENTINEL;
- }
- else
- {
- b->overlays_root = last;
- last->parent = deleted->parent;
- }
- }
- else
- {
- eassert (OVERLAYP (deleted->parent));
- struct Lisp_Overlay *up = XOVERLAY (deleted->parent);
- eassert (up->left == deleted || up->right == deleted);
- if (up->left == deleted)
- up->left = last == deleted ? OVERLAY_SENTINEL
- : last;
- else
- up->right = last == deleted ? OVERLAY_SENTINEL
- : last;
-
- XSETMISC (last->parent, up);
- }
- deleted->parent = Qnil;
- }
- else if (t->left->level < t->level - 1
- || t->right->level < t->level - 1)
- {
- t->level--;
- if (t->right->level > t->level)
- t->right->level = t->level;
-
- /* Andersson leaves it as 'an exercise for the reader' to prove
- that these rebalancing operions are enough. Don't you just love
- when that happens? */
- overlay_skew (&t);
- overlay_skew (&t->right);
- overlay_skew (&t->right->right);
- overlay_split (&t);
- overlay_split (&t->right);
- }
-}
-
-static void
-overlay_tree_drop_all_internal (struct buffer *buf,
- struct Lisp_Overlay *tree)
-{
- if (tree == OVERLAY_SENTINEL)
- return;
- overlay_tree_drop_all_internal (buf, tree->left);
- overlay_tree_drop_all_internal (buf, tree->right);
- modify_overlay (buf, tree->char_start, tree->char_end);
-}
-
-void
-overlay_tree_drop_all(struct buffer *buf)
-{
- overlay_tree_drop_all_internal (buf, buf->overlays_root);
- buf->overlays_root = OVERLAY_SENTINEL;
-}
-
-/* Add ELM to VECP at IDX. VECP has size VEC_SIZE. If IDX is at the
- end of VECP, realloc VECP and update VEC_SIZE.
- */
-static inline void
-add_to_vec (ptrdiff_t *vec_size, Lisp_Object **vecp,
- ptrdiff_t* idx, struct Lisp_Overlay *elm)
-{
- if (*idx == *vec_size - 1)
- {
- *vec_size += 50;
- *vecp = xnrealloc (*vecp, *vec_size, sizeof (Lisp_Object));
- }
-
- XSETMISC((*vecp)[(*idx)++], elm);
-}
-
-
-/* Add all nodes in TREE to VEC_PTR, which has size VEC_SIZE, starting
- from IDX. The nodes will be added in the order they have in the
- tree.
- */
-static void
-overlay_tree_all_internal (struct Lisp_Overlay *tree,
- ptrdiff_t *vec_size,
- Lisp_Object **vec_ptr,
- ptrdiff_t *idx)
-{
- if (tree == OVERLAY_SENTINEL)
- return;
-
- overlay_tree_all_internal (tree->left, vec_size,
- vec_ptr, idx);
- add_to_vec (vec_size, vec_ptr, idx, tree);
- overlay_tree_all_internal (tree->right, vec_size,
- vec_ptr, idx);
-}
-
-/* Put all nodes from TREE into VEC_PTR, adjusting VEC_SIZE as
- necessary.
- */
-ptrdiff_t
-overlay_tree_all (struct Lisp_Overlay *tree, ptrdiff_t *vec_size,
- Lisp_Object **vec_ptr)
-{
- ptrdiff_t n = 0;
- overlay_tree_all_internal (tree, vec_size, vec_ptr, &n);
- return n;
-}
-
-/* Add all nodes in TREE which contain POS to VEC_PTR at IDX.
- VEC_SIZE will be adjusted.
- */
-static void
-overlay_tree_at_internal (struct Lisp_Overlay *tree, ptrdiff_t pos,
- ptrdiff_t *vec_size, Lisp_Object **vec_ptr,
- ptrdiff_t *idx, ptrdiff_t *prev_ptr)
-{
- /* We are at a leaf. */
- if (tree == OVERLAY_SENTINEL)
- return;
-
- /* There's no subtree under here which can contain POS. Note
- tree->max, as this might be the closest before. */
- if (tree->max < pos)
- {
- if (tree->max > *prev_ptr)
- *prev_ptr = tree->max;
- return;
- }
-
-
- overlay_tree_at_internal (tree->left, pos, vec_size, vec_ptr,
- idx, prev_ptr);
-
- if (pos >= tree->char_start && pos <= tree->char_end)
- add_to_vec (vec_size, vec_ptr, idx, tree);
-
- /* If we are after POS, so are all the nodes to the right of us. */
- if (tree->char_start <= pos)
- overlay_tree_at_internal (tree->right, pos, vec_size, vec_ptr,
- idx, prev_ptr);
-}
-
-
-/* Find all nodes in TREE which contain POS and put them in VEC_PTR,
- growing it as necessary. The size of the vector VEC_PTR will be
- stored in VEC_SIZE. Return how many nodes were actually put in
- VEC_PTR.
- */
-ptrdiff_t
-overlay_tree_at (struct Lisp_Overlay *tree, ptrdiff_t pos,
- ptrdiff_t *next_ptr, ptrdiff_t *prev_ptr,
- ptrdiff_t *vec_size, Lisp_Object **vec_ptr,
- bool chane_req)
-{
- ptrdiff_t idx = 0;
- ptrdiff_t max_before = 0;
-
- /* Due to the recursion order in `overlay_tree_at_internal' the
- overlays are sorted by their `char_start' in VEC_PTR. */
- overlay_tree_at_internal (tree, pos, vec_size, vec_ptr,
- &idx, &max_before);
-
- if (prev_ptr && max_before)
- *prev_ptr = max_before;
- else
- *prev_ptr = BEGV;
-
- /* If NEXT_PTR is not NULL, it should be set to the start_char of
- the leftmost descendant of the right child of the last element in
- VEC_PTR, or ZV if the right child is OVERLAY_SENTINEL. */
- if (next_ptr && idx)
- {
- struct Lisp_Overlay *last = XOVERLAY ((*vec_ptr)[idx - 1]);
- if (last->right != OVERLAY_SENTINEL)
- {
- last = last->right;
- while (last->left != OVERLAY_SENTINEL)
- last = last->left;
- *next_ptr = last->char_start;
- }
- else
- *next_ptr = ZV;
- }
-
- /* IDX points one behind the last element, so it is the size */
- return idx;
-}
-
-static inline void
-add_entry_to_vec (ptrdiff_t *vec_size, struct overlay_entry **vecp,
- ptrdiff_t* idx, Lisp_Object overlay,
- Lisp_Object str, bool after_p)
-{
- if (*idx == *vec_size - 1)
- {
- *vec_size += 50;
- *vecp = xnrealloc (*vecp, *vec_size,
- sizeof (struct overlay_entry));
- }
-
- Lisp_Object priority = Foverlay_get ((OVERLAY), Qpriority);
- EMACS_INT prio = INTEGERP (priority) ? XINT (priority) : 0;
-
-#define SET_ENTRY(ENT, ELM) (*vecp)[*idx].ENT = (ELM)
- SET_ENTRY(string, str);
- SET_ENTRY(overlay, overlay);
- SET_ENTRY(priority, prio);
- SET_ENTRY(after_string, after_p);
-#undef SET_ENTRY
-
- (*idx)++;
-}
-
-ptrdiff_t
-overlay_tree_load_overlays (struct Lisp_Overlay *tree, ptrdiff_t pos,
- ptrdiff_t *vec_size, ptrdiff_t **vec_ptr,
- ptridff_t *idx, struct window *w)
-{
- Lisp_Object window, invisible, str, ov;
- int invis;
-
- eassert (*idx == 0);
-
- if (tree == OVERLAY_SENTINEL || tree->max > pos)
- return;
-
- if (tree->char_start != pos && tree->char_end != pos)
- goto cont;
-
- window = lookup_char_property (tree->plist, Qwindow, 0);
- if (WINDOWP (window) && XWINDOW (window) != it->w)
- goto cont;
-
- invisible = lookup_char_property (tree->plist, Qinvisible, 0);
- invis = TEXT_PROP_MEANS_INVISIBLE (invisible);
-
- if ((tree->char_start == pos || (tree->char_end == pos && invis))
- && (str = lookup_char_property (tree->plist, Qbefore_string, 0),
- STRINGP (str))
- && SCHARS (str))
- {
- XSETMISC (ov, tree);
- add_entry_to_vec(vec_size, vec_ptr, idx, ov, str, false);
- }
-
- if ((tree->char_end == pos || (tree->char_start == pos && invis))
- && (str = lookup_char_property (tree->plist, Qafter_string, 0),
- STRINGP (str))
- && SCHARS (str))
- {
- XSETMISC (ov, tree);
- add_entry_to_vec(vec_size, vec_ptr, idx, ov, str, true);
- }
-
-
- cont:
- overlay_tree_load_overlays(tree->left, pos, vec_size, vec_ptr, w);
- if (tree->char_start <= pos)
- overlay_tree_load_overlays(tree->right, pos, vec_size, vec_ptr, w);
-}
-
-/* Return the buffer OVERLAY is in or nil if OVERLAY has been
- deleted. */
-Lisp_Object
-buffer_of_overlay (Lisp_Object overlay)
-{
- Lisp_Object o = overlay;
- while (!NILP (XOVERLAY (o)->parent) &&
- !BUFFERP (XOVERLAY (o)->parent))
- {
- eassert (OVERLAYP (XOVERLAY (o)->parent));
- eassert (XOVERLAY (XOVERLAY (o)->parent) != XOVERLAY (o));
-
- o = XOVERLAY (o)->parent;
- }
- return XOVERLAY (o)->parent;
-}
-
-void
-overlay_tree_zero_size_at (struct Lisp_Overlay *tree, ptrdiff_t pos,
- Lisp_Object hit_list)
-{
- if (tree == OVERLAY_SENTINEL || tree->max < pos)
- return;
-
- if (tree->char_start == pos && tree->char_end == pos)
- {
- Lisp_Object ov;
- XSETMISC (ov, tree);
- Fcons(hit_list, ov);
- }
-
- overlay_tree_zero_size_at (tree->right, pos, hit_list);
- if (pos >= tree->char_start)
- overlay_tree_zero_size_at (tree->left, pos, hit_list);
-}
-
-/* Adjust CHARPOS asn BYTEPOS for an insert from FROM_CHAR (FROM_BYTE)
- to TO_CHAR (TO_BYTE).
- FIXME: insertion_type and before.
- */
-static void
-adjust_pos_for_insert (ptrdiff_t *charpos, ptrdiff_t *bytepos,
- ptrdiff_t from_char, ptrdiff_t to_char,
- ptrdiff_t from_byte, ptrdiff_t to_byte,
- bool insertion_type , bool before)
-{
- if (*bytepos > from_byte)
- {
- *bytepos += to_byte - from_byte;
- *charpos += to_char - from_char;
- }
- else if (*bytepos == from_byte && insertion_type)
- {
- *bytepos = to_byte;
- *charpos = to_char;
- }
-}
-
-/* Adjust all nodes in TREE for an insert from FROM_CHAR (FROM_BYTE)
- to TO_CHAR (TO_BYTE). Return TREEs max.
- FIXME: before.
- */
-ptrdiff_t
-overlay_tree_adjust_for_insert (struct Lisp_Overlay *tree,
- ptrdiff_t from_char,
- ptrdiff_t to_char,
- ptrdiff_t from_byte,
- ptrdiff_t to_byte,
- bool before)
-{
- /* If we are at a leaf or all nodes in TREE are before the insert,
- return. */
- if (tree == OVERLAY_SENTINEL || tree->max < from_char)
- return tree->max;
-
- /* Adjust the start postions. */
- adjust_pos_for_insert(&tree->char_start, &tree->byte_start, from_char,
- to_char, from_byte, to_byte,
- tree->start_insertion_type, before);
- /* Adjust the end postions. */
- adjust_pos_for_insert(&tree->char_end, &tree->byte_end, from_char,
- to_char, from_byte, to_byte,
- tree->end_insertion_type, before);
-
- ptrdiff_t r,l;
-
- l = overlay_tree_adjust_for_insert (tree->left, from_char,
- to_char, from_byte,
- to_byte, before);
- r = overlay_tree_adjust_for_insert (tree->right, from_char,
- to_char, from_byte,
- to_byte, before);
-
- tree->max = overlay_max(l, r, tree->char_end);
- return tree->max;
-}
-
-/* Adjust CHARPOS and BYTEPOS for a delete from FROM_CHAR (FROM_BYTE)
- to TO_CHAR (TO_BYTE).
- */
-static void
-adjust_pos_for_delete (ptrdiff_t *charpos, ptrdiff_t *bytepos,
- ptrdiff_t from_char, ptrdiff_t from_byte,
- ptrdiff_t to_char, ptrdiff_t to_byte)
-{
- if (*charpos > to_char)
- {
- *charpos = to_char - from_char;
- *bytepos = to_byte - from_byte;
- }
- else if (*charpos > from_char)
- {
- *charpos = from_char;
- *bytepos = from_byte;
- }
-}
-
-/* Adjust TREE for a delete from FROM_CHAR (FROM_BYTE) to TO_CHAR
- (TO_BYTE).
- */
-ptrdiff_t
-overlay_tree_adjust_for_delete (struct Lisp_Overlay *tree,
- ptrdiff_t from_char, ptrdiff_t from_byte,
- ptrdiff_t to_char, ptrdiff_t to_byte)
-{
- if (tree == OVERLAY_SENTINEL || tree->max < from_char)
- return tree->max;
-
- adjust_pos_for_delete(&tree->char_start, &tree->byte_start, from_char,
- from_byte, to_char, to_byte);
- adjust_pos_for_delete(&tree->char_end, &tree->byte_end, from_char,
- from_byte, to_char, to_byte);
-
- ptrdiff_t r, l;
-
- l = overlay_tree_adjust_for_delete(tree->left, from_char, from_byte,
- to_char, to_byte);
- r = overlay_tree_adjust_for_delete(tree->right, from_char, from_byte,
- to_char, to_byte);
-
- tree->max = overlay_max(l, r, tree->char_end);
- return tree->max;
-}
-
-/* Adjust CHARPOS and BYTEPOS for a delete from FROM_CHAR (FROM_BYTE)
- to TO_CHAR (TO_BYTE).
- */
-static void
-adjust_pos_for_replace (ptrdiff_t *charpos, ptrdiff_t *bytepos,
- ptrdiff_t from_char, ptrdiff_t from_byte,
- ptrdiff_t old_chars, ptrdiff_t old_bytes,
- ptrdiff_t new_chars, ptrdiff_t new_bytes)
-{
- ptrdiff_t diff_chars = new_chars - old_chars;
- ptrdiff_t diff_bytes = new_bytes - old_bytes;
-
- if (*bytepos >= (from_byte + old_bytes))
- {
- *charpos += diff_chars;
- *bytepos += diff_bytes;
- }
- else if (*bytepos > from_byte)
- {
- *charpos = from_char;
- *bytepos = from_byte;
- }
-}
-
-/* Adjust TREE for a delete from FROM_CHAR (FROM_BYTE)
- to TO_CHAR (TO_BYTE).
- */
-ptrdiff_t
-overlay_tree_adjust_for_replace (struct Lisp_Overlay *tree,
- ptrdiff_t from_char,
- ptrdiff_t from_byte,
- ptrdiff_t old_chars,
- ptrdiff_t old_bytes,
- ptrdiff_t new_chars,
- ptrdiff_t new_bytes)
-{
- if (tree == OVERLAY_SENTINEL || tree->max <= from_byte)
- return tree->max;
-
- adjust_pos_for_replace(&tree->char_start, &tree->byte_start,
- from_char, from_byte, old_chars, old_bytes,
- new_chars, new_bytes);
- adjust_pos_for_replace(&tree->char_end, &tree->byte_end,
- from_char, from_byte, old_chars, old_bytes,
- new_chars, new_bytes);
-
- ptrdiff_t r, l;
-
- l = overlay_tree_adjust_for_replace(tree->left, from_char,
- from_byte, old_chars,
- old_bytes, new_chars,
- new_bytes);
- r = overlay_tree_adjust_for_replace(tree->right, from_char,
- from_byte, old_chars,
- old_bytes, new_chars,
- new_bytes);
-
- tree->max = overlay_max(l, r, tree->char_end);
- return tree->max;
-}
-
-
-DEFUN("overlay-parent", Foverlay_parent, Soverlay_parent, 1, 1, 0,
- doc: /* Parent of overlay. An overlay or a buffer. */)
- (Lisp_Object overlay)
-{
- if (!OVERLAYP(overlay))
- signal_error("Not an overlay", Qnil);
- return XOVERLAY (overlay)->parent;
-}
-
-DEFUN("overlay-info", Foverlay_info, Soverlay_info, 1, 1, 0,
- doc: /* Info about OVERLAY. */)
- (Lisp_Object overlay)
-{
- if (!OVERLAYP(overlay))
- signal_error("Not an overlay", Qnil);
- Lisp_Object ret;
- struct Lisp_Overlay *o = XOVERLAY (overlay);
- Lisp_Object left, right, this;
- if (o->left != OVERLAY_SENTINEL)
- XSETMISC(left, o->left);
- else
- left = Qt;
-
- if (o->right != OVERLAY_SENTINEL)
- XSETMISC(right, o->right);
- else
- right = Qt;
-
- XSETMISC (this, o);
-
- ret = list5(Fcons(Fcons(make_number(o->char_start),
- make_number(o->char_end)),
- make_number(o->max)),
- this,
- o->parent,
- make_number (o->level),
- Fcons(left,
- right));
- return ret;
-}
-
-DEFUN("overlays-in-buffer", Foverlays_in_buffer, Soverlays_in_buffer,
- 0, 1, 0,
- doc: /* Return a list of all the overlays in BUFFER. */)
- (Lisp_Object buffer)
-{
- Lisp_Object ret;
- struct buffer *b;
- if (!NILP (buffer))
- b = XBUFFER (buffer);
- else
- b = current_buffer;
-
-
- ptrdiff_t vec_size = 30;
- Lisp_Object *vec = xnmalloc (vec_size, sizeof (Lisp_Object));
-
-
- ptrdiff_t noverlays = overlay_tree_all(b->overlays_root,
- &vec_size, &vec);
- ret = Flist(noverlays, vec);
-
- return ret;
-}
-
-DEFUN("overlay-tree-at", Foverlay_tree_at, Soverlay_tree_at,
- 1, 2, 0,
- doc: /* Return a list of all overlays in BUFFER. If BUFFER is
- nil, use the current buffer. */)
- (Lisp_Object pos, Lisp_Object buffer)
-{
- CHECK_NUMBER_COERCE_MARKER (pos);
-
- ptrdiff_t next, prev;
- ptrdiff_t bufpos = XINT (pos);
-
- Lisp_Object ret;
- struct buffer *b;
- if (!NILP (buffer))
- b = XBUFFER (buffer);
- else
- b = current_buffer;
-
-
- ptrdiff_t vec_size = 30;
- Lisp_Object *vec = xnmalloc (vec_size, sizeof (Lisp_Object));
-
-
- ptrdiff_t noverlays = overlay_tree_at(b->overlays_root, bufpos,
- &next, &prev,
- &vec_size, &vec, false);
-
- ret = Flist(noverlays, vec);
-
- return ret;
-}
-
-void
-syms_of_overlays (void)
-{
- defsubr (&Soverlay_parent);
- defsubr (&Soverlay_info);
- defsubr (&Soverlays_in_buffer);
- defsubr (&Soverlay_tree_at);
-}
diff --git a/src/overlays.h b/src/overlays.h
deleted file mode 100644
index d5d85a9..0000000
--- a/src/overlays.h
+++ /dev/null
@@ -1,75 +0,0 @@
-
-#ifndef OVERLAYS_H
-#define OVERLAYS_H
-
-#include
-#include "lisp.h"
-
-extern struct Lisp_Overlay OVERLAY_SENTINEL_NODE;
-
-extern struct Lisp_Overlay * OVERLAY_SENTINEL;
-
-struct overlay_entry
-{
- Lisp_Object overlay;
- Lisp_Object string;
- EMACS_INT priority;
- bool after_string_p;
-};
-
-void
-overlay_tree_insert (struct Lisp_Overlay **tree,
- struct Lisp_Overlay *node);
-
-void
-overlay_tree_delete (struct Lisp_Overlay **tree,
- struct Lisp_Overlay *node);
-
-void
-overlay_tree_drop_all (struct buffer *buf);
-
-Lisp_Object
-buffer_of_overlay (Lisp_Object overlay);
-
-ptrdiff_t
-overlay_tree_all (struct Lisp_Overlay *tree, ptrdiff_t *vec_size,
- Lisp_Object **vec_ptr);
-
-ptrdiff_t
-overlay_tree_at (struct Lisp_Overlay *tree, ptrdiff_t pos,
- ptrdiff_t *next_ptr, ptrdiff_t *prev_ptr,
- ptrdiff_t *vec_size, Lisp_Object **vec_ptr,
- bool chane_req);
-
-void
-overlay_tree_zero_size_at (struct Lisp_Overlay *tree, ptrdiff_t pos,
- Lisp_Object hit_list);
-
-ptrdiff_t
-overlay_tree_adjust_for_insert (struct Lisp_Overlay *tree,
- ptrdiff_t from_char,
- ptrdiff_t to_char,
- ptrdiff_t from_byte,
- ptrdiff_t to_byte,
- bool before);
-
-ptrdiff_t
-overlay_tree_adjust_for_delete (struct Lisp_Overlay *tree,
- ptrdiff_t from_char, ptrdiff_t from_byte,
- ptrdiff_t to_char, ptrdiff_t to_byte);
-
-ptrdiff_t
-overlay_tree_adjust_for_replace (struct Lisp_Overlay *tree,
- ptrdiff_t from_char,
- ptrdiff_t from_byte,
- ptrdiff_t old_chars,
- ptrdiff_t old_bytes,
- ptrdiff_t new_chars,
- ptrdiff_t new_bytes);
-
-ptrdiff_t
-overlay_tree_at (struct Lisp_Overlay *tree, Lisp_Object **vecp,
- ptrdiff_t pos);
-
-
-#endif /* OVERLAYS_H */
diff --git a/src/xdisp.c b/src/xdisp.c
index 785853e..1289515 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -315,9 +315,6 @@ along with GNU Emacs. If not, see . */
#include "fontset.h"
#include "blockinput.h"
#include "xwidget.h"
-#if defined(NEW_OVERLAYS) || defined(BOTH_OVERLAYS)
-#include "overlays.h"
-#endif
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
@@ -5502,7 +5499,7 @@ handle_composition_prop (struct it *it)
/* The following structure is used to record overlay strings for
later sorting in load_overlay_strings. */
-#if !defined(NEW_OVERLAYS) && !defined(BOTH_OVERLAYS)
+
struct overlay_entry
{
Lisp_Object overlay;
@@ -5510,7 +5507,7 @@ struct overlay_entry
EMACS_INT priority;
bool after_string_p;
};
-#endif
+
/* Set up iterator IT from overlay strings at its current position.
Called from handle_stop. */
@@ -5712,7 +5709,6 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
if (charpos <= 0)
charpos = IT_CHARPOS (*it);
-#ifndef NEW_OVERLAYS
/* Append the overlay string STRING of overlay OVERLAY to vector
`entries' which has size `size' and currently contains `n'
elements. AFTER_P means STRING is an after-string of
@@ -5819,30 +5815,6 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
}
#undef RECORD_OVERLAY_STRING
-#ifdef BOTH_OVERLAYS
- struct window *sw = XWINDOW (window);
- ptrdiff_t n1, ii, jj;
- struct overlay_entry entriesbuf1[20];
- ptrdiff_t size1 = ARRAYELTS (entriesbuf);
- overlay_tree_load_overlays (current_buffer->overlays_root,
- charpos, &size, &entries, &n, sw);
- eassert (n1 == n);
- for (ii = 0; ii < n; ii++) {
- bool found = false;
- struct overlay_entry *oe1 = &entries[ii];
- for (jj = 0; jj < n; jj++) {
- struct overlay_entry *oe2 = &entries1[jj];
- if (*oe1 == *oe2)
- found = true;
- }
- eassert (found);
- }
-#endif
-#else /* if NEW_OVERLAYS is defined */
- struct window *sw = XWINDOW (window);
- overlay_tree_load_overlays (current_buffer->overlays_root,
- charpos, &size, &entries, &n, sw);
-#endif
/* Sort entries. */
if (n > 1)
@@ -5868,7 +5840,6 @@ load_overlay_strings (struct it *it, ptrdiff_t charpos)
}
-
/* Get the first chunk of overlay strings at IT's current buffer
position, or at CHARPOS if that is > 0. Value is true if at
least one overlay string was found. */
diff --git a/test/lisp/overlay-tests.el b/test/lisp/overlay-tests.el
deleted file mode 100644
index 407aaee..0000000
--- a/test/lisp/overlay-tests.el
+++ /dev/null
@@ -1,70 +0,0 @@
-
-
-
-(require 'ert)
-
-(ert-deftest overlay-create-test ()
- " "
- (with-temp-buffer
- (insert "blueberrypancakes")
- (let ((o1 (make-overlay 4 9)))
- (should-not (overlay-get o1 'face))
- (should (overlayp o1))
- (should (= (overlay-start o1) 4))
- (should (= (overlay-end o1) 9))
- (should (eq (overlay-buffer o1) (current-buffer)))
- (let ((b (current-buffer)))
- (with-temp-buffer
- (should (eq (overlay-buffer o1) b))))
- (should (= (length (overlays-in (point-min) (point-max))) 1))
- (should (eq (car (overlays-in (point-min) (point-max))) o1)))))
-
-
-(ert-deftest overlay-move-test ()
- " "
- (with-temp-buffer
- (insert "blueberrypancakes")
- (let ((o1 (make-overlay 4 9)))
- ;; Test a "normal" move
- (should (= (overlay-start o1) 4))
- (should (= (overlay-end o1) 9))
- (should (eq (overlay-buffer o1) (current-buffer)))
- (move-overlay o1 3 10)
- (should (= (overlay-start o1) 3))
- (should (= (overlay-end o1) 10))
- (let ((b (current-buffer)))
- (with-temp-buffer
- (insert "blueberry")
- (move-overlay o1 2 4)
- (should (eq (overlay-buffer o1) b))
- (move-overlay o1 2 4 (current-buffer))
- (should (eq (overlay-buffer o1) (current-buffer)))
- (should (= (overlay-start o1) 2))
- (should (= (overlay-end o1) 4))))
- (move-overlay o1 1 50 (current-buffer))
- (should (eq (overlay-buffer o1) (current-buffer)))
- (should (= (overlay-start o1) 1))
- (should (= (overlay-end o1) (point-max))))))
-
-(ert-deftest overlay-front-advance-test ()
- (with-temp-buffer
- (insert "blueberrypancakes")
- (let ((o1 (make-overlay 1 5 nil t))
- (o2 (make-overlay 1 5))
- (str "creamy "))
- (goto-char (point-min))
- (insert str)
- (should (= (overlay-start o2) 1))
- (should (= (overlay-start o1) (1+ (length str)))))))
-
-(ert-deftest overlay-rear-advance-test ()
- (with-temp-buffer
- (insert "blueberrypancakes")
- (let ((o1 (make-overlay 7 18 nil nil t))
- (o2 (make-overlay 7 18))
- (str " for dinner"))
- (should (= (point-max) 18))
- (goto-char (point-max))
- (insert str)
- (should (= (overlay-end o1) (point-max)))
- (should (= (overlay-end o2) 18)))))