range-set: unify the coalescing step and tidy the algebra

With the algebra now in its own module, clean up a few things the move
made easy to see.  None changes behavior: the unit tests added with the
extraction still pass.

 - sort_and_merge_range_set() and range_set_union() open-coded the same
   final step: append a range, merging it into the previous one when they
   overlap or touch, and dropping it when empty.  Pull that into
   range_set_append_coalesce() and call it from both.  union stays a
   linear 2-way merge, and sort_and_merge stays an in-place,
   allocation-free compaction: range_set_grow() does not reallocate while
   the output count stays within the original allocation, and the reset
   output cursor never passes the read index, so appending over the same
   buffer never clobbers a range not yet read.

 - Name the temporaries in range_set_map_across_diff(): "untouched" for
   the ranges the diff did not touch and "shifted" for those after they
   are shifted to the parent side, so the three-step body reads as its
   own description.

 - Drop the dead "if (!rs) return" guard in range_set_check_invariants(),
   now static with a single, always-valid caller; explain the range_cmp()
   comment (start is long, and narrowing the difference to int could flip
   the sign); and const-qualify ranges_overlap().

No functional change intended.

Signed-off-by: Michael Montalbo <mmontalbo@gmail.com>

Author: mmontalbo

range-set.c

@@ -57,7 +57,10 @@ static int range_cmp(const void *_r, const void *_s)
 	const struct range *r = _r;
 	const struct range *s = _s;
 
-	/* this could be simply 'return r.start-s.start', but for the types */
+	/*
+	 * Not "r->start - s->start": start is long, and narrowing the
+	 * difference to int could overflow and flip the sign.
+	 */
 	if (r->start == s->start)
 		return 0;
 	if (r->start < s->start)
@@ -72,9 +75,6 @@ static void range_set_check_invariants(struct range_set *rs)
 {
 	unsigned int i;
 
-	if (!rs)
-		return;
-
 	if (rs->nr)
 		assert(rs->ranges[0].start < rs->ranges[0].end);
 
@@ -84,27 +84,43 @@ static void range_set_check_invariants(struct range_set *rs)
 	}
 }
 
+/*
+ * Append [start, end) to rs, coalescing it with the last range when they
+ * overlap or touch, and dropping it when empty.  The caller must append in
+ * nondecreasing start order, so rs stays sorted.  This is the shared
+ * canonicalizing step for building a range set from an already-ordered
+ * stream, whether into a fresh set or in place over the same buffer.
+ */
+static void range_set_append_coalesce(struct range_set *rs, long start, long end)
+{
+	if (start == end)
+		return;
+	if (!rs->nr || rs->ranges[rs->nr-1].end < start) {
+		range_set_grow(rs, 1);
+		rs->ranges[rs->nr].start = start;
+		rs->ranges[rs->nr].end = end;
+		rs->nr++;
+	} else if (rs->ranges[rs->nr-1].end < end) {
+		rs->ranges[rs->nr-1].end = end;
+	}
+}
+
 void sort_and_merge_range_set(struct range_set *rs)
 {
-	unsigned int i;
-	unsigned int o = 0; /* output cursor */
+	unsigned int i, nr = rs->nr;
 
-	QSORT(rs->ranges, rs->nr, range_cmp);
+	QSORT(rs->ranges, nr, range_cmp);
 
-	for (i = 0; i < rs->nr; i++) {
-		if (rs->ranges[i].start == rs->ranges[i].end)
-			continue;
-		if (o > 0 && rs->ranges[i].start <= rs->ranges[o-1].end) {
-			if (rs->ranges[o-1].end < rs->ranges[i].end)
-				rs->ranges[o-1].end = rs->ranges[i].end;
-		} else {
-			rs->ranges[o].start = rs->ranges[i].start;
-			rs->ranges[o].end = rs->ranges[i].end;
-			o++;
-		}
-	}
-	assert(o <= rs->nr);
-	rs->nr = o;
+	/*
+	 * Compact in place.  The output cursor is rs->nr, reset to 0; it
+	 * never overtakes the read index i, and range_set_grow() does not
+	 * reallocate while nr stays within the original count, so appending
+	 * over the same buffer never clobbers an unread range.
+	 */
+	rs->nr = 0;
+	for (i = 0; i < nr; i++)
+		range_set_append_coalesce(rs, rs->ranges[i].start,
+					  rs->ranges[i].end);
 
 	range_set_check_invariants(rs);
 }
@@ -115,7 +131,6 @@ void range_set_union(struct range_set *out,
 	unsigned int i = 0, j = 0;
 	struct range *ra = a->ranges;
 	struct range *rb = b->ranges;
-	/* cannot make an alias of out->ranges: it may change during grow */
 
 	assert(out->nr == 0);
 	while (i < a->nr || j < b->nr) {
@@ -133,16 +148,8 @@ void range_set_union(struct range_set *out,
 			new_range = &ra[i++];
 		else                       /* a exhausted */
 			new_range = &rb[j++];
-		if (new_range->start == new_range->end)
-			; /* empty range */
-		else if (!out->nr || out->ranges[out->nr-1].end < new_range->start) {
-			range_set_grow(out, 1);
-			out->ranges[out->nr].start = new_range->start;
-			out->ranges[out->nr].end = new_range->end;
-			out->nr++;
-		} else if (out->ranges[out->nr-1].end < new_range->end) {
-			out->ranges[out->nr-1].end = new_range->end;
-		}
+		range_set_append_coalesce(out, new_range->start,
+					  new_range->end);
 	}
 }
 
@@ -153,7 +160,7 @@ void range_set_union(struct range_set *out,
 static void range_set_difference(struct range_set *out,
 				  struct range_set *a, struct range_set *b)
 {
-	unsigned int i, j =  0;
+	unsigned int i, j = 0;
 	for (i = 0; i < a->nr; i++) {
 		long start = a->ranges[i].start;
 		long end = a->ranges[i].end;
@@ -212,7 +219,7 @@ void diff_ranges_release(struct diff_ranges *diff)
  * its parent-side counterpart (range_set_map_across_diff).
  */
 
-static int ranges_overlap(struct range *a, struct range *b)
+static int ranges_overlap(const struct range *a, const struct range *b)
 {
 	return !(a->end <= b->start || b->end <= a->start);
 }
@@ -285,16 +292,16 @@ void range_set_map_across_diff(struct range_set *out,
 			       struct diff_ranges **touched_out)
 {
 	struct diff_ranges *touched = xmalloc(sizeof(*touched));
-	struct range_set tmp1 = { 0 };
-	struct range_set tmp2 = { 0 };
+	struct range_set untouched = { 0 };
+	struct range_set shifted = { 0 };
 
 	diff_ranges_init(touched);
 	diff_ranges_filter_touched(touched, diff, rs);
-	range_set_difference(&tmp1, rs, &touched->target);
-	range_set_shift_diff(&tmp2, &tmp1, diff);
-	range_set_union(out, &tmp2, &touched->parent);
-	range_set_release(&tmp1);
-	range_set_release(&tmp2);
+	range_set_difference(&untouched, rs, &touched->target);
+	range_set_shift_diff(&shifted, &untouched, diff);
+	range_set_union(out, &shifted, &touched->parent);
+	range_set_release(&untouched);
+	range_set_release(&shifted);
 
 	*touched_out = touched;
 }