From dbd20bbdb75ac38edaf719e398be24310db6dfa3 Mon Sep 17 00:00:00 2001
From: Alasdair Kergon <agk@redhat.com>
Date: Thu, 22 Apr 2010 03:24:24 +0000
Subject: [PATCH] Still not satisfactory...

---
 libdm/regex/parse_rx.c | 69 ++++++++++++++++++++++++++++++------------
 1 file changed, 50 insertions(+), 19 deletions(-)

diff --git a/libdm/regex/parse_rx.c b/libdm/regex/parse_rx.c
index fb8b886ad..fb9406de4 100644
--- a/libdm/regex/parse_rx.c
+++ b/libdm/regex/parse_rx.c
@@ -331,17 +331,19 @@ static struct rx_node *_or_term(struct parse_sp *ps)
 
 /*----------------------------------------------------------------*/
 
+#define L_OR_R(a) (leftmost ? (a)->left : (a)->right)
+
 /*
  * The optimiser spots common prefixes on either side of an 'or' node, and
  * lifts them outside the 'or' with a 'cat'.
  */
-static unsigned _leftmost_depth(struct rx_node *r)
+static unsigned _depth(struct rx_node *r, unsigned leftmost)
 {
 	int count = 1;
 
 	while (r->type != CHARSET) {
 		count++;
-		r = r->left;
+		r = L_OR_R(r);
 	}
 
 	return count;
@@ -378,38 +380,69 @@ static int _nodes_equal(struct rx_node *l, struct rx_node *r)
 
 static int _find_leftmost_common(struct rx_node *or,
                                  struct rx_node **l,
-                                 struct rx_node **r)
+                                 struct rx_node **r,
+				 unsigned leftmost)
 {
 	struct rx_node *left = or->left, *right = or->right;
-	unsigned left_depth = _leftmost_depth(left);
-	unsigned right_depth = _leftmost_depth(right);
+	unsigned left_depth = _depth(left, leftmost);
+	unsigned right_depth = _depth(right, leftmost);
 
 	while (left_depth > right_depth) {
-		left = left->left;
+		left = L_OR_R(left);
 		left_depth--;
 	}
 
 	while (right_depth > left_depth) {
-		right = right->left;
+		right = L_OR_R(right);
 		right_depth--;
 	}
 
 	while (left_depth) {
 		if (left->type == CAT && right->type == CAT) {
-			if (_nodes_equal(left->left, right->left)) {
+			if (_nodes_equal(L_OR_R(left), L_OR_R(right))) {
 				*l = left;
 				*r = right;
 				return 1;
 			}
 		}
-		left = left->left;
-		right = right->left;
+		left = L_OR_R(left);
+		right = L_OR_R(right);
 		left_depth--;
 	}
 
 	return 0;
 }
 
+static struct rx_node *_exchange_nodes(struct dm_pool *mem, struct rx_node *r, struct rx_node *left_cat, struct rx_node *right_cat, unsigned leftmost)
+{
+	struct rx_node *new_r, *new_cat;
+
+	/* FIXME Clean up leftmost */
+	if (leftmost) {
+		new_r = r->right;
+		new_cat = _node(mem, CAT, left_cat->left, r);
+		if (!new_cat)
+			return_NULL;
+		new_r->left = new_cat;
+
+		memcpy(left_cat, left_cat->right, sizeof(*left_cat));
+		r->right = right_cat->right;
+
+		/* FIXME Avoid this */
+		if (new_r->right == right_cat->right)
+			new_r = new_r->left;
+	} else {
+		new_r = _node(mem, CAT, r, right_cat->right);
+		if (!new_r)
+			return_NULL;
+
+		memcpy(left_cat, left_cat->left, sizeof(*left_cat));
+		memcpy(right_cat, right_cat->left, sizeof(*right_cat));
+	}
+
+	return new_r;
+}
+
 static struct rx_node *_pass(struct dm_pool *mem,
                              struct rx_node *r,
                              int *changed)
@@ -445,16 +478,12 @@ static struct rx_node *_pass(struct dm_pool *mem,
 		{
 			struct rx_node *left, *right;
 
-			if (_find_leftmost_common(r, &left, &right)) {
-				struct rx_node *new_r = _node(mem, CAT, left->left, r);
+			if (_find_leftmost_common(r, &left, &right, 1)) {
+				r = _exchange_nodes(mem, r, left, right, 1);
 
-				if (!new_r)
-					return_NULL;
-
-				memcpy(left, left->right, sizeof(*left));
-				memcpy(right, right->right, sizeof(*right));
-
-				r = new_r;
+				*changed = 1;
+			} else if (_find_leftmost_common(r, &left, &right, 0)) {
+				r = _exchange_nodes(mem, r, left, right, 0);
 
 				*changed = 1;
 			}
@@ -473,6 +502,8 @@ static struct rx_node *_optimise(struct dm_pool *mem, struct rx_node *r)
 	/*
 	 * We're looking for (or (... (cat <foo> a)) (... (cat <foo> b)))
 	 * and want to turn it into (cat <foo> (or (... a) (... b)))
+	 *
+	 * (fa)|(fb) becomes f(a|b)
 	 */
 
 	/*