X-Git-Url: http://git.hcoop.net/bpt/emacs.git/blobdiff_plain/226c3633fdc0a259aa73aa9e6555cd42dd9f168c..d64d97e537301a9787a569982d67eed8ecdabe8b:/src/marker.c
diff --git a/src/marker.c b/src/marker.c
index a059987aa5..0d992c0abf 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -1,5 +1,6 @@
/* Markers: examining, setting and deleting.
- Copyright (C) 1985, 1997-1998, 2001-2012 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1997-1998, 2001-2013 Free Software Foundation,
+ Inc.
This file is part of GNU Emacs.
@@ -18,7 +19,7 @@ along with GNU Emacs. If not, see . */
#include
-#include
+
#include "lisp.h"
#include "character.h"
#include "buffer.h"
@@ -29,9 +30,44 @@ along with GNU Emacs. If not, see . */
static ptrdiff_t cached_charpos;
static ptrdiff_t cached_bytepos;
static struct buffer *cached_buffer;
-static int cached_modiff;
+static EMACS_INT cached_modiff;
+
+/* Juanma Barranquero reported ~3x increased
+ bootstrap time when byte_char_debug_check is enabled; so this
+ is never turned on by --enable-checking configure option. */
+
+#ifdef MARKER_DEBUG
+
+extern int count_markers (struct buffer *) EXTERNALLY_VISIBLE;
+extern ptrdiff_t verify_bytepos (ptrdiff_t charpos) EXTERNALLY_VISIBLE;
+
+static void
+byte_char_debug_check (struct buffer *b, ptrdiff_t charpos, ptrdiff_t bytepos)
+{
+ ptrdiff_t nchars;
+
+ if (NILP (BVAR (b, enable_multibyte_characters)))
+ return;
+
+ if (bytepos > BUF_GPT_BYTE (b))
+ nchars
+ = multibyte_chars_in_text (BUF_BEG_ADDR (b),
+ BUF_GPT_BYTE (b) - BUF_BEG_BYTE (b))
+ + multibyte_chars_in_text (BUF_GAP_END_ADDR (b),
+ bytepos - BUF_GPT_BYTE (b));
+ else
+ nchars = multibyte_chars_in_text (BUF_BEG_ADDR (b),
+ bytepos - BUF_BEG_BYTE (b));
+
+ if (charpos - 1 != nchars)
+ emacs_abort ();
+}
+
+#else /* not MARKER_DEBUG */
-static void byte_char_debug_check (struct buffer *, ptrdiff_t, ptrdiff_t);
+#define byte_char_debug_check(b, charpos, bytepos) do { } while (0)
+
+#endif /* MARKER_DEBUG */
void
clear_charpos_cache (struct buffer *b)
@@ -47,22 +83,20 @@ clear_charpos_cache (struct buffer *b)
and everywhere there is a marker. So we find the one of these places
that is closest to the specified position, and scan from there. */
-/* charpos_to_bytepos returns the byte position corresponding to CHARPOS. */
-
-/* This macro is a subroutine of charpos_to_bytepos.
+/* This macro is a subroutine of buf_charpos_to_bytepos.
Note that it is desirable that BYTEPOS is not evaluated
except when we really want its value. */
#define CONSIDER(CHARPOS, BYTEPOS) \
{ \
ptrdiff_t this_charpos = (CHARPOS); \
- int changed = 0; \
+ bool changed = 0; \
\
if (this_charpos == charpos) \
{ \
ptrdiff_t value = (BYTEPOS); \
- if (byte_debug_flag) \
- byte_char_debug_check (b, charpos, value); \
+ \
+ byte_char_debug_check (b, charpos, value); \
return value; \
} \
else if (this_charpos > charpos) \
@@ -86,38 +120,14 @@ clear_charpos_cache (struct buffer *b)
if (best_above - best_below == best_above_byte - best_below_byte) \
{ \
ptrdiff_t value = best_below_byte + (charpos - best_below); \
- if (byte_debug_flag) \
- byte_char_debug_check (b, charpos, value); \
+ \
+ byte_char_debug_check (b, charpos, value); \
return value; \
} \
} \
}
-static void
-byte_char_debug_check (struct buffer *b, ptrdiff_t charpos, ptrdiff_t bytepos)
-{
- ptrdiff_t nchars = 0;
-
- if (bytepos > BUF_GPT_BYTE (b))
- {
- nchars = multibyte_chars_in_text (BUF_BEG_ADDR (b),
- BUF_GPT_BYTE (b) - BUF_BEG_BYTE (b));
- nchars += multibyte_chars_in_text (BUF_GAP_END_ADDR (b),
- bytepos - BUF_GPT_BYTE (b));
- }
- else
- nchars = multibyte_chars_in_text (BUF_BEG_ADDR (b),
- bytepos - BUF_BEG_BYTE (b));
-
- if (charpos - 1 != nchars)
- abort ();
-}
-
-ptrdiff_t
-charpos_to_bytepos (ptrdiff_t charpos)
-{
- return buf_charpos_to_bytepos (current_buffer, charpos);
-}
+/* Return the byte position corresponding to CHARPOS in B. */
ptrdiff_t
buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
@@ -126,8 +136,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
ptrdiff_t best_above, best_above_byte;
ptrdiff_t best_below, best_below_byte;
- if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
- abort ();
+ eassert (BUF_BEG (b) <= charpos && charpos <= BUF_Z (b));
best_above = BUF_Z (b);
best_above_byte = BUF_Z_BYTE (b);
@@ -175,7 +184,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
if (charpos - best_below < best_above - charpos)
{
- int record = charpos - best_below > 5000;
+ bool record = charpos - best_below > 5000;
while (best_below != charpos)
{
@@ -187,15 +196,9 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
cache the correspondence by creating a marker here.
It will last until the next GC. */
if (record)
- {
- Lisp_Object marker, buffer;
- marker = Fmake_marker ();
- XSETBUFFER (buffer, b);
- set_marker_both (marker, buffer, best_below, best_below_byte);
- }
+ build_marker (b, best_below, best_below_byte);
- if (byte_debug_flag)
- byte_char_debug_check (b, charpos, best_below_byte);
+ byte_char_debug_check (b, best_below, best_below_byte);
cached_buffer = b;
cached_modiff = BUF_MODIFF (b);
@@ -206,7 +209,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
}
else
{
- int record = best_above - charpos > 5000;
+ bool record = best_above - charpos > 5000;
while (best_above != charpos)
{
@@ -218,15 +221,9 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
cache the correspondence by creating a marker here.
It will last until the next GC. */
if (record)
- {
- Lisp_Object marker, buffer;
- marker = Fmake_marker ();
- XSETBUFFER (buffer, b);
- set_marker_both (marker, buffer, best_above, best_above_byte);
- }
+ build_marker (b, best_above, best_above_byte);
- if (byte_debug_flag)
- byte_char_debug_check (b, charpos, best_above_byte);
+ byte_char_debug_check (b, best_above, best_above_byte);
cached_buffer = b;
cached_modiff = BUF_MODIFF (b);
@@ -239,28 +236,6 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
#undef CONSIDER
-/* Used for debugging: recompute the bytepos corresponding to CHARPOS
- in the simplest, most reliable way. */
-
-extern ptrdiff_t verify_bytepos (ptrdiff_t charpos) EXTERNALLY_VISIBLE;
-ptrdiff_t
-verify_bytepos (ptrdiff_t charpos)
-{
- ptrdiff_t below = 1;
- ptrdiff_t below_byte = 1;
-
- while (below != charpos)
- {
- below++;
- BUF_INC_POS (current_buffer, below_byte);
- }
-
- return below_byte;
-}
-
-/* buf_bytepos_to_charpos returns the char position corresponding to
- BYTEPOS. */
-
/* This macro is a subroutine of buf_bytepos_to_charpos.
It is used when BYTEPOS is actually the byte position. */
@@ -272,8 +247,8 @@ verify_bytepos (ptrdiff_t charpos)
if (this_bytepos == bytepos) \
{ \
ptrdiff_t value = (CHARPOS); \
- if (byte_debug_flag) \
- byte_char_debug_check (b, value, bytepos); \
+ \
+ byte_char_debug_check (b, value, bytepos); \
return value; \
} \
else if (this_bytepos > bytepos) \
@@ -297,13 +272,15 @@ verify_bytepos (ptrdiff_t charpos)
if (best_above - best_below == best_above_byte - best_below_byte) \
{ \
ptrdiff_t value = best_below + (bytepos - best_below_byte); \
- if (byte_debug_flag) \
- byte_char_debug_check (b, value, bytepos); \
+ \
+ byte_char_debug_check (b, value, bytepos); \
return value; \
} \
} \
}
+/* Return the character position corresponding to BYTEPOS in B. */
+
ptrdiff_t
buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
{
@@ -311,8 +288,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
ptrdiff_t best_above, best_above_byte;
ptrdiff_t best_below, best_below_byte;
- if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
- abort ();
+ eassert (BUF_BEG_BYTE (b) <= bytepos && bytepos <= BUF_Z_BYTE (b));
best_above = BUF_Z (b);
best_above_byte = BUF_Z_BYTE (b);
@@ -351,7 +327,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
if (bytepos - best_below_byte < best_above_byte - bytepos)
{
- int record = bytepos - best_below_byte > 5000;
+ bool record = bytepos - best_below_byte > 5000;
while (best_below_byte < bytepos)
{
@@ -365,15 +341,9 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
But don't do it if BUF_MARKERS is nil;
that is a signal from Fset_buffer_multibyte. */
if (record && BUF_MARKERS (b))
- {
- Lisp_Object marker, buffer;
- marker = Fmake_marker ();
- XSETBUFFER (buffer, b);
- set_marker_both (marker, buffer, best_below, best_below_byte);
- }
+ build_marker (b, best_below, best_below_byte);
- if (byte_debug_flag)
- byte_char_debug_check (b, best_below, bytepos);
+ byte_char_debug_check (b, best_below, best_below_byte);
cached_buffer = b;
cached_modiff = BUF_MODIFF (b);
@@ -384,7 +354,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
}
else
{
- int record = best_above_byte - bytepos > 5000;
+ bool record = best_above_byte - bytepos > 5000;
while (best_above_byte > bytepos)
{
@@ -398,15 +368,9 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
But don't do it if BUF_MARKERS is nil;
that is a signal from Fset_buffer_multibyte. */
if (record && BUF_MARKERS (b))
- {
- Lisp_Object marker, buffer;
- marker = Fmake_marker ();
- XSETBUFFER (buffer, b);
- set_marker_both (marker, buffer, best_above, best_above_byte);
- }
+ build_marker (b, best_above, best_above_byte);
- if (byte_debug_flag)
- byte_char_debug_check (b, best_above, bytepos);
+ byte_char_debug_check (b, best_above, best_above_byte);
cached_buffer = b;
cached_modiff = BUF_MODIFF (b);
@@ -435,7 +399,7 @@ Returns nil if MARKER points into a dead buffer. */)
does not preserve the buffer from being GC'd (it's weak), so
markers have to be unlinked from their buffer as soon as the buffer
is killed. */
- eassert (!NILP (BVAR (XBUFFER (buf), name)));
+ eassert (BUFFER_LIVE_P (XBUFFER (buf)));
return buf;
}
return Qnil;
@@ -452,66 +416,22 @@ Returns nil if MARKER points nowhere. */)
return Qnil;
}
-
-DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
- doc: /* Position MARKER before character number POSITION in BUFFER.
-BUFFER defaults to the current buffer.
-If POSITION is nil, makes marker point nowhere.
-Then it no longer slows down editing in any buffer.
-Returns MARKER. */)
- (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
-{
- register ptrdiff_t charno;
- register ptrdiff_t bytepos;
- register struct buffer *b;
- register struct Lisp_Marker *m;
- CHECK_MARKER (marker);
- m = XMARKER (marker);
-
- /* If position is nil or a marker that points nowhere,
- make this marker point nowhere. */
- if (NILP (position)
- || (MARKERP (position) && !XMARKER (position)->buffer))
- {
- unchain_marker (m);
- return marker;
- }
+/* Change M so it points to B at CHARPOS and BYTEPOS. */
- if (NILP (buffer))
- b = current_buffer;
+static void
+attach_marker (struct Lisp_Marker *m, struct buffer *b,
+ ptrdiff_t charpos, ptrdiff_t bytepos)
+{
+ /* In a single-byte buffer, two positions must be equal.
+ Otherwise, every character is at least one byte. */
+ if (BUF_Z (b) == BUF_Z_BYTE (b))
+ eassert (charpos == bytepos);
else
- {
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
- }
-
- /* Optimize the special case where we are copying the position
- of an existing marker, and MARKER is already in the same buffer. */
- if (MARKERP (position) && b == XMARKER (position)->buffer
- && b == m->buffer)
- {
- m->bytepos = XMARKER (position)->bytepos;
- m->charpos = XMARKER (position)->charpos;
- return marker;
- }
-
- CHECK_NUMBER_COERCE_MARKER (position);
- charno = clip_to_bounds (BUF_BEG (b), XINT (position), BUF_Z (b));
- bytepos = buf_charpos_to_bytepos (b, charno);
-
- /* Every character is at least one byte. */
- if (charno > bytepos)
- abort ();
+ eassert (charpos <= bytepos);
+ m->charpos = charpos;
m->bytepos = bytepos;
- m->charpos = charno;
if (m->buffer != b)
{
@@ -520,231 +440,197 @@ Returns MARKER. */)
m->next = BUF_MARKERS (b);
BUF_MARKERS (b) = m;
}
+}
- return marker;
+/* If BUFFER is nil, return current buffer pointer. Next, check
+ whether BUFFER is a buffer object and return buffer pointer
+ corresponding to BUFFER if BUFFER is live, or NULL otherwise. */
+
+static struct buffer *
+live_buffer (Lisp_Object buffer)
+{
+ struct buffer *b;
+
+ if (NILP (buffer))
+ {
+ b = current_buffer;
+ eassert (BUFFER_LIVE_P (b));
+ }
+ else
+ {
+ CHECK_BUFFER (buffer);
+ b = XBUFFER (buffer);
+ if (!BUFFER_LIVE_P (b))
+ b = NULL;
+ }
+ return b;
}
-/* This version of Fset_marker won't let the position
- be outside the visible part. */
+/* Internal function to set MARKER in BUFFER at POSITION. Non-zero
+ RESTRICTED means limit the POSITION by the visible part of BUFFER. */
-Lisp_Object
-set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
+static Lisp_Object
+set_marker_internal (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer, bool restricted)
{
- register ptrdiff_t charno;
- register ptrdiff_t bytepos;
- register struct buffer *b;
- register struct Lisp_Marker *m;
+ struct Lisp_Marker *m;
+ struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- /* If position is nil or a marker that points nowhere,
- make this marker point nowhere. */
- if (NILP (pos)
- || (MARKERP (pos) && !XMARKER (pos)->buffer))
+ /* Set MARKER to point nowhere if BUFFER is dead, or
+ POSITION is nil or a marker points to nowhere. */
+ if (NILP (position)
+ || (MARKERP (position) && !XMARKER (position)->buffer)
+ || !b)
+ unchain_marker (m);
+
+ /* Optimize the special case where we are copying the position of
+ an existing marker, and MARKER is already in the same buffer. */
+ else if (MARKERP (position) && b == XMARKER (position)->buffer
+ && b == m->buffer)
{
- unchain_marker (m);
- return marker;
+ m->bytepos = XMARKER (position)->bytepos;
+ m->charpos = XMARKER (position)->charpos;
}
- if (NILP (buffer))
- b = current_buffer;
else
{
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
+ register ptrdiff_t charpos, bytepos;
+
+ /* Do not use CHECK_NUMBER_COERCE_MARKER because we
+ don't want to call buf_charpos_to_bytepos if POSTION
+ is a marker and so we know the bytepos already. */
+ if (INTEGERP (position))
+ charpos = XINT (position), bytepos = -1;
+ else if (MARKERP (position))
{
- unchain_marker (m);
- return marker;
+ charpos = XMARKER (position)->charpos;
+ bytepos = XMARKER (position)->bytepos;
}
- }
+ else
+ wrong_type_argument (Qinteger_or_marker_p, position);
- /* Optimize the special case where we are copying the position
- of an existing marker, and MARKER is already in the same buffer. */
- if (MARKERP (pos) && b == XMARKER (pos)->buffer
- && b == m->buffer)
- {
- m->bytepos = XMARKER (pos)->bytepos;
- m->charpos = XMARKER (pos)->charpos;
- return marker;
- }
+ charpos = clip_to_bounds
+ (restricted ? BUF_BEGV (b) : BUF_BEG (b), charpos,
+ restricted ? BUF_ZV (b) : BUF_Z (b));
+ if (bytepos == -1)
+ bytepos = buf_charpos_to_bytepos (b, charpos);
+ else
+ bytepos = clip_to_bounds
+ (restricted ? BUF_BEGV_BYTE (b) : BUF_BEG_BYTE (b),
+ bytepos, restricted ? BUF_ZV_BYTE (b) : BUF_Z_BYTE (b));
- CHECK_NUMBER_COERCE_MARKER (pos);
- charno = clip_to_bounds (BUF_BEGV (b), XINT (pos), BUF_ZV (b));
- bytepos = buf_charpos_to_bytepos (b, charno);
+ attach_marker (m, b, charpos, bytepos);
+ }
+ return marker;
+}
- /* Every character is at least one byte. */
- if (charno > bytepos)
- abort ();
+DEFUN ("set-marker", Fset_marker, Sset_marker, 2, 3, 0,
+ doc: /* Position MARKER before character number POSITION in BUFFER,
+which defaults to the current buffer. If POSITION is nil,
+makes marker point nowhere so it no longer slows down
+editing in any buffer. Returns MARKER. */)
+ (Lisp_Object marker, Lisp_Object position, Lisp_Object buffer)
+{
+ return set_marker_internal (marker, position, buffer, 0);
+}
- m->bytepos = bytepos;
- m->charpos = charno;
+/* Like the above, but won't let the position be outside the visible part. */
- if (m->buffer != b)
- {
- unchain_marker (m);
- m->buffer = b;
- m->next = BUF_MARKERS (b);
- BUF_MARKERS (b) = m;
- }
-
- return marker;
+Lisp_Object
+set_marker_restricted (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer)
+{
+ return set_marker_internal (marker, position, buffer, 1);
}
-
+
/* Set the position of MARKER, specifying both the
character position and the corresponding byte position. */
Lisp_Object
-set_marker_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
+set_marker_both (Lisp_Object marker, Lisp_Object buffer,
+ ptrdiff_t charpos, ptrdiff_t bytepos)
{
- register struct buffer *b;
register struct Lisp_Marker *m;
+ register struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- if (NILP (buffer))
- b = current_buffer;
+ if (b)
+ attach_marker (m, b, charpos, bytepos);
else
- {
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
- }
-
- /* In a single-byte buffer, the two positions must be equal. */
- if (BUF_Z (b) == BUF_Z_BYTE (b)
- && charpos != bytepos)
- abort ();
- /* Every character is at least one byte. */
- if (charpos > bytepos)
- abort ();
-
- m->bytepos = bytepos;
- m->charpos = charpos;
-
- if (m->buffer != b)
- {
- unchain_marker (m);
- m->buffer = b;
- m->next = BUF_MARKERS (b);
- BUF_MARKERS (b) = m;
- }
-
+ unchain_marker (m);
return marker;
}
-/* This version of set_marker_both won't let the position
- be outside the visible part. */
+/* Like the above, but won't let the position be outside the visible part. */
Lisp_Object
-set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer, ptrdiff_t charpos, ptrdiff_t bytepos)
+set_marker_restricted_both (Lisp_Object marker, Lisp_Object buffer,
+ ptrdiff_t charpos, ptrdiff_t bytepos)
{
- register struct buffer *b;
register struct Lisp_Marker *m;
+ register struct buffer *b = live_buffer (buffer);
CHECK_MARKER (marker);
m = XMARKER (marker);
- if (NILP (buffer))
- b = current_buffer;
- else
- {
- CHECK_BUFFER (buffer);
- b = XBUFFER (buffer);
- /* If buffer is dead, set marker to point nowhere. */
- if (EQ (BVAR (b, name), Qnil))
- {
- unchain_marker (m);
- return marker;
- }
- }
-
- charpos = clip_to_bounds (BUF_BEGV (b), charpos, BUF_ZV (b));
- bytepos = clip_to_bounds (BUF_BEGV_BYTE (b), bytepos, BUF_ZV_BYTE (b));
-
- /* In a single-byte buffer, the two positions must be equal. */
- if (BUF_Z (b) == BUF_Z_BYTE (b)
- && charpos != bytepos)
- abort ();
- /* Every character is at least one byte. */
- if (charpos > bytepos)
- abort ();
-
- m->bytepos = bytepos;
- m->charpos = charpos;
-
- if (m->buffer != b)
+ if (b)
{
- unchain_marker (m);
- m->buffer = b;
- m->next = BUF_MARKERS (b);
- BUF_MARKERS (b) = m;
+ attach_marker
+ (m, b,
+ clip_to_bounds (BUF_BEGV (b), charpos, BUF_ZV (b)),
+ clip_to_bounds (BUF_BEGV_BYTE (b), bytepos, BUF_ZV_BYTE (b)));
}
-
+ else
+ unchain_marker (m);
return marker;
}
-
-/* Remove MARKER from the chain of whatever buffer it is in.
- Leave it "in no buffer".
- This is called during garbage collection,
- so we must be careful to ignore and preserve mark bits,
- including those in chain fields of markers. */
+/* Remove MARKER from the chain of whatever buffer it is in,
+ leaving it points to nowhere. This is called during garbage
+ collection, so we must be careful to ignore and preserve
+ mark bits, including those in chain fields of markers. */
void
unchain_marker (register struct Lisp_Marker *marker)
{
- register struct Lisp_Marker *tail, *prev, *next;
- register struct buffer *b;
-
- b = marker->buffer;
- if (b == 0)
- return;
-
- if (EQ (BVAR (b, name), Qnil))
- abort ();
+ register struct buffer *b = marker->buffer;
- marker->buffer = 0;
-
- tail = BUF_MARKERS (b);
- prev = NULL;
- while (tail)
+ if (b)
{
- next = tail->next;
-
- if (marker == tail)
- {
- if (!prev)
- {
- BUF_MARKERS (b) = next;
- /* Deleting first marker from the buffer's chain. Crash
- if new first marker in chain does not say it belongs
- to the same buffer, or at least that they have the same
- base buffer. */
- if (next && b->text != next->buffer->text)
- abort ();
- }
- else
- prev->next = next;
- /* We have removed the marker from the chain;
- no need to scan the rest of the chain. */
- return;
- }
- else
- prev = tail;
- tail = next;
+ register struct Lisp_Marker *tail, **prev;
+
+ /* No dead buffers here. */
+ eassert (BUFFER_LIVE_P (b));
+
+ marker->buffer = NULL;
+ prev = &BUF_MARKERS (b);
+
+ for (tail = BUF_MARKERS (b); tail; prev = &tail->next, tail = *prev)
+ if (marker == tail)
+ {
+ if (*prev == BUF_MARKERS (b))
+ {
+ /* Deleting first marker from the buffer's chain. Crash
+ if new first marker in chain does not say it belongs
+ to the same buffer, or at least that they have the same
+ base buffer. */
+ if (tail->next && b->text != tail->next->buffer->text)
+ emacs_abort ();
+ }
+ *prev = tail->next;
+ /* We have removed the marker from the chain;
+ no need to scan the rest of the chain. */
+ break;
+ }
+
+ /* Error if marker was not in it's chain. */
+ eassert (tail != NULL);
}
-
- /* Marker was not in its chain. */
- abort ();
}
/* Return the char position of marker MARKER, as a C integer. */
@@ -758,6 +644,8 @@ marker_position (Lisp_Object marker)
if (!buf)
error ("Marker does not point anywhere");
+ eassert (BUF_BEG (buf) <= m->charpos && m->charpos <= BUF_Z (buf));
+
return m->charpos;
}
@@ -768,15 +656,13 @@ marker_byte_position (Lisp_Object marker)
{
register struct Lisp_Marker *m = XMARKER (marker);
register struct buffer *buf = m->buffer;
- register ptrdiff_t i = m->bytepos;
if (!buf)
error ("Marker does not point anywhere");
- if (i < BUF_BEG_BYTE (buf) || i > BUF_Z_BYTE (buf))
- abort ();
+ eassert (BUF_BEG_BYTE (buf) <= m->bytepos && m->bytepos <= BUF_Z_BYTE (buf));
- return i;
+ return m->bytepos;
}
DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 0, 2, 0,
@@ -829,20 +715,21 @@ DEFUN ("buffer-has-markers-at", Fbuffer_has_markers_at, Sbuffer_has_markers_at,
(Lisp_Object position)
{
register struct Lisp_Marker *tail;
- register ptrdiff_t charno;
+ register ptrdiff_t charpos;
- charno = clip_to_bounds (BEG, XINT (position), Z);
+ charpos = clip_to_bounds (BEG, XINT (position), Z);
for (tail = BUF_MARKERS (current_buffer); tail; tail = tail->next)
- if (tail->charpos == charno)
+ if (tail->charpos == charpos)
return Qt;
return Qnil;
}
+#ifdef MARKER_DEBUG
+
/* For debugging -- count the markers in buffer BUF. */
-extern int count_markers (struct buffer *) EXTERNALLY_VISIBLE;
int
count_markers (struct buffer *buf)
{
@@ -854,6 +741,26 @@ count_markers (struct buffer *buf)
return total;
}
+
+/* For debugging -- recompute the bytepos corresponding
+ to CHARPOS in the simplest, most reliable way. */
+
+ptrdiff_t
+verify_bytepos (ptrdiff_t charpos)
+{
+ ptrdiff_t below = 1;
+ ptrdiff_t below_byte = 1;
+
+ while (below != charpos)
+ {
+ below++;
+ BUF_INC_POS (current_buffer, below_byte);
+ }
+
+ return below_byte;
+}
+
+#endif /* MARKER_DEBUG */
void
syms_of_marker (void)
@@ -865,8 +772,4 @@ syms_of_marker (void)
defsubr (&Smarker_insertion_type);
defsubr (&Sset_marker_insertion_type);
defsubr (&Sbuffer_has_markers_at);
-
- DEFVAR_BOOL ("byte-debug-flag", byte_debug_flag,
- doc: /* Non-nil enables debugging checks in byte/char position conversions. */);
- byte_debug_flag = 0;
}