X-Git-Url: https://git.hcoop.net/bpt/emacs.git/blobdiff_plain/f2b31075364c17574955493ec5effa7baa12ee24..7cded46f2bef23f86041cc883618ac82b6dbfe61:/src/marker.c

diff --git a/src/marker.c b/src/marker.c
index 2b78282e69..69be4faec3 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -1,5 +1,5 @@
 /* Markers: examining, setting and deleting.
-   Copyright (C) 1985, 1997-1998, 2001-2011  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1997-1998, 2001-2012  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -18,10 +18,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #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.  */
@@ -29,9 +29,44 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 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 *, ptrdiff_t, ptrdiff_t);
+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 */
+
+#define byte_char_debug_check(b, charpos, bytepos) do { } while (0)
+
+#endif /* MARKER_DEBUG */
 
 void
 clear_charpos_cache (struct buffer *b)
@@ -56,13 +91,13 @@ clear_charpos_cache (struct buffer *b)
 #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,33 +121,13 @@ 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)
 {
@@ -127,7 +142,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
   ptrdiff_t best_below, best_below_byte;
 
   if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
-    abort ();
+    emacs_abort ();
 
   best_above = BUF_Z (b);
   best_above_byte = BUF_Z_BYTE (b);
@@ -175,7 +190,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 +202,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 +215,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 +227,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,25 +242,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.  */
 
@@ -272,8 +256,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,8 +281,8 @@ 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;							\
 	}								\
     }									\
@@ -312,7 +296,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
   ptrdiff_t best_below, best_below_byte;
 
   if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
-    abort ();
+    emacs_abort ();
 
   best_above = BUF_Z (b);
   best_above_byte = BUF_Z_BYTE (b);
@@ -351,7 +335,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 +349,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 +362,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 +376,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 +407,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 +424,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,237 +448,179 @@ Returns MARKER.  */)
       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;
-
-  CHECK_MARKER (marker);
-  m = XMARKER (marker);
+  struct buffer *b;
 
-  /* 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;
 }
-
+
+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
-    {
-      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;
-	}
-    }
-
-  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)
+  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.  */
@@ -764,6 +634,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;
 }
 
@@ -774,15 +646,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,
@@ -835,20 +705,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)
 {
@@ -860,6 +731,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)
@@ -871,8 +762,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;
 }