Merge branch 'master_fixed_rangeset' into rel_1_2_beta

funbringer · funbringer · commit 549f211669b3 · 2016-11-01T15:12:45.000+03:00
diff --git a/src/rangeset.c b/src/rangeset.c
@@ -44,22 +44,6 @@ irange_eq_bounds(IndexRange a, IndexRange b)
 		   (irange_upper(a) == irange_upper(b));
 }
 
-/* Comapre lossiness factor of two ranges */
-ir_cmp_lossiness
-irange_cmp_lossiness(IndexRange a, IndexRange b)
-{
-	if (is_irange_lossy(a) == is_irange_lossy(b))
-		return IR_EQ_LOSSINESS;
-
-	if (is_irange_lossy(a))
-		return IR_A_LOSSY;
-
-	if (is_irange_lossy(b))
-		return IR_B_LOSSY;
-
-	return IR_EQ_LOSSINESS;
-}
-
 
 /* Make union of two conjuncted ranges */
 IndexRange
@@ -161,6 +145,10 @@ irange_union_internal(IndexRange first,
 					  IndexRange second,
 					  List **new_iranges)
 {
+	/* Assert that both IndexRanges are valid */
+	Assert(is_irange_valid(first));
+	Assert(is_irange_valid(second));
+
 	/* Swap 'first' and 'second' if order is incorrect */
 	if (irange_lower(first) > irange_lower(second))
 	{
@@ -332,39 +320,48 @@ irange_list_intersection(List *a, List *b)
 		IndexRange	ra = lfirst_irange(ca),
 					rb = lfirst_irange(cb);
 
+		/* Assert that both IndexRanges are valid */
+		Assert(is_irange_valid(ra));
+		Assert(is_irange_valid(rb));
+
 		/* Only care about intersecting ranges */
 		if (iranges_intersect(ra, rb))
 		{
-			IndexRange	intersect, last;
+			IndexRange	ir_intersection;
+			bool		glued_to_last = false;
 
 			/*
 			 * Get intersection and try to "glue" it to
-			 * previous range, put it separately otherwise.
+			 * last irange, put it separately otherwise.
 			 */
-			intersect = irange_intersection_simple(ra, rb);
+			ir_intersection = irange_intersection_simple(ra, rb);
 			if (result != NIL)
 			{
-				last = llast_irange(result);
-				if (iranges_adjoin(last, intersect) &&
-					is_irange_lossy(last) == is_irange_lossy(intersect))
-				{
-					llast(result) = alloc_irange(irange_union_simple(last, intersect));
-				}
-				else
+				IndexRange last = llast_irange(result);
+
+				/* Test if we can glue 'last' and 'ir_intersection' */
+				if (irange_cmp_lossiness(last, ir_intersection) == IR_EQ_LOSSINESS &&
+					iranges_adjoin(last, ir_intersection))
 				{
-					result = lappend_irange(result, intersect);
+					IndexRange ir_union = irange_union_simple(last, ir_intersection);
+
+					/* We allocate a new IndexRange for safety */
+					llast(result) = alloc_irange(ir_union);
+
+					/* Successfully glued them */
+					glued_to_last = true;
 				}
 			}
-			else
-			{
-				result = lappend_irange(result, intersect);
-			}
+
+			/* Append IndexRange if we couldn't glue it */
+			if (!glued_to_last)
+				result = lappend_irange(result, ir_intersection);
 		}
 
 		/*
-		 * Fetch next ranges. We use upper bound of current range to determine
-		 * which lists to fetch, since lower bound of next range is greater (or
-		 * equal) to upper bound of current.
+		 * Fetch next iranges. We use upper bound of current irange to
+		 * determine which lists to fetch, since lower bound of next
+		 * irange is greater (or equal) to upper bound of current.
 		 */
 		if (irange_upper(ra) <= irange_upper(rb))
 			ca = lnext(ca);
diff --git a/src/rangeset.h b/src/rangeset.h
@@ -44,6 +44,14 @@ typedef struct {
 #define irange_upper(irange)	( (uint32) (irange.upper & IRANGE_BONDARY_MASK) )
 
 
+#define lfirst_irange(lc)				( *(IndexRange *) lfirst(lc) )
+#define lappend_irange(list, irange)	( lappend((list), alloc_irange(irange)) )
+#define lcons_irange(irange, list)		( lcons(alloc_irange(irange), (list)) )
+#define list_make1_irange(irange)		( lcons_irange(irange, NIL) )
+#define llast_irange(list)				( lfirst_irange(list_tail(list)) )
+#define linitial_irange(list)			( lfirst_irange(list_head(list)) )
+
+
 inline static IndexRange
 make_irange(uint32 lower, uint32 upper, bool lossy)
 {
@@ -82,25 +90,17 @@ irb_pred(uint32 boundary)
 	return 0;
 }
 
-/* Return predecessor or IRANGE_BONDARY_MASK */
+/* Return successor or IRANGE_BONDARY_MASK */
 inline static uint32
 irb_succ(uint32 boundary)
 {
 	if (boundary >= IRANGE_BONDARY_MASK)
-		return boundary;
+		return IRANGE_BONDARY_MASK;
 
 	return boundary + 1;
 }
 
 
-#define lfirst_irange(lc)				( *(IndexRange *) lfirst(lc) )
-#define lappend_irange(list, irange)	( lappend((list), alloc_irange(irange)) )
-#define lcons_irange(irange, list)		( lcons(alloc_irange(irange), (list)) )
-#define list_make1_irange(irange)		( lcons(alloc_irange(irange), NIL) )
-#define llast_irange(list)				( lfirst_irange(list_tail(list)) )
-#define linitial_irange(list)			( lfirst_irange(list_head(list)) )
-
-
 /* Result of function irange_cmp_lossiness() */
 typedef enum
 {
@@ -109,12 +109,27 @@ typedef enum
 	IR_B_LOSSY				/* IndexRange 'b' is lossy ('a' is not) */
 } ir_cmp_lossiness;
 
+/* Comapre lossiness factor of two IndexRanges */
+inline static ir_cmp_lossiness
+irange_cmp_lossiness(IndexRange a, IndexRange b)
+{
+	if (is_irange_lossy(a) == is_irange_lossy(b))
+		return IR_EQ_LOSSINESS;
+
+	if (is_irange_lossy(a))
+		return IR_A_LOSSY;
+
+	if (is_irange_lossy(b))
+		return IR_B_LOSSY;
+
+	return IR_EQ_LOSSINESS;
+}
+
 
 /* Various traits */
 bool iranges_intersect(IndexRange a, IndexRange b);
 bool iranges_adjoin(IndexRange a, IndexRange b);
 bool irange_eq_bounds(IndexRange a, IndexRange b);
-ir_cmp_lossiness irange_cmp_lossiness(IndexRange a, IndexRange b);
 
 /* Basic operations on IndexRanges */
 IndexRange irange_union_simple(IndexRange a, IndexRange b);
diff --git a/tests/cmocka/Makefile b/tests/cmocka/Makefile
@@ -26,3 +26,6 @@ build_extension:
 
 clean:
 	rm -f $(OBJ) $(TEST_BIN)
+
+check: all
+	./$(TEST_BIN)
diff --git a/tests/cmocka/rangeset_tests.c b/tests/cmocka/rangeset_tests.c
