/* Markers: examining, setting and deleting.
- Copyright (C) 1985, 1997-1998, 2001-2011 Free Software Foundation, Inc.
+ Copyright (C) 1985, 1997-1998, 2001-2013 Free Software Foundation,
+ Inc.
This file is part of GNU Emacs.
#include <config.h>
-#include <setjmp.h>
+
#include "lisp.h"
-#include "buffer.h"
#include "character.h"
+#include "buffer.h"
/* Record one cached position found recently by
buf_charpos_to_bytepos or buf_bytepos_to_charpos. */
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 <lekktu@gmail.com> 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;
-static void byte_char_debug_check (struct buffer *, ptrdiff_t, ptrdiff_t);
+ 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 */
+
+#define byte_char_debug_check(b, charpos, bytepos) do { } while (0)
+
+#endif /* MARKER_DEBUG */
void
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) \
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)
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);
if (charpos - best_below < best_above - charpos)
{
- int record = charpos - best_below > 5000;
+ bool record = charpos - best_below > 5000;
while (best_below != 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);
}
else
{
- int record = best_above - charpos > 5000;
+ bool record = best_above - charpos > 5000;
while (best_above != 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);
#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;
-}
-\f
-/* 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. */
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) \
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)
{
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);
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)
{
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);
}
else
{
- int record = best_above_byte - bytepos > 5000;
+ bool record = best_above_byte - bytepos > 5000;
while (best_above_byte > 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);
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;
return Qnil;
}
-\f
-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)
{
m->next = BUF_MARKERS (b);
BUF_MARKERS (b) = m;
}
-
- return marker;
}
-/* This version of Fset_marker won't let the position
- be outside the visible part. */
+/* 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. */
-Lisp_Object
-set_marker_restricted (Lisp_Object marker, Lisp_Object pos, Lisp_Object buffer)
+static struct buffer *
+live_buffer (Lisp_Object buffer)
{
- register ptrdiff_t charno;
- register ptrdiff_t bytepos;
- register struct buffer *b;
- register struct Lisp_Marker *m;
+ struct buffer *b;
- 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))
+ if (NILP (buffer))
{
- unchain_marker (m);
- return marker;
+ b = current_buffer;
+ eassert (BUFFER_LIVE_P (b));
}
-
- 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;
- }
- }
-
- /* 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;
+ if (!BUFFER_LIVE_P (b))
+ b = NULL;
}
+ return 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);
+/* Internal function to set MARKER in BUFFER at POSITION. Non-zero
+ RESTRICTED means limit the POSITION by the visible part of BUFFER. */
- /* Every character is at least one byte. */
- if (charno > bytepos)
- abort ();
+static Lisp_Object
+set_marker_internal (Lisp_Object marker, Lisp_Object position,
+ Lisp_Object buffer, bool restricted)
+{
+ struct Lisp_Marker *m;
+ struct buffer *b = live_buffer (buffer);
- m->bytepos = bytepos;
- m->charpos = charno;
+ CHECK_MARKER (marker);
+ m = XMARKER (marker);
- if (m->buffer != b)
+ /* 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);
- m->buffer = b;
- m->next = BUF_MARKERS (b);
- BUF_MARKERS (b) = m;
+ m->bytepos = XMARKER (position)->bytepos;
+ m->charpos = XMARKER (position)->charpos;
}
+ else
+ {
+ register ptrdiff_t charpos, bytepos;
+
+ CHECK_NUMBER_COERCE_MARKER (position);
+ charpos = clip_to_bounds (restricted ? BUF_BEGV (b) : BUF_BEG (b),
+ XINT (position),
+ restricted ? BUF_ZV (b) : BUF_Z (b));
+ bytepos = buf_charpos_to_bytepos (b, charpos);
+ attach_marker (m, b, charpos, bytepos);
+ }
return marker;
}
-\f
+
+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);
+}
+
+/* Like the above, but won't let the position be outside the visible part. */
+
+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
+ if (b)
{
- 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;
- }
+ 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)));
}
-
- if (charpos < BUF_BEGV (b))
- charpos = BUF_BEGV (b);
- if (charpos > BUF_ZV (b))
- charpos = BUF_ZV (b);
- if (bytepos < BUF_BEGV_BYTE (b))
- bytepos = BUF_BEGV_BYTE (b);
- if (bytepos > BUF_ZV_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)
- {
- unchain_marker (m);
- m->buffer = b;
- m->next = BUF_MARKERS (b);
- BUF_MARKERS (b) = m;
- }
-
+ else
+ unchain_marker (m);
return marker;
}
-\f
-/* 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;
+ register struct buffer *b = marker->buffer;
- if (EQ (BVAR (b, name), Qnil))
- abort ();
-
- 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. */
if (!buf)
error ("Marker does not point anywhere");
+ eassert (BUF_BEG (buf) <= m->charpos && m->charpos <= BUF_Z (buf));
+
return m->charpos;
}
{
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;
}
\f
DEFUN ("copy-marker", Fcopy_marker, Scopy_marker, 0, 2, 0,
(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)
{
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 */
\f
void
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;
}