DO_MARKERS -> Pip's FOR_EACH_MARKER

* src/marker-vector.h (DO_MARKERS_OF_VECTOR, DO_MARKERS): Remove.
(build_for_each_marker_data, next_marker_entry):
(FOR_EACH_MARKER_OF_VECTOR, FOR_EACH_MARKER): New.

* .clang-format (IndentPPDirectives): Add new FOR_EACH_ macros.

* src/alloc.c (unchain_dead_markers):
* src/buffer.c (Fkill_buffer, Fbuffer_swap_text)
(Fset_buffer_multibyte):
* src/coding.c (decode_coding_object, encode_coding_object):
* src/editfns.c (transpose_markers):
* src/marker-vector.c (check_marker_vector, marker_vector_reset)
(marker_vector_adjust_for_insert)
(marker_vector_adjust_for_replace):
* src/undo.c (record_marker_adjustments): Use FOR_EACH_MARKER.

.clang-format

@@ -9,6 +9,8 @@ ContinuationIndentWidth: 2
 IndentPPDirectives: AfterHash
 PPIndentWidth: 1
 ForEachMacros:
+  - FOR_EACH_MARKER
+  - FOR_EACH_MARKER_OF_VECTOR
   - FOR_EACH_TAIL
   - FOR_EACH_TAIL_SAFE
   - FOR_EACH_LIVE_BUFFER

src/alloc.c

@@ -7114,12 +7114,11 @@ sweep_symbols (void)
 static void
 unchain_dead_markers (struct buffer *b)
 {
-  DO_MARKERS (b, m)
+  FOR_EACH_MARKER (b, m)
     {
       if (!vectorlike_marked_p (&m->header))
 	marker_vector_remove (XVECTOR (BUF_MARKERS (b)), m);
     }
-  END_DO_MARKERS;
 }
 
 NO_INLINE /* For better stack traces */

src/buffer.c

@@ -2073,12 +2073,11 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       /* Unchain all markers that belong to this indirect buffer.
 	 Don't unchain the markers that belong to the base buffer
 	 or its other indirect buffers.  */
-      DO_MARKERS (b, m)
+      FOR_EACH_MARKER (b, m)
 	{
 	  if (m->buffer == b)
 	    marker_vector_remove (XVECTOR (BUF_MARKERS (b)), m);
 	}
-      END_DO_MARKERS;
 
      /* Intervals should be owned by the base buffer (Bug#16502).  */
       i = buffer_intervals (b);
@@ -2618,7 +2617,7 @@ results, see Info node `(elisp)Swapping Text'.  */)
   other_buffer->text->end_unchanged = other_buffer->text->gpt;
   swap_buffer_overlays (current_buffer, other_buffer);
   {
-    DO_MARKERS (current_buffer, m)
+    FOR_EACH_MARKER (current_buffer, m)
       {
 	if (m->buffer == other_buffer)
 	  m->buffer = current_buffer;
@@ -2627,8 +2626,7 @@ results, see Info node `(elisp)Swapping Text'.  */)
 	     BUF_MARKERS(buf) should either be for `buf' or dead.  */
 	  eassert (!m->buffer);
       }
-    END_DO_MARKERS;
+    FOR_EACH_MARKER (other_buffer, m)
-    DO_MARKERS (other_buffer, m)
       {
 	if (m->buffer == current_buffer)
 	  m->buffer = other_buffer;
@@ -2637,7 +2635,6 @@ results, see Info node `(elisp)Swapping Text'.  */)
 	     BUF_MARKERS(buf) should either be for `buf' or dead.  */
 	  eassert (!m->buffer);
       }
-    END_DO_MARKERS;
   }
 
   { /* Some of the C code expects that both window markers of a
@@ -2746,12 +2743,11 @@ current buffer is cleared.  */)
       GPT = GPT_BYTE;
       TEMP_SET_PT_BOTH (PT_BYTE, PT_BYTE);
 
-      DO_MARKERS (current_buffer, tail)
+      FOR_EACH_MARKER (current_buffer, tail)
 	{
 	  const ptrdiff_t bytepos = marker_vector_bytepos (tail);
 	  marker_vector_set_charpos (tail, bytepos);
 	}
-      END_DO_MARKERS;
 
       /* Convert multibyte form of 8-bit characters to unibyte.  */
       pos = BEG;
@@ -2901,13 +2897,12 @@ current buffer is cleared.  */)
 	TEMP_SET_PT_BOTH (position, byte);
       }
 
-      DO_MARKERS (current_buffer, tail)
+      FOR_EACH_MARKER (current_buffer, tail)
 	{
 	  ptrdiff_t bytepos = marker_vector_bytepos (tail);
 	  bytepos = advance_to_char_boundary (bytepos);
 	  marker_vector_set_charpos (tail, BYTE_TO_CHAR (bytepos));
 	}
-      END_DO_MARKERS;
 
       /* Do this last, so it can calculate the new correspondences
 	 between chars and bytes.  */

src/coding.c

@@ -8118,14 +8118,13 @@ decode_coding_object (struct coding_system *coding,
 	move_gap_both (from, from_byte);
       if (BASE_EQ (src_object, dst_object))
 	{
-	  DO_MARKERS (current_buffer, tail)
+	  FOR_EACH_MARKER (current_buffer, tail)
 	    {
 	      const ptrdiff_t charpos = marker_vector_charpos (tail);
 	      tail->need_adjustment
 		= charpos == (tail->insertion_type ? from : to);
 	      need_marker_adjustment |= tail->need_adjustment;
 	    }
-	  END_DO_MARKERS;
 	  saved_pt = PT, saved_pt_byte = PT_BYTE;
 	  TEMP_SET_PT_BOTH (from, from_byte);
 	  current_buffer->text->inhibit_shrinking = true;
@@ -8250,7 +8249,7 @@ decode_coding_object (struct coding_system *coding,
 
       if (need_marker_adjustment)
 	{
-	  DO_MARKERS (current_buffer, tail)
+	  FOR_EACH_MARKER (current_buffer, tail)
 	    {
 	      if (tail->need_adjustment)
 		{
@@ -8269,7 +8268,6 @@ decode_coding_object (struct coding_system *coding,
 		    }
 		}
 	    }
-	  END_DO_MARKERS;
 	}
     }
 
@@ -8340,14 +8338,13 @@ encode_coding_object (struct coding_system *coding,
   if (BASE_EQ (src_object, dst_object) && BUFFERP (src_object))
     {
       same_buffer = true;
-      DO_MARKERS (XBUFFER (src_object), tail)
+      FOR_EACH_MARKER (XBUFFER (src_object), tail)
 	{
 	  const ptrdiff_t charpos = marker_vector_charpos (tail);
 	  tail->need_adjustment
 	    = charpos == (tail->insertion_type ? from : to);
 	  need_marker_adjustment |= tail->need_adjustment;
 	}
-      END_DO_MARKERS;
     }
 
   if (! NILP (CODING_ATTR_PRE_WRITE (attrs)))
@@ -8505,7 +8502,7 @@ encode_coding_object (struct coding_system *coding,
 
       if (need_marker_adjustment)
 	{
-	  DO_MARKERS (current_buffer, tail)
+	  FOR_EACH_MARKER (current_buffer, tail)
 	    {
 	      if (tail->need_adjustment)
 		{
@@ -8524,7 +8521,6 @@ encode_coding_object (struct coding_system *coding,
 		    }
 		}
 	    }
-	  END_DO_MARKERS;
 	}
     }
 

src/editfns.c

@@ -4438,7 +4438,7 @@ transpose_markers (ptrdiff_t start1, ptrdiff_t end1,
   amt1 = (end2 - start2) + (start2 - end1);
   amt2 = (end1 - start1) + (start2 - end1);
 
-  DO_MARKERS (current_buffer, marker)
+  FOR_EACH_MARKER (current_buffer, marker)
     {
       mpos = marker_vector_charpos (marker);
       if (mpos >= start1 && mpos < end2)
@@ -4452,7 +4452,6 @@ transpose_markers (ptrdiff_t start1, ptrdiff_t end1,
 	}
       marker_vector_set_charpos (marker, mpos);
     }
-  END_DO_MARKERS;
 }
 
 DEFUN ("transpose-regions", Ftranspose_regions, Stranspose_regions, 4, 5,

src/marker-vector.c

@@ -164,9 +164,8 @@ check_marker_vector (struct Lisp_Vector *v, bool allocating)
 
   size_t nused = 0;
   Lisp_Object mv = make_lisp_ptr (v, Lisp_Vectorlike);
-  DO_MARKERS_OF_VECTOR (mv, m)
+  FOR_EACH_MARKER_OF_VECTOR (mv, m)
     {
-      eassert (m->entry == e_);
       eassert (m->buffer != NULL);
       if (!allocating)
 	{
@@ -175,7 +174,6 @@ check_marker_vector (struct Lisp_Vector *v, bool allocating)
 	}
       ++nused;
     }
-  END_DO_MARKERS;
 
   eassert ((nused + nfree) * MARKER_VECTOR_ENTRY_SIZE
 	   + MARKER_VECTOR_HEADER_SIZE == gc_vsize (v));
@@ -280,13 +278,12 @@ marker_vector_remove (struct Lisp_Vector *v, struct Lisp_Marker *m)
 void
 marker_vector_reset (struct buffer *b)
 {
-  DO_MARKERS (b, m)
+  FOR_EACH_MARKER (b, m)
     {
       const struct Lisp_Vector *v = XVECTOR (BUF_MARKERS (m->buffer));
       m->entry = - XFIXNUM (CHARPOS (v, m->entry));
       m->buffer = NULL;
     }
-  END_DO_MARKERS;
   BUF_MARKERS (b) = Qnil;
 }
 
@@ -344,7 +341,7 @@ marker_vector_adjust_for_insert (struct buffer *b,
 {
   const ptrdiff_t nchars = to_charpos - from_charpos;
   struct Lisp_Vector *v = XVECTOR (BUF_MARKERS (b));
-  DO_MARKERS (b, m)
+  FOR_EACH_MARKER (b, m)
     {
       const ptrdiff_t charpos = XFIXNUM (CHARPOS (v, m->entry));
       if (charpos == from_charpos)
@@ -355,7 +352,6 @@ marker_vector_adjust_for_insert (struct buffer *b,
       else if (charpos > from_charpos)
 	CHARPOS (v, m->entry) = make_fixnum (charpos + nchars);
     }
-  END_DO_MARKERS;
 }
 
 /* Adjust marker positions of buffer Bs for a replacement of text at
@@ -371,7 +367,7 @@ marker_vector_adjust_for_replace (struct buffer *b,
   const ptrdiff_t diff_nchars = new_nchars - old_nchars;
   const ptrdiff_t old_to_charpos = from_charpos + old_nchars;
   struct Lisp_Vector *v = XVECTOR (BUF_MARKERS (b));
-  DO_MARKERS (b, m)
+  FOR_EACH_MARKER (b, m)
     {
       const ptrdiff_t charpos = XFIXNUM (CHARPOS (v, m->entry));
       if (charpos >= old_to_charpos)
@@ -379,5 +375,4 @@ marker_vector_adjust_for_replace (struct buffer *b,
       else if (charpos > from_charpos)
 	CHARPOS (v, m->entry) = make_fixnum (from_charpos);
     }
-  END_DO_MARKERS;
 }

src/marker-vector.h

@@ -39,27 +39,55 @@ enum
   MARKER_VECTOR_ENTRY_SIZE = 2,
 };
 
-/* Iterate over markers in marker vector MV, binding a variable with
+struct for_each_marker_data
-   name M to a pointer to Lisp_Marker.  The loop must be ended
+{
-   with an END_DO_MARKERS.  */
+  ptrdiff_t e;
+  ptrdiff_t end;
+  Lisp_Object m;
+  Lisp_Object mv;
+  bool continued;
+  struct Lisp_Marker *marker;
+};
 
-# define DO_MARKERS_OF_VECTOR(mv, m)					\
+INLINE struct for_each_marker_data
-  for (ptrdiff_t e_ = MARKER_VECTOR_HEADER_SIZE,			\
+build_for_each_marker_data(Lisp_Object mv)
-	 end_ = XFIXNUM (AREF (mv, MARKER_VECTOR_MAX_ENTRY));		\
+{
-       e_ <= end_;							\
+  struct for_each_marker_data ret;
-       e_ += MARKER_VECTOR_ENTRY_SIZE)					\
+  ret.e = MARKER_VECTOR_HEADER_SIZE;
-    {									\
+  ret.end = XFIXNUM (AREF (mv, MARKER_VECTOR_MAX_ENTRY));
-       Lisp_Object m_ = AREF (mv, e_ + MARKER_VECTOR_OFFSET_MARKER);	\
+  ret.m = Qnil;
-       if (MARKERP (m_))						\
+  ret.mv = mv;
-	 {								\
+  ret.marker = NULL;
-            struct Lisp_Marker *m = XMARKER (m_);
+  ret.continued = true;
+  return ret;
+}
 
-/* Iterate over markers of buffer B, binding a variable with name M to a
+INLINE bool
-   pointer to Lisp_Marker.  The loop must be ended with an
+next_marker_entry (struct for_each_marker_data *d)
-   END_DO_MARKERS.  */
+{
+  if (!d->continued)
+    return false;
+  while (d->e <= d->end)
+    {
+      d->m = AREF (d->mv, d->e + MARKER_VECTOR_OFFSET_MARKER);
+      d->e += MARKER_VECTOR_ENTRY_SIZE;
+      if (MARKERP (d->m))
+	{
+	  d->marker = XMARKER (d->m);
+	  d->continued = false;
+	  return true;
+	}
+    }
+  return false;
+}
 
-# define DO_MARKERS(b, m) DO_MARKERS_OF_VECTOR (BUF_MARKERS (b), m)
+#define FOR_EACH_MARKER_OF_VECTOR(v, m)					\
-# define END_DO_MARKERS }}
+  for (struct for_each_marker_data d_ = build_for_each_marker_data (v); \
+       next_marker_entry (&d_);)					\
+    for (struct Lisp_Marker *m = d_.marker; !d_.continued; d_.continued = true)
+
+#define FOR_EACH_MARKER(b, m) \
+  FOR_EACH_MARKER_OF_VECTOR (BUF_MARKERS (b), m)
 
 Lisp_Object make_marker_vector (void);
 Lisp_Object alloc_marker_vector (ptrdiff_t len);

src/undo.c

@@ -128,7 +128,7 @@ record_marker_adjustments (ptrdiff_t from, ptrdiff_t to)
 {
   prepare_record ();
 
-  DO_MARKERS (current_buffer, m)
+  FOR_EACH_MARKER (current_buffer, m)
     {
       ptrdiff_t charpos = marker_vector_charpos (m);
       eassert (charpos <= Z);
@@ -154,7 +154,6 @@ record_marker_adjustments (ptrdiff_t from, ptrdiff_t to)
             }
         }
     }
-  END_DO_MARKERS;
 }
 
 /* Record that a deletion is about to take place, of the characters in